code: 
  
  
  
  
  
  from .number_theory.prime_numbers import next_prime
  
  
  
  
  class   _UpperCAmelCase	:
  
  
  
  
  					def __init__(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      )						->  None:
  							UpperCamelCase__         =	size_table
  							UpperCamelCase__         =	[None] * self.size_table
  							UpperCamelCase__         =	0.7_5 if lim_charge is None else lim_charge
  							UpperCamelCase__         =	1 if charge_factor is None else charge_factor
  							UpperCamelCase__         =	[]
  							UpperCamelCase__         =	{}
  
  
  
  
  					def 	snake_case_		(						self       )						->  str:
  							return self._keys
  
  
  
  
  					def 	snake_case_		(						self       )						->  Optional[int]:
  							return sum(1 for slot in self.values if slot is not None       ) / (
  							    self.size_table * self.charge_factor
  							)
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase       )						->  Union[str, Any]:
  							return key % self.size_table
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase       )						->  Optional[Any]:
  							print(F"""step {step_ord}"""       )
  							print(list(range(len(self.values       )       )       )       )
  							print(self.values       )
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase       )						->  Any:
  							UpperCamelCase__         =	1
  							UpperCamelCase__         =	values
  							for value in values:
  									self.insert_data(__lowerCAmelCase       )
  									self._step_by_step(__lowerCAmelCase       )
  									i += 1
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase       )						->  Dict:
  							UpperCamelCase__         =	data
  							UpperCamelCase__         =	data
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase=None       )						->  int:
  							UpperCamelCase__         =	self.hash_function(key + 1       )
  
  							while self.values[new_key] is not None and self.values[new_key] != key:
  									if self.values.count(__lowerCAmelCase       ) > 0:
  											UpperCamelCase__         =	self.hash_function(new_key + 1       )
  									else:
  											UpperCamelCase__         =	None
  											break
  
  							return new_key
  
  
  
  
  					def 	snake_case_		(						self       )						->  int:
  							UpperCamelCase__         =	[value for value in self.values if value is not None]
  							UpperCamelCase__         =	next_prime(self.size_table    ,      factor=2       )
  							self._keys.clear()
  							UpperCamelCase__         =	[None] * self.size_table  # hell's pointers D: don't DRY ;/
  							for value in survivor_values:
  									self.insert_data(__lowerCAmelCase       )
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase       )						->  int:
  							UpperCamelCase__         =	self.hash_function(__lowerCAmelCase       )
  
  							if self.values[key] is None:
  									self._set_value(__lowerCAmelCase    ,      __lowerCAmelCase       )
  
  							elif self.values[key] == data:
  									pass
  
  							else:
  									UpperCamelCase__         =	self._collision_resolution(__lowerCAmelCase    ,      __lowerCAmelCase       )
  									if collision_resolution is not None:
  											self._set_value(__lowerCAmelCase    ,      __lowerCAmelCase       )
  									else:
  											self.rehashing()
  											self.insert_data(__lowerCAmelCase       )
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  def     a						(      _lowercase   :     List[str]       )     ->List[str]:
  		UpperCamelCase__         =	[7_0_1, 3_0_1, 1_3_2, 5_7, 2_3, 1_0, 4, 1]
  		for gap in gaps:
  				for i in range(_lowercase ,						len(_lowercase       )       ):
  						UpperCamelCase__         =	collection[i]
  						UpperCamelCase__         =	i
  						while j >= gap and collection[j - gap] > insert_value:
  								UpperCamelCase__         =	collection[j - gap]
  								j -= gap
  						if j != i:
  								UpperCamelCase__         =	insert_value
  		return collection
  
  
  if __name__ == "__main__":
  				from doctest import testmod
  
  				testmod()
  				__lowerCAmelCase     =			input("Enter numbers separated by a comma:\n").strip()
  				__lowerCAmelCase     =			[int(item) for item in user_input.split(",")]
  				print(shell_sort(unsorted))
  
  
  
  
  
  