'''simple docstring'''

import itertools
import random
import unittest

import numpy as np

from transformers import ASTFeatureExtractor
from transformers.testing_utils import require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


SCREAMING_SNAKE_CASE__											=     random.Random()

if is_torch_available():
     import torch







def 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase=1.0	,		__UpperCamelCase=None	,		__UpperCamelCase=None					)->				Union[str, Any]:
      if rng is None:
            UpperCamelCase       						=      global_rng

      UpperCamelCase       						=      []
      for batch_idx in range(shape[0]					):
            values.append([]					)
            for _ in range(shape[1]					):
                  values[-1].append(rng.random() * scale					)

      return values






class        a_		(    unittest.TestCase       ):

  def __init__(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE=7    ,	_SCREAMING_SNAKE_CASE=400    ,	_SCREAMING_SNAKE_CASE=2000    ,	_SCREAMING_SNAKE_CASE=1    ,	_SCREAMING_SNAKE_CASE=0.0    ,	_SCREAMING_SNAKE_CASE=16000    ,	_SCREAMING_SNAKE_CASE=True    ,	_SCREAMING_SNAKE_CASE=True    ,	)						->   int:



        """simple docstring"""






        UpperCamelCase       						=      parent
        UpperCamelCase       						=      batch_size
        UpperCamelCase       						=      min_seq_length
        UpperCamelCase       						=      max_seq_length
        UpperCamelCase       						=      (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
        UpperCamelCase       						=      feature_size
        UpperCamelCase       						=      padding_value
        UpperCamelCase       						=      sampling_rate
        UpperCamelCase       						=      return_attention_mask
        UpperCamelCase       						=      do_normalize

  def 						A__		(   self   )						->   List[str]:



        """simple docstring"""






        return {
            "feature_size": self.feature_size,
            "padding_value": self.padding_value,
            "sampling_rate": self.sampling_rate,
            "return_attention_mask": self.return_attention_mask,
            "do_normalize": self.do_normalize,
        }


  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE=False    ,	_SCREAMING_SNAKE_CASE=False   )						->   int:



        """simple docstring"""






        def _flatten(_SCREAMING_SNAKE_CASE   ):
              return list(itertools.chain(*_SCREAMING_SNAKE_CASE   )   )

        if equal_length:
              UpperCamelCase       						=      floats_list((self.batch_size, self.max_seq_length)   )
        else:
              # make sure that inputs increase in size
              UpperCamelCase       						=      [
                  _flatten(floats_list((x, self.feature_size)   )   )
                  for x in range(self.min_seq_length    ,	self.max_seq_length    ,	self.seq_length_diff   )
              ]

        if numpify:
              UpperCamelCase       						=      [np.asarray(_SCREAMING_SNAKE_CASE   ) for x in speech_inputs]

        return speech_inputs






