Added trivial inverse problems (and renamed file)

Author: akalai

README.md

@@ -111,8 +111,6 @@ This project has adopted the [Microsoft Open Source Code of Conduct](https://ope
 For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
 contact [[email protected]](mailto:[email protected]) with any additional questions or comments.
 
-
-### Datasheet
 See the [datasheet](DATASHEET.md) for our dataset.
 
 ## Trademarks

templates/__init__.py

@@ -7,4 +7,4 @@
 from . import ICPC
 from . import IMO
 from . import puzzles
-from . import trivial
+from . import trivial_inverse

templates/trivial.py renamed to templates/trivial_inverse.py

@@ -55,12 +55,13 @@ def gen_random(self):
 
 assert StrAdd.sat(StrAdd.sol(**StrAdd.get_example()))
 
+
 @register
 class StrSetLen(Problem):
-    """Find a string with a certain number of duplicate chars"""
+    """Find a string with `dups` duplicate chars"""
 
     @staticmethod
-    def sat(s: str, dups=1000):
+    def sat(s: str, dups=2021):
         return len(set(s)) == len(s) - dups
 
     @staticmethod
@@ -73,9 +74,10 @@ def gen(self, target_num_problems):
                 return
             self.add(dict(dups=dups))
 
+
 @register
 class StrMul(Problem):
-    """Solve string multiplication problem"""
+    """Find a string which when repeated `n` times gives `target`"""
 
     @staticmethod
     def sat(s: str, target='foofoofoofoo', n=2):
@@ -96,7 +98,7 @@ def gen_random(self):
 
 @register
 class StrMul2(Problem):
-    """Solve string multiplication problem"""
+    """Find `n` such that `s` repeated `n` times gives `target`"""
 
     @staticmethod
     def sat(n: int, target='foofoofoofoo', s='foofoo'):
@@ -117,7 +119,7 @@ def gen_random(self):
 
 @register
 class StrLen(Problem):
-    """Solve string length problem"""
+    """Find a string of length `n`"""
 
     @staticmethod
     def sat(s: str, n=1000):
@@ -134,7 +136,7 @@ def gen_random(self):
 
 @register
 class StrAt(Problem):
-    """Solve str[i] problem"""
+    """Find the index of `target` in string `s`"""
 
     @staticmethod
     def sat(i: int, s="cat", target="a"):
@@ -152,7 +154,7 @@ def gen_random(self):
 
 @register
 class StrNegAt(Problem):
-    """Solve str[-i] problem"""
+    """Find the index of `target` in `s` using a negative index."""
 
     @staticmethod
     def sat(i: int, s="cat", target="a"):
@@ -170,7 +172,7 @@ def gen_random(self):
 
 @register
 class StrSlice(Problem):
-    """Solve string slice problem"""
+    """Find the three slice indices that give the specific `target` in string `s`"""
 
     @staticmethod
     def sat(inds: List[int], s="hello world", target="do"):
@@ -199,7 +201,7 @@ def gen_random(self):
 
 @register
 class StrIndex(Problem):
-    """Solve str.index problem"""
+    """Find a string whose *first* index in `big_str` is `index`"""
 
     @staticmethod
     def sat(s: str, big_str="foobar", index=2):
@@ -215,9 +217,10 @@ def gen_random(self):
         index = big_str.index(big_str[i:])
         self.add(dict(big_str=big_str, index=index))
 
+
 @register
 class StrIndex2(Problem):
-    """Solve str.index problem"""
+    """Find a string whose *first* index of `sub_str` is `index`"""
 
     @staticmethod
     def sat(big_str: str, sub_str="foobar", index=2):
@@ -228,7 +231,7 @@ def sol(sub_str, index):
         i = ord('A')
         while chr(i) in sub_str:
             i += 1
-        return chr(i)*index + sub_str
+        return chr(i) * index + sub_str
 
     def gen_random(self):
         sub_str = self.random.pseudo_word(max_len=50)
@@ -238,18 +241,17 @@ def gen_random(self):
 
 @register
 class StrIn(Problem):
-    """Solve str in problem"""
+    """Find a string of length `length` that is in both strings `a` and `b`"""
 
     @staticmethod
     def sat(s: str, a="hello", b="yellow", length=4):
         return len(s) == length and s in a and s in b
 
     @staticmethod
     def sol(a, b, length):
-        for i in range(len(a)-length+1):
-            if a[i:i+length] in b:
-                return a[i:i+length]
-
+        for i in range(len(a) - length + 1):
+            if a[i:i + length] in b:
+                return a[i:i + length]
 
     def gen_random(self):
         sub_str = self.random.pseudo_word()
@@ -261,22 +263,205 @@ def gen_random(self):
 
 @register
 class StrIn2(Problem):
-    """Solve str in problem"""
+    """Find a list of >= `count` distinct strings that are all contained in `s`"""
 
     @staticmethod
     def sat(substrings: List[str], s="hello", count=15):
         return len(substrings) == len(set(substrings)) >= count and all(sub in s for sub in substrings)
 
     @staticmethod
     def sol(s, count):
-        return [""] + sorted({s[j:i] for i in range(len(s)+1) for j in range(i)})
+        return [""] + sorted({s[j:i] for i in range(len(s) + 1) for j in range(i)})
 
     def gen_random(self):
         s = self.random.pseudo_word(max_len=50)
         count = len(self.sol(s, None))
         self.add(dict(s=s, count=count))
 
 
+########################################
+# List problems
+########################################
+
+
+@register
+class ListSetLen(Problem):
+    """Find a list with a certain number of duplicate items"""
+
+    @staticmethod
+    def sat(li: List[int], dups=42155):
+        return len(set(li)) == len(li) - dups
+
+    @staticmethod
+    def sol(dups):
+        return [1] * (dups + 1)
+
+    def gen_random(self):
+        self.add(dict(dups=self.random.randrange(10 ** 5)))
+
+
+@register
+class ListMul(Problem):
+    """Find a list that when multiplied n times gives the target list"""
+
+    @staticmethod
+    def sat(li: List[int], target=[17, 9, -1, 17, 9, -1], n=2):
+        return li * n == target
+
+    @staticmethod
+    def sol(target, n):
+        if n == 0:
+            return []
+        return target[:len(target) // n]
+
+    def gen_random(self):
+        li = [self.random.randrange(-10 ** 5, 10 ** 5) for _ in
+              range(self.random.randrange(1, 10))] * self.random.randint(1, 3)
+        n = self.random.randrange(10)
+        target = li * n
+        self.add(dict(target=target, n=n))
+
+
+@register
+class ListLen(Problem):
+    """Find a list of a given length n"""
+
+    @staticmethod
+    def sat(li: List[int], n=85012):
+        return len(li) == n
+
+    @staticmethod
+    def sol(n):
+        return [1] * n
+
+    def gen_random(self):
+        n = self.random.randrange(self.random.choice([10, 100, 1000, 10000]))
+        self.add(dict(n=n))
+
+
+@register
+class ListAt(Problem):
+    """Find the index of an item in a list. Any such index is fine."""
+
+    @staticmethod
+    def sat(i: int, li=[17, 31, 91, 18, 42, 1, 9], target=18):
+        return li[i] == target
+
+    @staticmethod
+    def sol(li, target):
+        return li.index(target)
+
+    def gen_random(self):
+        li = [self.random.randrange(-10 ** 2, 10 ** 2) for _ in range(self.random.randrange(1, 20))]
+        target = self.random.choice(li)
+        self.add(dict(li=li, target=target))
+
+
+@register
+class ListNegAt(Problem):
+    """Find the index of an item in a list using negative indexing."""
+
+    @staticmethod
+    def sat(i: int, li=[17, 31, 91, 18, 42, 1, 9], target=91):
+        return li[i] == target and i < 0
+
+    @staticmethod
+    def sol(li, target):
+        return li.index(target) - len(li)
+
+    def gen_random(self):
+        li = [self.random.randrange(-10 ** 2, 10 ** 2) for _ in range(self.random.randrange(1, 20))]
+        target = self.random.choice(li)
+        self.add(dict(li=li, target=target))
+
+
+@register
+class ListSlice(Problem):
+    """Find three slice indices to achieve a given list slice"""
+
+    @staticmethod
+    def sat(inds: List[int], li=[42, 18, 21, 103, -2, 11], target=[-2, 21, 42]):
+        i, j, k = inds
+        return li[i:j:k] == target
+
+    @staticmethod
+    def sol(li, target):
+        from itertools import product
+        for i, j, k in product(range(-len(li) - 1, len(li) + 1), repeat=3):
+            try:
+                if li[i:j:k] == target:
+                    return [i, j, k]
+            except (IndexError, ValueError):
+                pass
+
+    def gen_random(self):
+        li = [self.random.randrange(-10 ** 2, 10 ** 2) for _ in range(self.random.randrange(1, 20))]
+        i, j, k = [self.random.randrange(-len(li) - 1, len(li) + 1) for _ in range(3)]
+        try:
+            target = li[i:j:k]
+            if (target != [] and target != li) or self.random.randrange(50) == 0:
+                self.add(dict(li=li, target=target))
+        except (IndexError, ValueError):
+            pass
+
+
+
+@register
+class ListIndex(Problem):
+    """Find the item whose first index in `li` is `index`"""
+
+    @staticmethod
+    def sat(item: int, li=[17, 2, 3, 9, 11, 11], index=4):
+        return li.index(item) == index
+
+    @staticmethod
+    def sol(li, index):
+        return li[index]
+
+    def gen_random(self):
+        li = [self.random.randrange(-10 ** 2, 10 ** 2) for _ in range(self.random.randrange(1, 20))]
+        i = self.random.randrange(len(li))
+        index = li.index(li[i])
+        self.add(dict(li=li, index=index))
+
+@register
+class ListIndex2(Problem):
+    """Find a list that contains `i` first at index `index`"""
+
+    @staticmethod
+    def sat(li: List[int], i=29, index=10412):
+        return li.index(i) == index
+
+    @staticmethod
+    def sol(i, index):
+        return [i-1] * index + [i]
+
+    def gen_random(self):
+        i = self.random.randrange(-10**5, 10**5)
+        index = self.random.randrange(10**5)
+        self.add(dict(i=i, index=index))
+
+
+@register
+class ListIn(Problem):
+    """Find an item that is in both lists `a` and `b`"""
+
+    @staticmethod
+    def sat(s: str, a=['cat', 'dot', 'bird'], b=['tree', 'fly', 'dot']):
+        return s in a and s in b
+
+    @staticmethod
+    def sol(a, b):
+        return next(s for s in b if s in a)
+
+    def gen_random(self):
+        a = [self.random.pseudo_word() for _ in range(self.random.randrange(1, 100))]
+        b = [self.random.pseudo_word() for _ in range(self.random.randrange(1, 100))]
+        b.insert(self.random.randrange(len(b)), self.random.choice(a))
+        self.add(dict(a=a, b=b))
+
+
+
 ########################################
 # int problems
 ########################################
@@ -401,7 +586,7 @@ def gen_random(self):
 
 @register
 class IntDiv2(Problem):
-    """Solve division problem"""
+    """Find `n` that when divided by `b` is `a`"""
 
     @staticmethod
     def sat(n: int, a=345346363, b=10):
@@ -420,7 +605,7 @@ def gen_random(self):
 
 
 @register
-class SquareRoot(Problem):
+class IntSquareRoot(Problem):
     """Compute square root of number.
        The target has a round (integer) square root."""
 
@@ -439,7 +624,7 @@ def gen_random(self):
 
 
 @register
-class NegSquareRoot(Problem):
+class IntNegSquareRoot(Problem):
     """Compute negative square root of number.
        The target has a round (integer) square root."""
 
@@ -458,7 +643,7 @@ def gen_random(self):
 
 
 @register
-class SquareRootFloat(Problem):
+class FloatSquareRoot(Problem):
     """Compute square root of number.
        The target might not have a round solution.
        Accuracy of third decimal digit is required."""
@@ -477,7 +662,7 @@ def gen_random(self):
 
 
 @register
-class NegSquareRootFloat(Problem):
+class FloatNegSquareRoot(Problem):
     """Compute (negative) square root of number.
        The target might not have a round solution.
        Accuracy of third decimal digit is required."""