397 puzzles. Simplified generation process

Author: akalai

generators/IMO.py

@@ -91,8 +91,6 @@ def gen(self, target_num_instances):
         for i in range(10):
             n = 2 ** i
             self.add(dict(n=n))
-            if len(self.instances) >= target_num_instances:
-                return
 
 
 class NoRelativePrimes(PuzzleGenerator):

generators/chess.py

@@ -120,7 +120,7 @@ def possible(i, j):
     def gen(self, num_target_problems):
         count = 0
         for n in [9, 8, 7, 6, 5] + list(range(10, 100)):
-            if len(self.instances) == num_target_problems:
+            if self.num_generated_so_far() == num_target_problems:
                 return
             m = n
             self.add(dict(m=m, n=n))
@@ -170,7 +170,7 @@ def legal_quad(m1, m2):  # non-overlapping test: parallel or bounding box has (w
 
     def gen(self, target_num_instances):
         for count, n in enumerate(self.nxn_records):
-            if len(self.instances) >= target_num_instances:
+            if self.num_generated_so_far() >= target_num_instances:
                 return
             self.add(dict(m=n, n=n, target=self.nxn_records[n]))
 
@@ -223,7 +223,7 @@ def legal_quad(m1, m2):  # non-overlapping test: parallel or bounding box has (w
 
     def gen(self, target_num_instances):
         for n in self.unsolved_nxn_records:
-            if len(self.instances) >= target_num_instances:
+            if self.num_generated_so_far() >= target_num_instances:
                 return
             self.add(dict(m=n, n=n, target=self.unsolved_nxn_records[n] + 1))  # Note the +1 means breaking the record!
 

generators/classic_puzzles.py

@@ -239,7 +239,7 @@ def sol(n):
 
     def gen(self, target_num_instances):
         for n in [7824] + list(range(target_num_instances)):
-            if len(self.instances) == target_num_instances:
+            if self.num_generated_so_far() == target_num_instances:
                 return
             self.add(dict(n=n), test=n <= 100)
 
@@ -410,7 +410,7 @@ def mirror(coords):  # rotate to all four corners
     def gen(self, target_num_instances):
         for easy in range(47):
             for side in range(47):
-                if len(self.instances) == target_num_instances:
+                if self.num_generated_so_far() == target_num_instances:
                     return
                 test = side < 5 or side == 10
                 num_points = 1 if side == 1 else 2 * side
@@ -556,7 +556,6 @@ def print_sets(sets):
             if i == 2 or i == 5:
                 ans += "\n"
 
-
     @staticmethod
     def gen_sudoku_puzzle(rand):
 
@@ -640,14 +639,14 @@ def solve_helper():
         done = False
         while not done:
             done = True
-            pi = list([i for i in range(81) if x[i]!="_"])
+            pi = list([i for i in range(81) if x[i] != "_"])
             rand.shuffle(pi)
             for i in pi:
                 old = x[i]
                 x[i] = "_"
                 ans = solve("".join(x))
                 assert ans
-                if len(ans)>1:
+                if len(ans) > 1:
                     x[i] = old
                 else:
                     done = False
@@ -657,11 +656,10 @@ def solve_helper():
 
         return "".join(x)
 
-
     def gen_random(self):
 
         puz = None
-        for attempt in range(10 if len(self.instances)<10 else 1):
+        for attempt in range(10 if self.num_generated_so_far() < 10 else 1):
             puz2 = Sudoku.gen_sudoku_puzzle(self.random)
             if puz is None or puz2.count("_") > puz.count("_"):
                 puz = puz2
@@ -698,8 +696,7 @@ def sol():
 
 
 class NecklaceSplit(PuzzleGenerator):
-    """[Necklace Splitting Problem](https://en.wikipedia.org/wiki/Necklace_splitting_problem)
-    """
+    """[Necklace Splitting Problem](https://en.wikipedia.org/wiki/Necklace_splitting_problem)"""
 
     @staticmethod
     def sat(n: int, lace="bbrbrbbbbbbrrrrrrrbrrrrbbbrbrrbbbrbrrrbrrbrrbrbbrrrrrbrbbbrrrbbbrbbrbbbrbrbb"):

generators/codeforces.py

@@ -25,10 +25,8 @@ def sol(n):
         return n % 2 == 0
 
     def gen(self, target_num_instances):
-        n = 0
-        while len(self.instances) < target_num_instances:
+        for n in range(target_num_instances):
             self.add(dict(n=n))
-            n += 1
 
 
 class Abbreviate(PuzzleGenerator):
@@ -128,10 +126,10 @@ def sol(scores, k):
         return sum(s >= threshold for s in scores)
 
     def gen_random(self):
-        n = min(len(self.instances) + 1, 100)
+        n = self.random.randrange(1, 50)
         max_score = self.random.randrange(50)
         scores = sorted([self.random.randrange(max_score + 1) for _ in range(n)], reverse=True)
-        k = self.random.randrange(len(scores))
+        k = self.random.randrange(n)
         self.add(dict(scores=scores, k=k))
 
 
@@ -328,7 +326,7 @@ def sol(matrix, max_moves):
     def gen(self, target_num_instances):
         for i in range(5):
             for j in range(5):
-                if len(self.instances) == target_num_instances:
+                if self.num_generated_so_far() == target_num_instances:
                     return
                 matrix = [[0] * 5 for _ in range(5)]
                 matrix[i][j] = 1
@@ -952,7 +950,7 @@ def sol(target):
 
     def gen(self, target_num_instances):
         target = 0
-        while len(self.instances) < target_num_instances:
+        while self.num_generated_so_far() < target_num_instances:
             self.add(dict(target=target))
             target += 1
 

generators/conways_game_of_life.py

@@ -132,7 +132,7 @@ def gen_random(self):
         next_step = {z for z in visible if sum(z + d in live for d in deltas) in ([2, 3] if z in live else [3])}
 
         target = sorted([[int(z.real), int(z.imag)] for z in next_step])
-        self.add(dict(target=target), test=len(self.instances) < 10)
+        self.add(dict(target=target), test=self.num_generated_so_far() < 10)
 
 
 ########################################################################################################################

generators/graphs.py

@@ -387,9 +387,9 @@ def sol(z, n, t):
                 return [[a, b] for a, b in edges]
 
     def gen(self, target_num_instances):
-        if len(self.instances) < target_num_instances:
+        if self.num_generated_so_far() < target_num_instances:
             self.add(dict(z=26, n=6, t=3), test=False)
-        if len(self.instances) < target_num_instances:
+        if self.num_generated_so_far() < target_num_instances:
             self.add(dict(z=13, n=4, t=3))