@require_torch
@require_torchaudio
class        a_		(    lowerCamelCase			, unittest.TestCase       ):
  lowercase  	=   ASTFeatureExtractor

  def 						A__		(   self   )						->   int:



        """simple docstring"""






        UpperCamelCase       						=      ASTFeatureExtractionTester(self   )

  def 						A__		(   self   )						->   List[str]:



        """simple docstring"""






        UpperCamelCase       						=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
        # create three inputs of length 800, 1000, and 1200
        UpperCamelCase       						=      [floats_list((1, x)   )[0] for x in range(800    ,	1400    ,	200   )]
        UpperCamelCase       						=      [np.asarray(_SCREAMING_SNAKE_CASE   ) for speech_input in speech_inputs]

        # Test not batched input
        UpperCamelCase       						=      feat_extract(speech_inputs[0]    ,	return_tensors="""np"""   ).input_values
        UpperCamelCase       						=      feat_extract(np_speech_inputs[0]    ,	return_tensors="""np"""   ).input_values
        self.assertTrue(np.allclose(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	atol=1e-3   )   )

        # Test batched
        UpperCamelCase       						=      feat_extract(_SCREAMING_SNAKE_CASE    ,	padding=_SCREAMING_SNAKE_CASE    ,	return_tensors="""np"""   ).input_values
        UpperCamelCase       						=      feat_extract(_SCREAMING_SNAKE_CASE    ,	padding=_SCREAMING_SNAKE_CASE    ,	return_tensors="""np"""   ).input_values
        for enc_seq_a, enc_seq_a in zip(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   ):
              self.assertTrue(np.allclose(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	atol=1e-3   )   )

        # Test 2-D numpy arrays are batched.
        UpperCamelCase       						=      [floats_list((1, x)   )[0] for x in (800, 800, 800)]
        UpperCamelCase       						=      np.asarray(_SCREAMING_SNAKE_CASE   )
        UpperCamelCase       						=      feat_extract(_SCREAMING_SNAKE_CASE    ,	return_tensors="""np"""   ).input_values
        UpperCamelCase       						=      feat_extract(_SCREAMING_SNAKE_CASE    ,	return_tensors="""np"""   ).input_values
        for enc_seq_a, enc_seq_a in zip(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   ):
              self.assertTrue(np.allclose(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	atol=1e-3   )   )

  @require_torch
  def 						A__		(   self   )						->   str:



        """simple docstring"""






        import torch

        UpperCamelCase       						=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
        UpperCamelCase       						=      np.random.rand(100   ).astype(np.floataa   )
        UpperCamelCase       						=      np_speech_inputs.tolist()

        for inputs in [py_speech_inputs, np_speech_inputs]:
              UpperCamelCase       						=      feature_extractor.pad([{"""input_values""": inputs}]    ,	return_tensors="""np"""   )
              self.assertTrue(np_processed.input_values.dtype == np.floataa   )
              UpperCamelCase       						=      feature_extractor.pad([{"""input_values""": inputs}]    ,	return_tensors="""pt"""   )
              self.assertTrue(pt_processed.input_values.dtype == torch.floataa   )

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE   )						->   Any:



        """simple docstring"""






        from datasets import load_dataset

        UpperCamelCase       						=      load_dataset("""hf-internal-testing/librispeech_asr_dummy"""    ,	"""clean"""    ,	split="""validation"""   )
        # automatic decoding with librispeech
        UpperCamelCase       						=      ds.sort("""id"""   ).select(range(_SCREAMING_SNAKE_CASE   )   )[:num_samples]["""audio"""]

        return [x["array"] for x in speech_samples]


  @require_torch
  def 						A__		(   self   )						->   List[Any]:



        """simple docstring"""






        UpperCamelCase       						=      torch.tensor(
            [-0.9_8_9_4, -1.2_7_7_6, -0.9_0_6_6, -1.2_7_7_6, -0.9_3_4_9, -1.2_6_0_9, -1.0_3_8_6, -1.2_7_7_6,
             -1.1_5_6_1, -1.2_7_7_6, -1.2_0_5_2, -1.2_7_2_3, -1.2_1_9_0, -1.2_1_3_2, -1.2_7_7_6, -1.1_1_3_3,
             -1.1_9_5_3, -1.1_3_4_3, -1.1_5_8_4, -1.2_2_0_3, -1.1_7_7_0, -1.2_4_7_4, -1.2_3_8_1, -1.1_9_3_6,
             -0.9_2_7_0, -0.8_3_1_7, -0.8_0_4_9, -0.7_7_0_6, -0.7_5_6_5, -0.7_8_6_9]   )
        # fmt: on

        UpperCamelCase       						=      self._load_datasamples(1   )
        UpperCamelCase       						=      ASTFeatureExtractor()
        UpperCamelCase       						=      feature_extractor(_SCREAMING_SNAKE_CASE    ,	return_tensors="""pt"""   ).input_values
        self.assertEquals(input_values.shape    ,	(1, 1024, 128)   )
        self.assertTrue(torch.allclose(input_values[0, 0, :30]    ,	_SCREAMING_SNAKE_CASE    ,	atol=1e-4   )   )








'''simple docstring'''

from math import factorial







def 					lowercase__				(   __UpperCamelCase = 20					)->				int:
      UpperCamelCase       						=      2 * n  # middle entry of odd rows starting at row 3 is the solution for n = 1,
      # 2, 3,...
      UpperCamelCase       						=      n // 2

      return int(factorial(__UpperCamelCase					) / (factorial(__UpperCamelCase					) * factorial(n - k					))					)


if __name__ == "__main__":
     import sys

     if len(sys.argv) == 1:
          print(solution(2_0))
     else:
          try:
               SCREAMING_SNAKE_CASE__											=     int(sys.argv[1])
               print(solution(n))
          except ValueError:
               print('Invalid entry - please enter a number.')
