code: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  import itertools
  import random
  import unittest
  
  import numpy as np
  
  from transformers import EncodecFeatureExtractor
  from transformers.testing_utils import require_torch
  from transformers.utils.import_utils import is_torch_available
  
  from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin
  
  
  if is_torch_available():
      import torch
  
  
  A_			  =    random.Random()
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A=1.0    ,       A=None    ,       A=None			):
  
     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
  @require_torch
  class 						__lowerCAmelCase   (			unittest.TestCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		int				,			UpperCamelCase_:		int				,			UpperCamelCase_:		List[str]=7				,			UpperCamelCase_:		int=400				,			UpperCamelCase_:		Dict=2000				,			UpperCamelCase_:		Dict=1				,			UpperCamelCase_:		List[Any]=0.0				,			UpperCamelCase_:		Any=2_4000				,			UpperCamelCase_:		Dict=True				,			):
       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
    def 					UpperCamelCase__   (      self:		List[str]					):
       return {
           "feature_size": self.feature_size,
           "padding_value": self.padding_value,
           "sampling_rate": self.sampling_rate,
           "return_attention_mask": self.return_attention_mask,
       }
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		Optional[int]				,			UpperCamelCase_:		List[Any]=False				,			UpperCamelCase_:		Tuple=False					):
  
  
  
  
  
  
  
       def _flatten(UpperCamelCase_:		int					):
          return list(itertools.chain(*__A					)					)
  
       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(__A					) for x in audio_inputs]
  
       return audio_inputs
  
  
  
  
  @require_torch
  class 						__lowerCAmelCase   (			a__       ,   unittest.TestCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    __lowerCamelCase       :    List[Any]     	=			EncodecFeatureExtractor
    def 					UpperCamelCase__   (      self:		Optional[Any]					):
       UpperCamelCase_     =EnCodecFeatureExtractionTester(self					)
    def 					UpperCamelCase__   (      self:		Optional[int]					):
       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(__A					) for audio_input in audio_inputs]
  
       # Test not batched input
       UpperCamelCase_     =feat_extract(audio_inputs[0]				,			return_tensors="np"					).input_values
       UpperCamelCase_     =feat_extract(np_audio_inputs[0]				,			return_tensors="np"					).input_values
       self.assertTrue(np.allclose(__A				,			__A				,			atol=1e-3					)					)
  
       # Test batched
       UpperCamelCase_     =feat_extract(__A				,			padding=__A				,			return_tensors="np"					).input_values
       UpperCamelCase_     =feat_extract(__A				,			padding=__A				,			return_tensors="np"					).input_values
       for enc_seq_a, enc_seq_a in zip(__A				,			__A					):
          self.assertTrue(np.allclose(__A				,			__A				,			atol=1e-3					)					)
    def 					UpperCamelCase__   (      self:		Any					):
       UpperCamelCase_     =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
       UpperCamelCase_     =np.random.rand(100					).astype(np.floataa					)
       UpperCamelCase_     =np_audio_inputs.tolist()
  
       for inputs in [py_audio_inputs, np_audio_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 					UpperCamelCase__   (      self:		Union[str, Any]				,			UpperCamelCase_:		str					):
       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(__A					)					)[:num_samples]["audio"]
  
       return [x["array"] for x in audio_samples]
    def 					UpperCamelCase__   (      self:		Optional[int]					):
       UpperCamelCase_     =torch.tensor(
           [2.3_8_0_4e-0_3, 2.0_7_5_2e-0_3, 1.9_8_3_6e-0_3, 2.1_0_5_7e-0_3, 1.6_1_7_4e-0_3,
            3.0_5_1_8e-0_4, 9.1_5_5_3e-0_5, 3.3_5_6_9e-0_4, 9.7_6_5_6e-0_4, 1.8_3_1_1e-0_3,
            2.0_1_4_2e-0_3, 2.1_0_5_7e-0_3, 1.7_3_9_5e-0_3, 4.5_7_7_6e-0_4, -3.9_6_7_3e-0_4,
            4.5_7_7_6e-0_4, 1.0_0_7_1e-0_3, 9.1_5_5_3e-0_5, 4.8_8_2_8e-0_4, 1.1_5_9_7e-0_3,
            7.3_2_4_2e-0_4, 9.4_6_0_4e-0_4, 1.8_0_0_5e-0_3, 1.8_3_1_1e-0_3, 8.8_5_0_1e-0_4,
            4.2_7_2_5e-0_4, 4.8_8_2_8e-0_4, 7.3_2_4_2e-0_4, 1.0_9_8_6e-0_3, 2.1_0_5_7e-0_3]					)
       # fmt: on
       UpperCamelCase_     =self._load_datasamples(1					)
       UpperCamelCase_     =EncodecFeatureExtractor()
       UpperCamelCase_     =feature_extractor(__A				,			return_tensors="pt"					).input_values
       self.assertEquals(input_values.shape				,			(1, 1, 9_3680)					)
       self.assertTrue(torch.allclose(input_values[0, 0, :30]				,			__A				,			atol=1e-6					)					)
    def 					UpperCamelCase__   (      self:		List[str]					):
       UpperCamelCase_     =torch.tensor(
           [2.3_8_0_4e-0_3, 2.0_7_5_2e-0_3, 1.9_8_3_6e-0_3, 2.1_0_5_7e-0_3, 1.6_1_7_4e-0_3,
            3.0_5_1_8e-0_4, 9.1_5_5_3e-0_5, 3.3_5_6_9e-0_4, 9.7_6_5_6e-0_4, 1.8_3_1_1e-0_3,
            2.0_1_4_2e-0_3, 2.1_0_5_7e-0_3, 1.7_3_9_5e-0_3, 4.5_7_7_6e-0_4, -3.9_6_7_3e-0_4,
            4.5_7_7_6e-0_4, 1.0_0_7_1e-0_3, 9.1_5_5_3e-0_5, 4.8_8_2_8e-0_4, 1.1_5_9_7e-0_3,
            7.3_2_4_2e-0_4, 9.4_6_0_4e-0_4, 1.8_0_0_5e-0_3, 1.8_3_1_1e-0_3, 8.8_5_0_1e-0_4,
            4.2_7_2_5e-0_4, 4.8_8_2_8e-0_4, 7.3_2_4_2e-0_4, 1.0_9_8_6e-0_3, 2.1_0_5_7e-0_3]					)
       # fmt: on
       UpperCamelCase_     =self._load_datasamples(1					)
       UpperCamelCase_     =[np.tile(input_audio[0][None]				,			reps=(2, 1)					)]
       input_audio[0][1] *= 0.5
       UpperCamelCase_     =EncodecFeatureExtractor(feature_size=2					)
       UpperCamelCase_     =feature_extractor(__A				,			return_tensors="pt"					).input_values
       self.assertEquals(input_values.shape				,			(1, 2, 9_3680)					)
       self.assertTrue(torch.allclose(input_values[0, 0, :30]				,			__A				,			atol=1e-6					)					)
       self.assertTrue(torch.allclose(input_values[0, 1, :30]				,			EXPECTED_INPUT_VALUES * 0.5				,			atol=1e-6					)					)
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		Optional[Any]					):
       UpperCamelCase_     =self._load_datasamples(2					)
       # would be easier if the stride was like
       UpperCamelCase_     =EncodecFeatureExtractor(feature_size=1				,			chunk_length_s=1				,			overlap=0.01					)
  
       # pad and trunc raise an error ?
       with self.assertRaisesRegex(
           __A				,			"^Both padding and truncation were set. Make sure you only set one.$"				,			):
          UpperCamelCase_     =feature_extractor(
              __A				,			padding="max_length"				,			truncation=__A				,			return_tensors="pt"					).input_values
  
       # truncate to chunk
       UpperCamelCase_     =feature_extractor(__A				,			truncation=__A				,			return_tensors="pt"					).input_values
       self.assertEquals(truncated_outputs.shape				,			(2, 1, 7_1520)					)  # 2 chunks
  
       # force truncate to max_length
       UpperCamelCase_     =feature_extractor(
           __A				,			truncation=__A				,			max_length=4_8000				,			return_tensors="pt"					).input_values
       self.assertEquals(truncated_outputs.shape				,			(2, 1, 4_8000)					)
  
       # pad to chunk
       UpperCamelCase_     =feature_extractor(__A				,			padding=__A				,			return_tensors="pt"					).input_values
       self.assertEquals(padded_outputs.shape				,			(2, 1, 9_5280)					)
  
       # pad to chunk
       UpperCamelCase_     =feature_extractor(__A				,			return_tensors="pt"					).input_values
       self.assertEquals(truncated_outputs.shape				,			(2, 1, 9_5280)					)
  
       # force pad to max length
       UpperCamelCase_     =feature_extractor(
           __A				,			padding="max_length"				,			max_length=10_0000				,			return_tensors="pt"					).input_values
       self.assertEquals(truncated_outputs.shape				,			(2, 1, 10_0000)					)
  
       # force no pad
       with self.assertRaisesRegex(
           __A				,			"^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$"				,			):
          UpperCamelCase_     =feature_extractor(__A				,			padding=__A				,			return_tensors="pt"					).input_values
  
       UpperCamelCase_     =feature_extractor(input_audio[0]				,			padding=__A				,			return_tensors="pt"					).input_values
       self.assertEquals(truncated_outputs.shape				,			(1, 1, 9_3680)					)
  
       # no pad if no chunk_length_s
       UpperCamelCase_     =None
       with self.assertRaisesRegex(
           __A				,			"^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$"				,			):
          UpperCamelCase_     =feature_extractor(__A				,			padding=__A				,			return_tensors="pt"					).input_values
  
       UpperCamelCase_     =feature_extractor(input_audio[0]				,			padding=__A				,			return_tensors="pt"					).input_values
       self.assertEquals(truncated_outputs.shape				,			(1, 1, 9_3680)					)
  
       # no pad if no overlap
       UpperCamelCase_     =2
       UpperCamelCase_     =None
       with self.assertRaisesRegex(
           __A				,			"^Unable to create tensor, you should probably activate padding with 'padding=True' to have batched tensors with the same length.$"				,			):
          UpperCamelCase_     =feature_extractor(__A				,			padding=__A				,			return_tensors="pt"					).input_values
  
       UpperCamelCase_     =feature_extractor(input_audio[0]				,			padding=__A				,			return_tensors="pt"					).input_values
       self.assertEquals(truncated_outputs.shape				,			(1, 1, 9_3680)					)
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  from collections import defaultdict
  
  
  
  
  def 						_UpperCamelCase			(  A = 5			):
     UpperCamelCase_     =defaultdict(A			)
     UpperCamelCase_     =0
  
     while True:
        UpperCamelCase_     =get_digits(A			)
        freqs[digits].append(A			)
  
        if len(freqs[digits]			) == max_base:
           UpperCamelCase_     =freqs[digits][0] ** 3
           return base
  
        num += 1
  
  
  
  
  def 						_UpperCamelCase			(  A			):
     return "".join(sorted(str(num**3			)			)			)
  
  
  if __name__ == "__main__":
      print(f'''{solution() = }''')
  