cleaning up code and updating README

Author: jjCode01

README.md

@@ -1,11 +1,33 @@
 # Py-Problems
 
-Misc riddles, games, and problems modeled using python.
+A collection of riddles, games, and problems modeled using python.
 
 ## [Soduko Solver](./projects/soduko_solver/)
 
 Solves soduko puzzles using recursion.
 
 ## [100 Prisoner Problem](./projects//prisoner_problem/)
 
-Tests probabilities for different strategies to solve the 100 Prisoner Problem.
+Each of 100 prisoner has to find their own number in one of 100 drawers, but may open only 50 of the drawers. 
+This program tests probabilities for different strategies to solve the [100 Prisoner Problem](https://en.wikipedia.org/wiki/100_prisoners_problem).
+
+<img
+ src="./images/100_prisoner.jpg"
+ alt="100 prisoners problem screenshot"
+ title="100 prisoners problem screenshot"
+ style="display: inline-block; margin: 1rem auto; max-width: 600px">
+
+## [Collatz Conjecture (3n + 1 problem)](./projects/collatz_conjecture/)
+
+Given a set of integers, this program calculates the sequence of numbers (steps) for each integer following the rules of [Collatz Conjecture](https://en.wikipedia.org/wiki/Collatz_conjecture):
+
+* If the previous term is even, the next term is one half of the previous term (*n / 2*).
+* If the previous term is odd, the next term is 3 times the previous term plus 1 (*3n + 1*).
+
+The results are displayed on a graph.
+
+<img
+ src="./images/Collatz_Conjecture.jpg"
+ alt="Collatz Conjecture screenshot"
+ title="Collatz Conjecture screenshot"
+ style="display: inline-block; margin: 1rem auto; max-width: 600px">

images/100_prisoner.jpg

@@ -1,3 +1,13 @@
-# Collatz Conjecture
+# Collatz Conjecture (3n + 1 problem)
 
-Reference [Wikipedia](https://en.wikipedia.org/wiki/Collatz_conjecture)
+Reference [Wikipedia](https://en.wikipedia.org/wiki/Collatz_conjecture) 
+This program was inspired by watching a [Youtube video](https://www.youtube.com/watch?v=094y1Z2wpJg&t=319s) from Veritasium about Collatz Conjecture, and implements a function to ouput the steps for a given set of integers and plot the results to a graph. 
+
+## Problem
+
+This problem concerns any sequences of integers in which each term is obtained from the previous term as follows: 
+
+* If the previous term is even, the next term is one half of the previous term (*n / 2*).
+* If the previous term is odd, the next term is 3 times the previous term plus 1 (*3n + 1*).
+
+The conjecture is that these sequences always reach 1, no matter which positive integer is chosen to start the sequence.

images/Collatz_Conjecture.jpg

@@ -2,7 +2,6 @@
 
 def n(num: int) -> list:
  _n = [num]
- # print(num) 
  while num > 1:
  if num % 2:
  # num is odd
@@ -16,12 +15,13 @@ def n(num: int) -> list:
 if __name__ == "__main__":
  y = []
  p = plt
- for x in range(3,40):
+ for x in range(4,41,2):
  z = n(x)
  if max(z) > 1:
  y.append(z)
  p.plot(z)
- print(x)
 
- p.ylabel('some numbers')
+ p.title("Collatz Conjecture", loc="center")
+ p.ylabel('Step Value')
+ p.xlabel('Step Count')
  p.show()

projects/collatz_conjecture/README.md

@@ -1,5 +1,5 @@
 # 100 Prisoners Problem
-Reference the [Wikipedia](https://en.wikipedia.org/wiki/100_prisoners_problem#:~:text=The%20100%20prisoners%20problem%20is,cannot%20communicate%20with%20other%20prisoners.) page. 
+Reference the [Wikipedia](https://en.wikipedia.org/wiki/100_prisoners_problem) page. 
 This program was inspired by watching a [Youtube video](https://www.youtube.com/watch?v=iSNsgj1OCLA) from Veritasium about the 100 Prisoner Problem, and tests the probabilities of the Loop Strategy described below. 
 
 ## Problem

projects/collatz_conjecture/main.py

@@ -24,99 +24,90 @@ def init_boxes() -> list[int]:
  # on the outside of the box/drawer.
  return boxes
 
-def loop_strategy(*args) -> list[bool]:
+def loop_strategy(boxes: list, prisoners: int = 100, attempts: int = 50) -> int:
  """
  Loop strategy for the 100 Prisoners Problem.
  Should result in a success rate of greather than 30% for all
  prisoners to find their number.
  """
 
- boxes = init_boxes()
- prisoners_free = []
- for player_number in list(range(100)):
- box_number = player_number
- for _ in range(50):
- if boxes[box_number] == player_number:
+ # boxes = init_boxes()
+ prisoners_free = 0
+ for prisoner_number in list(range(prisoners)):
+ box_number = prisoner_number
+ for _ in range(attempts):
+ if boxes[box_number] == prisoner_number:
  # Prisoner found their number within 50 attempts
- prisoners_free.append(True)
+ prisoners_free += 1
  break
  box_number = boxes[box_number]
- else:
- # Prisoner failed find their number
- prisoners_free.append(False)
 
  return prisoners_free
 
-def random_strategy(*args) -> list[bool]:
+def random_strategy(boxes: list, prisoners: int = 100, attempts: int = 50) -> int:
  """
  Random strategy for the 100 Prisoners Problem.
  Should result in a less then 0% success rate for all prisoners
  to find their number.
  """
 
- boxes = init_boxes()
- prisoners_free = []
- for player_number in list(range(100)):
+ # boxes = init_boxes()
+ prisoners_free = 0
+ for prisoner_number in list(range(prisoners)):
  unchecked_boxes = boxes[:]
 
- for _ in range(50):
+ for _ in range(attempts):
  box_number = random.randint(0, len(unchecked_boxes) - 1)
- prisoner_number = unchecked_boxes.pop(box_number)
+ number_in_box = unchecked_boxes.pop(box_number)
 
- if player_number == prisoner_number:
+ if prisoner_number == number_in_box:
  # Prisoner found their number within 50 attempts
- prisoners_free.append(True)
+ prisoners_free += 1
  break
- else:
- # Prisoner failed find their number
- prisoners_free.append(False)
+
  return prisoners_free
 
 
 if __name__ == "__main__":
  # Run the strategy multiple times and print the average success rate.
- ITERATIONS = 50_000
+ PRISONER_COUNT = 100
+ ITERATIONS = 10_000
  print('########## 100 Prisoner Problem ##########')
+ loop_results = []
+ random_results = []
 
- print("Running Loop Strategy...")
- with multiprocessing.Pool() as pool:
- loop_results = pool.map(loop_strategy, range(ITERATIONS))
+ for _ in track(range(ITERATIONS)):
+ boxes = init_boxes()
+ loop_results.append(loop_strategy(boxes[:]))
+ random_results.append(random_strategy(boxes[:]))
 
- print("Running Random Strategy...")
- with multiprocessing.Pool() as pool:
- random_results = pool.map(random_strategy, range(ITERATIONS))
+ loop_group_success_count = sum(results == PRISONER_COUNT for results in loop_results)
+ loop_free_prisoner_count = sum(results for results in loop_results)
 
- print("Tabulating Loop Strategy Results...")
- loop_group_success_count = sum(all(results) for results in loop_results)
- loop_free_prisoner_count = sum(sum(results) for results in loop_results)
+ random_group_success_count = sum(results == PRISONER_COUNT for results in random_results)
+ random_free_prisoner_count = sum(results for results in random_results)
 
- print("Tabulating Random Strategy Results...\n")
- random_group_success_count = sum(all(results) for results in random_results)
- random_free_prisoner_count = sum(sum(results) for results in random_results)
- total_prisoners = ITERATIONS * 100
+ total_prisoners = ITERATIONS * PRISONER_COUNT
 
  console = Console()
  table = Table()
- table.title = f"Results: 100 Prisoner Problem\n{ITERATIONS:,} Iterations"
+ table.title = f"\nResults: 100 Prisoner Problem\n{ITERATIONS:,} Iterations : {total_prisoners:,} Prisoners"
  table.add_column("Strategy")
  table.add_column("Group\nSuccess Count", justify="right")
  table.add_column("Group\nSuccess Rate", justify="right")
- table.add_column("Total\nPrisoners", justify="right")
  table.add_column("Free\nPrisoners", justify="right")
  table.add_column("Individual\nSuccess Rate", justify="right")
  table.add_row(
  "Loop",
  f"{loop_group_success_count:,}",
  f"{(loop_group_success_count / ITERATIONS):.2%}",
- f"{total_prisoners:,}",
  f"{loop_free_prisoner_count:,}",
  f"{(loop_free_prisoner_count / total_prisoners):.2%}"
  )
  table.add_row(
  "Random", 
  f"{random_group_success_count:,}", 
  f"{(random_group_success_count / ITERATIONS):.2%}", 
- f"{total_prisoners:,}", 
  f"{random_free_prisoner_count:,}",
  f"{(random_free_prisoner_count / total_prisoners):.2%}"
  )

projects/prisoner_problem/README.md

@@ -0,0 +1,18 @@
+
+from soduko_solver import Soduko_Solver
+
+if __name__ == "__main__":
+
+ grid = [[3, 6, 0, 4, 5, 1, 7, 2, 0],
+ [0, 0, 0, 0, 0, 2, 0, 0, 4],
+ [4, 0, 2, 6, 3, 7, 0, 0, 0],
+ [0, 0, 1, 0, 0, 0, 5, 0, 0],
+ [0, 0, 4, 5, 1, 8, 2, 0, 3],
+ [0, 0, 0, 0, 9, 0, 4, 6, 0],
+ [2, 0, 0, 0, 7, 0, 0, 5, 0],
+ [0, 7, 0, 1, 0, 0, 3, 0, 2],
+ [0, 0, 5, 0, 0, 0, 0, 0, 7]]
+
+ game = Soduko_Solver(grid)
+
+ game.solve()