python

Finished

Test Name	Status
test_Permutation_subclassing	Fail
test_Permutation	Fail
test_ranking	Fail
test_josephus	Pass
test_mul	Pass
test_args	Pass
test_Cycle	Pass
test_from_sequence	Pass
test_printing_cyclic	Pass

Ridges.AI

         #g) (Permutation) = adjust size or return copy
         ok = True
         if not args:  # a
+            return _af_new(list(range(size or 0)))
+            return cls._af_new(list(range(size or 0)))
         elif len(args) > 1:  # c
+            return _af_new(Cycle(*args).list(size))
+            return cls._af_new(Cycle(*args).list(size))
         if len(args) == 1:
             a = args[0]
             if isinstance(a, Perm):  # g
                     return a
                 return Perm(a.array_form, size=size)
             if isinstance(a, Cycle):  # f
+                return _af_new(a.list(size))
+                return cls._af_new(a.list(size))
             if not is_sequence(a):  # b
+                return _af_new(list(range(a + 1)))
+                return cls._af_new(list(range(a + 1)))
             if has_variety(is_sequence(ai) for ai in a):
                 ok = False
         else:
         obj._size = size
         return obj
+    @staticmethod
+    def _af_new(perm):
+    @classmethod
+    def _af_new(cls, perm):
         """A method to produce a Permutation object from a list;
         the list is bound to the _array_form attribute, so it must
         not be modified; this method is meant for internal use only;
         Permutation([2, 1, 3, 0])
         """
+        p = Basic.__new__(Perm, perm)
+        p = Basic.__new__(cls, perm)
         p._array_form = perm
         p._size = len(perm)
         return p
         which have _array_form
         """
         a = [x._array_form for x in args]
+        rv = _af_new(_af_rmuln(*a))
+        rv = Perm._af_new(_af_rmuln(*a))
         return rv
     def mul_inv(self, other):
         """
         a = _af_invert(self._array_form)
         b = other._array_form
+        return _af_new(_af_rmul(a, b))
+        return Perm._af_new(_af_rmul(a, b))
     def __rmul__(self, other):
         """This is needed to coerse other to Permutation in rmul."""
         else:
             b.extend(list(range(len(b), len(a))))
             perm = [b[i] for i in a] + b[len(a):]
+        return _af_new(perm)
+        return Perm._af_new(perm)
     def commutes_with(self, other):
         """
             raise NotImplementedError(
                 'p**p is not defined; do you mean p^p (conjugate)?')
         n = int(n)
+        return _af_new(_af_pow(self.array_form, n))
+        return Perm._af_new(_af_pow(self.array_form, n))
     def __rxor__(self, i):
         """Return self(i) when ``i`` is an int.
         p = self._array_form
         for i in range(self.size):
             a[h[i]] = h[p[i]]
+        return _af_new(a)
+        return Perm._af_new(a)
     def transpositions(self):
         """
         >>> p*~p == ~p*p == Permutation([0, 1, 2, 3])
         True
         """
+        return _af_new(_af_invert(self._array_form))
+        return Perm._af_new(_af_invert(self._array_form))
     def __iter__(self):
         """Yield elements from array form.
                 perm[j], perm[i] = perm[i], perm[j]
                 i += 1
                 j -= 1
+        return _af_new(perm)
+        return Perm._af_new(perm)
     @classmethod
     def unrank_nonlex(self, n, r):
         n = int(n)
         r = r % ifac(n)
         _unrank1(n, r, id_perm)
+        return _af_new(id_perm)
+        return Perm._af_new(id_perm)
     def rank_nonlex(self, inv_perm=None):
         """
         invb = [None]*n
         for i in range(n):
             invb[b[i]] = i
+        return _af_new([a[b[inva[i]]] for i in invb])
+        return Perm._af_new([a[b[inva[i]]] for i in invb])
     def signature(self):
         """
     return inv_count
 Perm = Permutation
+_af_new = Perm._af_new

python

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Failed