Refinement for Zhihan Split

data/raw/f_1000_zhihan_refined.py

@@ -0,0 +1,112 @@
+import itertools
+from random import shuffle
+
+def f_1000(numbers=list(range(1, 3))):
+ """
+ Calculates the average of the sums of absolute differences between each pair of consecutive numbers 
+ for all permutations of a given list. Each permutation is shuffled before calculating the differences.
+
+ Args:
+ - numbers (list): A list of numbers. Default is numbers from 1 to 10.
+
+ Returns:
+ float: The average of the sums of absolute differences for each shuffled permutation of the list.
+
+ Requirements:
+ - itertools
+ - random.shuffle
+
+ Example:
+ >>> result = f_1000([1, 2, 3])
+ >>> isinstance(result, float)
+ True
+ """
+ permutations = list(itertools.permutations(numbers))
+ sum_diffs = 0
+
+ for perm in permutations:
+ perm = list(perm)
+ shuffle(perm)
+ diffs = [abs(perm[i] - perm[i+1]) for i in range(len(perm)-1)]
+ sum_diffs += sum(diffs)
+
+ avg_sum_diffs = sum_diffs / len(permutations)
+
+ return avg_sum_diffs
+
+import unittest
+from unittest.mock import patch
+from random import seed, shuffle
+import itertools
+
+def run_tests():
+ suite = unittest.TestSuite()
+ suite.addTest(unittest.makeSuite(TestCases))
+ runner = unittest.TextTestRunner()
+ runner.run(suite)
+
+class TestCases(unittest.TestCase):
+ def test_default_numbers(self):
+ # Test with default number range (1 to 10) to check that the result is a positive float.
+ result = f_1000()
+ self.assertIsInstance(result, float)
+ self.assertGreater(result, 0)
+
+ def test_custom_list(self):
+ # Test with a custom list of small positive integers to ensure proper handling and positive result.
+ result = f_1000([1, 2, 3])
+ self.assertIsInstance(result, float)
+ self.assertGreater(result, 0)
+
+ def test_negative_numbers(self):
+ # Test with negative numbers to verify the function handles and returns a positive result.
+ result = f_1000([-3, -2, -1])
+ self.assertIsInstance(result, float)
+ self.assertGreater(result, 0)
+
+ def test_single_element(self):
+ # Test with a single element list to confirm the return is zero since no pairs exist.
+ result = f_1000([5])
+ self.assertIsInstance(result, float)
+ self.assertEqual(result, 0)
+
+ def test_empty_list(self):
+ # Test with an empty list to ensure the function handles it gracefully and returns zero.
+ result = f_1000([])
+ self.assertIsInstance(result, float)
+ self.assertEqual(result, 0)
+
+ def test_identical_elements(self):
+ # Test with a list of identical elements to confirm that differences are zero and the average is zero.
+ result = f_1000([2, 2, 2])
+ self.assertIsInstance(result, float)
+ self.assertEqual(result, 0)
+
+ def test_mixed_numbers(self):
+ # Test with a list of mixed positive and negative numbers to check correct average of differences.
+ result = f_1000([-10, 10, -5])
+ self.assertIsInstance(result, float)
+ self.assertGreater(result, 0)
+
+ def test_specific_value_with_seed(self):
+ # Set seed for reproducibility and check the computed value
+ with patch('random.shuffle', side_effect=lambda x: seed(42) or shuffle(x)):
+ result = f_1000([1, 2, 3])
+ self.assertAlmostEqual(result, 2.5, delta=0.5) # This expected value should be calculated beforehand
+
+ def test_large_list_with_seed(self):
+ # Set seed and test with a larger list for specific computed value
+ with patch('random.shuffle', side_effect=lambda x: seed(99) or shuffle(x)):
+ result = f_1000(list(range(1, 11)))
+ self.assertAlmostEqual(result, 33.0, delta=0.5) # This expected value should be calculated beforehand
+
+ def test_random_behavior(self):
+ # Test to ensure different seeds produce different outputs, demonstrating randomness
+ with patch('random.shuffle', side_effect=lambda x: seed(1) or shuffle(x)):
+ result1 = f_1000([1, 2, 3])
+ with patch('random.shuffle', side_effect=lambda x: seed(1) or shuffle(x)):
+ result2 = f_1000([1, 2, 4])
+ self.assertNotEqual(result1, result2)
+
+if __name__ == "__main__":
+ run_tests()

data/raw/f_1001_zhihan_refined.py

@@ -0,0 +1,74 @@
+import collections
+import random
+import string
+
+def f_1001(length=100):
+ """
+ Generate a random string of the specified length composed of uppercase and lowercase letters, 
+ and then count the occurrence of each character in this string.
+
+ Parameters:
+ length (int, optional): The number of characters in the generated string. Default is 100.
+
+ Returns:
+ dict: A dictionary where each key is a character from the generated string and the value 
+ is the count of how many times that character appears in the string.
+
+ Requirements:
+ - collections
+ - random
+ - string
+
+ Raises:
+ ValueError if the length is a negative number
+
+ Example:
+ >>> import random
+ >>> random.seed(42) # Ensures reproducibility for demonstration
+ >>> f_1001(10)
+ {'h': 1, 'B': 2, 'O': 1, 'L': 1, 'm': 1, 'j': 1, 'u': 1, 'E': 1, 'V': 1}
+ """
+ if length < 0:
+ raise ValueError
+ random_string = ''.join(random.choices(string.ascii_uppercase + string.ascii_lowercase, k=length))
+ char_counts = collections.Counter(random_string)
+ return dict(char_counts)
+
+import unittest
+import string
+
+def run_tests():
+ suite = unittest.TestSuite()
+ suite.addTest(unittest.makeSuite(TestCases))
+ runner = unittest.TextTestRunner()
+ runner.run(suite)
+
+class TestCases(unittest.TestCase):
+ def setUp(self):
+ # Prepare valid characters and set a random seed for reproducibility
+ self.valid_chars = string.ascii_uppercase + string.ascii_lowercase
+ random.seed(42) # Ensuring reproducibility for tests
+
+ def test_generated_string_properties(self):
+ # Consolidated test for different lengths to check structure and correctness
+ test_lengths = [10, 50, 100, 150, 5]
+ for length in test_lengths:
+ with self.subTest(length=length):
+ result = f_1001(length)
+ self.assertTrue(len(result) <= length, "Length of result should be <= requested string length")
+ self.assertEqual(sum(result.values()), length, f"Total counts should sum to {length}")
+ self.assertTrue(all(char in self.valid_chars for char in result), "All characters should be valid letters")
+
+ def test_zero_length(self):
+ # Test edge case where length is zero
+ result = f_1001(0)
+ self.assertEqual(len(result), 0, "Result should be empty for zero length")
+ self.assertEqual(sum(result.values()), 0, "Sum of counts should be zero for zero length")
+
+ def test_negative_length(self):
+ # Test handling of negative length input
+ with self.assertRaises(ValueError, msg="Negative length should raise an error"):
+ f_1001(-1)
+
+if __name__ == "__main__":
+ run_tests()