From bfc2eaa329769e95b6c43ddb3b36e6c181c3aa4f Mon Sep 17 00:00:00 2001
From: ShockaHolmes <sholmes7214@gmail.com>
Date: Thu, 16 Apr 2026 14:02:49 -0400
Subject: [PATCH] Updated Dicey program

---
 python/__pycache__/app.cpython-314.pyc | Bin 0 -> 8137 bytes
 python/app.py                          | 192 ++++++++++++++++++++++++-
 2 files changed, 188 insertions(+), 4 deletions(-)
 create mode 100644 python/__pycache__/app.cpython-314.pyc

diff --git a/python/__pycache__/app.cpython-314.pyc b/python/__pycache__/app.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..41bec762a520a507e655ab0b107233ca093160ec
GIT binary patch
literal 8137
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

literal 0
HcmV?d00001

diff --git a/python/app.py b/python/app.py
index e71e427..9e9ba44 100644
--- a/python/app.py
+++ b/python/app.py
@@ -1,9 +1,193 @@
-class Bin:
-    pass
+import random
+import unittest
+
 
 class Dice:
-    pass
+    def __init__(self, number_of_dice):
+        """
+        Initialize a Dice object that can roll N dice.
+        
+        Args:
+            number_of_dice: The number of dice to roll
+        """
+        self.number_of_dice = number_of_dice
+    
+    def toss_and_sum(self):
+        """
+        Roll all N dice and return the sum of their values.
+        
+        Returns:
+            The sum of all dice rolls (each die is 1-6)
+        """
+        total = sum(random.randint(1, 6) for _ in range(self.number_of_dice))
+        return total
+
+
+class Bins:
+    def __init__(self, min_value, max_value):
+        """
+        Initialize a Bins tracking object for a range of values.
+        
+        Args:
+            min_value: The minimum bin value (inclusive)
+            max_value: The maximum bin value (inclusive)
+        """
+        self.min_value = min_value
+        self.max_value = max_value
+        # Initialize bins dictionary with all values in range set to 0
+        self.bins = {i: 0 for i in range(min_value, max_value + 1)}
+    
+    def increment_bin(self, value):
+        """
+        Increment the count for a specific bin value.
+        
+        Args:
+            value: The bin value to increment
+        
+        Raises:
+            ValueError: If value is outside the valid range
+        """
+        if value not in self.bins:
+            raise ValueError(f"Value {value} is outside the range [{self.min_value}, {self.max_value}]")
+        self.bins[value] += 1
+    
+    def get_bin(self, value):
+        """
+        Get the count for a specific bin value.
+        
+        Args:
+            value: The bin value to retrieve
+        
+        Returns:
+            The count for the specified bin
+        
+        Raises:
+            ValueError: If value is outside the valid range
+        """
+        if value not in self.bins:
+            raise ValueError(f"Value {value} is outside the range [{self.min_value}, {self.max_value}]")
+        return self.bins[value]
+
 
 class Simulation:
-    pass
+    def __init__(self, numberOfDies, numberOfTosses):
+        """
+        Initialize a Simulation object.
+        
+        Args:
+            numberOfDies: The number of dice to throw per toss
+            numberOfTosses: The number of times to toss the dice
+        """
+        self.numberOfDies = numberOfDies
+        self.numberOfTosses = numberOfTosses
+        self.dice = Dice(numberOfDies)
+        # Calculate the minimum and maximum possible sums
+        # Minimum: numberOfDies * 1, Maximum: numberOfDies * 6
+        self.min_sum = numberOfDies
+        self.max_sum = numberOfDies * 6
+        self.results = Bins(self.min_sum, self.max_sum)
+    
+    def run_simulation(self):
+        """Run the simulation: toss dice numberOfTosses times and track results."""
+        for _ in range(self.numberOfTosses):
+            toss_sum = self.dice.toss_and_sum()
+            self.results.increment_bin(toss_sum)
+    
+    def print_results(self):
+        """Print the simulation results in a formatted table with histogram."""
+        print("***")
+        print(f"Simulation of {self.numberOfDies} dice tossed for {self.numberOfTosses} times.")
+        print("***")
+        print()
+        
+        for sum_value in range(self.min_sum, self.max_sum + 1):
+            count = self.results.get_bin(sum_value)
+            percentage = count / self.numberOfTosses
+            # Create histogram bar: asterisks = floor(percentage * 100)
+            histogram_bars = int((count / self.numberOfTosses) * 100)
+            
+            print(f"{sum_value:2d} : {count:8d}: {percentage:.2f} {'*' * histogram_bars}")
+
+
+if __name__ == '__main__':
+    sim = Simulation(2, 1000000)
+    sim.run_simulation()
+    sim.print_results()
+
+
+class TestDice(unittest.TestCase):
+    
+    def test_dice_sum_in_valid_range(self):
+        """Test that the sum of N dice rolls is within valid range"""
+        dice = Dice(2)
+        # For 2 dice, minimum is 2 (1+1) and maximum is 12 (6+6)
+        for _ in range(100):
+            result = dice.toss_and_sum()
+            self.assertGreaterEqual(result, 2)
+            self.assertLessEqual(result, 12)
+    
+    def test_single_die_range(self):
+        """Test that a single die roll is between 1 and 6"""
+        dice = Dice(1)
+        for _ in range(100):
+            result = dice.toss_and_sum()
+            self.assertGreaterEqual(result, 1)
+            self.assertLessEqual(result, 6)
+    
+    def test_five_dice_range(self):
+        """Test that 5 dice rolls produce sum between 5 and 30"""
+        dice = Dice(5)
+        # For 5 dice, minimum is 5 (1+1+1+1+1) and maximum is 30 (6+6+6+6+6)
+        for _ in range(100):
+            result = dice.toss_and_sum()
+            self.assertGreaterEqual(result, 5)
+            self.assertLessEqual(result, 30)
+    
+    def test_dice_rolls_produce_variance(self):
+        """Test that multiple rolls produce different values (randomness)"""
+        dice = Dice(2)
+        rolls = [dice.toss_and_sum() for _ in range(20)]
+        # It's extremely unlikely that all 20 rolls produce the same value
+        self.assertGreater(len(set(rolls)), 1)
+
+
+class TestBins(unittest.TestCase):
+    
+    def test_bins_initialization(self):
+        """Test that bins are properly initialized with zero counts"""
+        bins = Bins(2, 12)
+        # All bins should start at 0
+        for value in range(2, 13):
+            self.assertEqual(bins.get_bin(value), 0)
+    
+    def test_increment_bin(self):
+        """Test that incrementing a bin increases its count"""
+        bins = Bins(2, 12)
+        bins.increment_bin(7)
+        self.assertEqual(bins.get_bin(7), 1)
+        bins.increment_bin(7)
+        self.assertEqual(bins.get_bin(7), 2)
+    
+    def test_multiple_bins(self):
+        """Test that incrementing one bin doesn't affect others"""
+        bins = Bins(2, 12)
+        bins.increment_bin(2)
+        bins.increment_bin(7)
+        bins.increment_bin(12)
+        self.assertEqual(bins.get_bin(2), 1)
+        self.assertEqual(bins.get_bin(7), 1)
+        self.assertEqual(bins.get_bin(12), 1)
+        self.assertEqual(bins.get_bin(6), 0)
+    
+    def test_invalid_bin_value(self):
+        """Test that accessing bins outside range raises ValueError"""
+        bins = Bins(2, 12)
+        with self.assertRaises(ValueError):
+            bins.increment_bin(1)
+        with self.assertRaises(ValueError):
+            bins.get_bin(13)
+
+
+if __name__ == '__main__':
+    unittest.main()