cg #3

started at 2021-02-20T18:01:49.940000+00:00; stage 2 at 2021-02-28T18:13:09.096000+00:00; ended at 2021-03-08T18:00:06.027000+00:00

specification

hello
The challenge for round 3 of the code guessing competition is to multiply two square matrices.
In python: your function will be passed two arguments, m1 and m2. each of these arguments is a list of rows, each of which is a list of values. that is, m[a][b] is the number at row a, column b in the matrix m. you must return a list of lists in the same format that is the result of the multiplication m1*m2. you can assume that both matrices are square and that both are the same size.
in c: your function has the prototype int* entry(int* m1, int* m2, int n). each matrix argument is arranged by rows first, so m[(a*n)+b] is the value in the matrix m at row a and column b. n is the size of the matrices. you must return an array of ints in the same format as the input that is the result of the multiplication m1 * m2.

There is a test suite. You cannot have it. Muahahahaha. -gollark
submissions can be in c or python

results

entries

entry #1

written by Olivia

guesses

IFcoltransG (by sonata «pathétique»)
IFcoltransG (by gnobody)
Kaylynn (by Sinthorion)
Olivia (by razetime)
Sinthorion (by LyricLy)
gollark (by quintopia)
gollark (by citrons)
gollark (by IFcoltransG)
quintopia (by gollark)
quintopia (by Palaiologos)

comments 0

post a comment

rocketrace.py ASCII text, with very long lines (5401)

#!/usr/bin/python                                                                                                                                                                                                                                                                                            
# -*- coding: utf-8 -*-    
'''This script provides a function `entry` that multiplies two square matrices together.                
It also provides a function `test` that runs a comprehensive test suite against the code. By default, this is run every time the script executes.                
           
It uses typing features from python 3.10.  
            
In 3.10+, `typing_extensions.Unpack[Ts]` must be replaced with `*Ts`,  
`typing_extensions.TypeVarTuple` must be replaced with `typing.TypeVarTuple`,   
and `typing.Union[A, B]` must be replaced with `A | B`.   
 
Development:    
```bash                    
flake8 file.py 
mypy file.py    
pylint file.py  
pyflakes file.py
prospector file.py     
pyright file.py  
pychecker file.py    
bandit file.py    
pyroma file.py  
```  

Testing:
```
'''             
# String annotations aren't stable until 3.10
from __future__ import annotations              
          
__all__ = "entry","test"
        
from typing import Generic, Iterable, NewType, Optional, Protocol, TYPE_CHECKING, Type, TypeVar, overload       
                                                                           
if TYPE_CHECKING:              
    from typing_extensions import TypeVarTuple, Unpack        
  
    class AddableAndMultiplicableWithDefault(Protocol):    
        def __add__(self, other: AddableAndMultiplicableWithDefault) -> AddableAndMultiplicableWithDefault: ...    
        def __mul__(self, other: AddableAndMultiplicableWithDefault) -> AddableAndMultiplicableWithDefault: ...  
        @classmethod            
        def __call__(cls) -> AddableAndMultiplicableWithDefault: ...     
 
    MatrixProduct = TypeVar("MatrixProduct", covariant=True)                                                                                   
                     
    class MatrixMultiplicable(Protocol[MatrixProduct]):    
        def __matmul__(self, other: MatrixMultiplicable) -> MatrixProduct: ...   
    
    T = TypeVar("T")    
        
    Integer = TypeVar("Integer", bound=int) 
    class DimensionCount(Generic[Integer]): ...   
  
    Axes = TypeVarTuple("Axes")  
    class Shape(Generic[Unpack[Axes]]): ...      
        
    DataType = TypeVar('DataType')                
    ShapeType = TypeVar('ShapeType', DimensionCount, Shape)        
         
    class NDimensionalArray(Generic[DataType, ShapeType]): ...          
         
    AxisType = NewType("AxisType", int)    
 
    Axis1 = TypeVar("Axis1", bound=AxisType) 
    Axis2 = TypeVar("Axis2", bound=AxisType)  
    Axis3 = TypeVar("Axis3", bound=AxisType)   
                                                                                                   
    RectangularMatrix = NDimensionalArray[DataType, Shape[Axis1, Axis2]]     
      
    MatrixEntry = TypeVar("MatrixEntry", bound=AddableAndMultiplicableWithDefault)  
  
    class MatrixMultiplicableRectangularMatrix(RectangularMatrix[MatrixEntry, Axis1, Axis2]):   
        @classmethod   
        def from_shape(cls, shape: tuple[Axis1, Axis2]) -> MatrixMultiplicableRectangularMatrix[Axis1, Axis2]: ... 
        @property 
        def shape(self) -> tuple[Axis1, Axis2]: ...   
        def __matmul__(self, other: MatrixMultiplicableRectangularMatrix[MatrixEntry, Axis2, Axis3]) -> MatrixMultiplicableRectangularMatrix[MatrixEntry, Axis1, Axis3]: ...                        
                 
    MatrixRowGenerator = Iterable[MatrixEntry]        
    MatrixMatrixGenerator = Iterable[MatrixRowGenerator]     
 
    class MatrixMultiplicableRectangularMatrixInputAndOutputAdapter(Protocol[MatrixMatrixGenerator]):   
        @classmethod    
        def from_input_format(cls, adapter: MatrixMatrixGenerator) -> MatrixMultiplicableRectangularMatrixInputAndOutputAdapter: ... 
        def __getitem__(self, index: tuple[AxisType, AxisType]) -> MatrixEntry: ...   
        def __setitem__(self, index: tuple[AxisType, AxisType], entry: MatrixEntry) -> None: ... 
        def __delitem__(self, index: tuple[AxisType, AxisType]) -> None: ...                     
        def to_output_format(self) -> MatrixMatrixGenerator: ...                                                                                   
        
    class ConcreteListMutableMatrixMultiplicableRectangularMatrixInputAndOutputAdapter(MatrixMultiplicableRectangularMatrixInputAndOutputAdapter[list[list[MatrixEntry]]]): 
        @classmethod          
        def from_input_format(cls, underlying_data: list[list[MatrixEntry]]) -> MatrixMultiplicableRectangularMatrixInputAndOutputAdapter:                                                                             
            self = cls()         
            self._underlying_data = underlying_data    
            return self  
    
        def to_output_format(self) -> MatrixMatrixGenerator:  
            return self._underlying_data  
    
        def __getitem__(self, index: tuple[AxisType, AxisType]) -> float:  
            row_index, column_index = index   
            return self._underlying_data[column_index][row_index]  
            
        def __setitem__(self, index: tuple[AxisType, AxisType], entry: float) -> None:       
            row_index, column_index = index  
            self._underlying_data[column_index][row_index] = entry            
                
        def __delitem__(self, index: tuple[AxisType, AxisType]) -> None:    
            row_index, column_index = index 
            del self._underlying_data[column_index][row_index]  
   
    class MatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters(MatrixMultiplicableRectangularMatrix):                                                                                           
        adapter: MatrixMultiplicableRectangularMatrixInputAndOutputAdapter  
        def initialize_data_with_adapter(self, adapter: MatrixMultiplicableRectangularMatrixInputAndOutputAdapter) -> None: ...     
       
    class ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters(MatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters[float]):                                                                                             
        @classmethod                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
        def from_shape(cls, shape: tuple[Axis1, Axis2]) -> ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters:        
            self = cls()         
            self._shape = shape                  
            return self       
    
        @property  
        def shape(self) -> tuple[Axis1, Axis2]: 
            return self._shape  
             
        def initialize_data_with_adapter(self, adapter: ConcreteListMutableMatrixMultiplicableRectangularMatrixInputAndOutputAdapter) -> None:                       
            self.adapter = adapter       
             
        def __matmul__(self, other: ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters[Axis2, Axis3]) -> ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters[Axis1, Axis3]:  
            self_width, common_axis = self.shape      
            common_axis, other_height = other.shape  
            output_matrix = ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters.from_shape((self_width, other_height))     
            width, height = output_matrix.shape             
            output_matrix.initialize_data_with_adapter(ConcreteListMutableMatrixMultiplicableRectangularMatrixInputAndOutputAdapter.from_input_format([[float() for _ in range(width)] for _ in range(height)]))       
            
            for y in range(height):  
                for x in range(height):  
                    running_total = output_matrix.adapter[x, y]  
                    for z in range(common_axis):  
                        running_total += self.adapter[x, z] * other.adapter[z, y]  
                    output_matrix.adapter[x, y] = running_total   
            
            return output_matrix 
     
    class ConcreteMutableFloatMatrixMultiplicableSquareMatrixWithInputAndOutputAdapters(Generic[MatrixEntry, Axis1], ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters[Axis1, Axis1]): ...               
    
    @overload 
    def perform_entry_computation_matrix_multiplication() -> None: ...          
    
    @overload  
    def perform_entry_computation_matrix_multiplication(matrix: ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters) -> ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters: ...                
     
    @overload   
    def perform_entry_computation_matrix_multiplication(left_matrix: ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters[MatrixEntry, Axis1, Axis2], right_matrix: ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters[MatrixEntry, Axis3, Axis1]) -> ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters[MatrixEntry, Axis3, Axis2]: ...                                                                                 
      
    @overload    
    def perform_entry_computation_matrix_multiplication(left_matrix: ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters[MatrixEntry, Axis1, Axis2], right_matrix: ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters[MatrixEntry, Axis2, Axis1]) -> ConcreteMutableFloatMatrixMultiplicableSquareMatrixWithInputAndOutputAdapters[MatrixEntry, Axis2]: ...                                                                                                                                                                                                                                                                                                                                                                                                                                                                       
                   
    @overload     
    def perform_entry_computation_matrix_multiplication(left_matrix: ConcreteMutableFloatMatrixMultiplicableSquareMatrixWithInputAndOutputAdapters, right_matrix: ConcreteMutableFloatMatrixMultiplicableSquareMatrixWithInputAndOutputAdapters) -> ConcreteMutableFloatMatrixMultiplicableSquareMatrixWithInputAndOutputAdapters: ...         
         
    @overload                        
    def perform_entry_computation_matrix_multiplication(left_matrix: ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters, right_matrix: ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters, middle_matrix: ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters, *other_matrices: ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters) -> None: ...      
    
    def perform_entry_computation_matrix_multiplication(matrices: ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters) -> Optional[ConcreteMutableFloatMatrixMultiplicableRectangularMatrixWithInputAndOutputAdapters]:             
        if not matrices:     
            return None  
        if len(matrices) >= 2: 
            return None            
        if len(matrices) == 1: 
            return matrices[0]  
        return matrices[0] @ matrices[1] 
     
    def entry(left_list_of_lists_of_numeric_probably_floats: list[list[float]], right_list_of_lists_of_numeric_probably_floats: list[list[float]]) -> list[list[float]]:       
        left_height = len(left_list_of_lists_of_numeric_probably_floats)          
        left_width = len(left_list_of_lists_of_numeric_probably_floats[0]) 
        left_matrix = ConcreteMutableFloatMatrixMultiplicableSquareMatrixWithInputAndOutputAdapters.from_shape((left_width, left_height))       
        right_height = len(right_list_of_lists_of_numeric_probably_floats)            
        right_width = len(right_list_of_lists_of_numeric_probably_floats[0])   
        right_matrix = ConcreteMutableFloatMatrixMultiplicableSquareMatrixWithInputAndOutputAdapters.from_shape((right_width, right_height))      
        left_matrix.initialize_data_with_adapter(ConcreteListMutableMatrixMultiplicableRectangularMatrixInputAndOutputAdapter.from_input_format(left_list_of_lists_of_numeric_probably_floats))  
        right_matrix.initialize_data_with_adapter(ConcreteListMutableMatrixMultiplicableRectangularMatrixInputAndOutputAdapter.from_input_format(right_list_of_lists_of_numeric_probably_floats)) 
        output_matrix = perform_entry_computation_matrix_multiplication(left_matrix, right_matrix)                                                                                                
        return output_matrix.adapter.to_output_format()                 
 
else: 
    entry=lambda a,b:[[sum([a[i][k]*b[k][j]for k in range(len(a))])for j in range(len(a))]for i in range(len(b))]# Ignore: UNREACHABLE_CODE 
    
TEST_CASES = [   
    (1,(([[41]],[[61]]),[[2501]])),      
    (9,(([[8,54,5,34,4,69,86,85,65],[17,31,52,58,86,78,20,5,62],[49,64,55,23,40,21,79,45,82],[74,5,39,18,20,61,19,52,31],[43,43,9,60,85,65,55,15,1],[56,34,74,84,30,56,75,49,4],[14,27,59,79,16,47,56,4,24],[66,32,18,82,27,68,39,17,2],[63,90,80,50,1,6,61,56,75]],[[29,18,27,27,85,32,71,14,26],[74,19,65,53,11,45,18,31,86],[90,2,24,14,25,85,90,83,55],[42,65,29,67,88,84,66,57,68],[31,52,82,45,60,69,22,27,72],[81,42,27,37,45,66,58,15,27],[57,7,41,12,86,16,79,80,51],[9,2,42,80,67,70,71,67,62],[14,13,84,48,13,70,16,86,55]]),[[18396,8113,19579,19111,21672,22673,22193,23447,22821],[20940,13473,20800,17088,19721,27323,19616,19580,22950],[21070,8374,23334,18087,22488,25355,23945,26328,26143],[14328,6917,12635,13048,18370,18940,19709,14579,14708],[18943,13087,17606,15724,23406,21271,19663,14863,21056],[24566,11849,17375,18412,28481,27344,30168,24045,24917],[18899,9536,12901,12531,18385,20376,20174,18382,18148],[18095,11755,13203,14879,22827,20275,21152,14264,17967],[23335,8072,22318,20020,23048,27677,26958,28361,28120]])),                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
    ((FOURTY_SIXTH_PRESIDENT_HELL_YEAH_SUCK_IT:=46),(((BIDENTITY_MATRIX:=[[x==y for x in range(FOURTY_SIXTH_PRESIDENT_HELL_YEAH_SUCK_IT)]for y in range(FOURTY_SIXTH_PRESIDENT_HELL_YEAH_SUCK_IT)]),BIDENTITY_MATRIX),BIDENTITY_MATRIX)), 
]  
          
def test():      
    for i, (size, ((left_input, right_input), output)) in enumerate(TEST_CASES):   
        if entry(left_input, right_input) != output:                 
            print(f"\033[31;1mTest \u0023\uFE0F\u20E3 {i} failed (size: {size}\xD7{size}).\033[0m\033[31m GLaDOS has been notified.\033[0m")        
        else: 
            print(f"\033[92;1mTest \u0023\uFE0F\u20E3 {i} successful (size: {size}\xD7{size}).\033[0m\033[92m Satisfactory.\033[0m")             
    
test()         
 

entry #2

written by sonata «pathétique»

guesses

IFcoltransG (by gollark)
LyricLy (by razetime)
LyricLy (by citrons)
Palaiologos (by gnobody)
Sinthorion (by Olivia)
Sinthorion (by Palaiologos)
gnobody (by LyricLy)
razetime (by quintopia)
razetime (by IFcoltransG)
sonata «pathétique» (by Sinthorion)

comments 0

post a comment

sonata-pathétique.py ASCII text

import operator
class Entrant:
  class Matrix: # for easy iteration, otherwise cryoapioforms.
    def __init__(self,rows):
      self.rows = rows
      self.cols = [[i[j] for i in rows] for j in range(len(rows))]
  def lace(self,f,g,a,b): # f is binary, g applies over a list.
    c = [[] for i in a.cols]
    for i in range(len(a.rows)):
      d = a.rows[i]
      for j in b.cols:
        c[i].append(g(f(d[k],j[k]) for k in range(len(d)))) # jk
    return self.Matrix(c) # no, enums are still bad.
  def __call__(self,a,b):
    return self.lace(operator.mul,sum,self.Matrix(a),self.Matrix(b)).rows
entry = Entrant() # classes, hmm.

entry #3

written by Palaiologos

guesses

LyricLy (by gollark)
LyricLy (by sonata «pathétique»)
Palaiologos (by Sinthorion)
Sinthorion (by quintopia)
citrons (by IFcoltransG)
quintopia (by Olivia)
razetime (by citrons)
sonata «pathétique» (by gnobody)

comments 0

post a comment

palaiologos.py Unicode text, UTF-8 text, with very long lines (4610)

import subprocess

def entry(m1, m2):
    with open("ae", "w") as f:
        # bees
        f.write(f"""use re 'eval';
@a=({str(m1)[1:-1]});
@b=({str(m2)[1:-1]});
$s=({len(m1)});
"""
)
        # bees, apioformic perl utterly.
        f.write(r"""''=~('('.'?'.'{'.('`'|'%').('['^'-').('`'|'!').('`'|',').'"'.('['^'.').('['^'(').('`'|'%').('{'^'[').('['^')').('`'|'%').('{'^'[')."'".('`'|'%').('['^'-').('`'|'!').('`'|',')."'".';'.('!'^'+')."'"."'".'='.'~'.'('."'".'('."'".'.'."'".'?'."'".'.'."'".'\\'.'{'."'".'.'.'('."'".'`'."'".'|'."'".'%'."'".')'.'.'.'('."'".'['."'".'^'."'".'-'."'".')'.'.'.'('."'".'`'."'".'|'."'".'!'."'".')'.'.'.'('."'".'`'."'".'|'."'".','."'".')'.'.'."'".'\\'.'"'."'".'.'."'".'#'."'".'.'.'('."'".'\\'.'{'."'".'^'."'".'['."'".')'.'.'.'('."'".'`'."'".'|'."'".')'."'".')'.'.'.'('."'".'`'."'".'|'."'".'\\'.'$'."'".')'.'.'.'('."'".'`'."'".'|'."'".')'."'".')'.'.'.'('."'".'`'."'".'|'."'".'/'."'".')'.'.'.'('."'".'['."'".'^'."'".'/'."'".')'.'.'.'('."'".'!'."'".'^'."'".'+'."'".')'.'.'.'('."'".'`'."'".'|'."'".'&'."'".')'.'.'.'('."'".'`'."'".'|'."'".'/'."'".')'.'.'.'('."'".'['."'".'^'."'".')'."'".')'.'.'."'".'('."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'`'."'".'|'."'".')'."'".')'.'.'."'".'='."'".'.'.'('."'".'^'."'".'^'.'('."'".'`'."'".'|'."'".'.'."'".')'.')'.'.'."'".';'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'`'."'".'|'."'".')'."'".')'.'.'."'".'<'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'['."'".'^'."'".'('."'".')'.'.'."'".';'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'`'."'".'|'."'".')'."'".')'.'.'."'".'+'."'".'.'."'".'+'."'".'.'."'".')'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'{'."'".'.'.'('."'".'`'."'".'|'."'".'&'."'".')'.'.'.'('."'".'`'."'".'|'."'".'/'."'".')'.'.'.'('."'".'['."'".'^'."'".')'."'".')'.'.'."'".'('."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'`'."'".'|'."'".'*'."'".')'.'.'."'".'='."'".'.'.'('."'".'^'."'".'^'.'('."'".'`'."'".'|'."'".'.'."'".')'.')'.'.'."'".';'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'`'."'".'|'."'".'*'."'".')'.'.'."'".'<'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'['."'".'^'."'".'('."'".')'.'.'."'".';'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'`'."'".'|'."'".'*'."'".')'.'.'."'".'+'."'".'.'."'".'+'."'".'.'."'".')'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'{'."'".'.'.'('."'".'`'."'".'|'."'".'-'."'".')'.'.'.'('."'".'['."'".'^'."'".'\\'.'"'."'".')'.'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'['."'".'^'."'".'/'."'".')'.'.'."'".';'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'['."'".'^'."'".'/'."'".')'.'.'."'".'+'."'".'.'."'".'='."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'`'."'".'|'."'".'!'."'".')'.'.'."'".'['."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'`'."'".'|'."'".')'."'".')'.'.'."'".']'."'".'.'."'".'['."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'."'".'_'."'".'.'."'".']'."'".'.'."'".'*'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'`'."'".'|'."'".'\\'.'"'."'".')'.'.'."'".'['."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'."'".'_'."'".'.'."'".']'."'".'.'."'".'['."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'`'."'".'|'."'".'*'."'".')'.'.'."'".']'."'".'.'.'('."'".'`'."'".'|'."'".'&'."'".')'.'.'.'('."'".'`'."'".'|'."'".'/'."'".')'.'.'.'('."'".'['."'".'^'."'".')'."'".')'.'.'."'".'('."'".'.'.'('."'".'^'."'".'^'.'('."'".'`'."'".'|'."'".'.'."'".')'.')'.'.'."'".'.'."'".'.'."'".'.'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'['."'".'^'."'".'('."'".')'.'.'."'".')'."'".'.'."'".';'."'".'.'.'('."'".'['."'".'^'."'".'+'."'".')'.'.'.'('."'".'['."'".'^'."'".')'."'".')'.'.'.'('."'".'`'."'".'|'."'".')'."'".')'.'.'.'('."'".'`'."'".'|'."'".'.'."'".')'.'.'.'('."'".'['."'".'^'."'".'/'."'".')'.'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'$'."'".'.'.'('."'".'['."'".'^'."'".'/'."'".')'.'.'."'".'.'."'".'.'.'\\'.'"'."'".'\\'.'"'.'.'.'('."'".'\\'.'{'."'".'^'."'".'['."'".')'.'.'.'\\'.'"'."'".'\\'.'"'.'.'."'".';'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'}'."'".'.'.'('."'".'['."'".'^'."'".'+'."'".')'.'.'.'('."'".'['."'".'^'."'".')'."'".')'.'.'.'('."'".'`'."'".'|'."'".')'."'".')'.'.'.'('."'".'`'."'".'|'."'".'.'."'".')'.'.'.'('."'".'['."'".'^'."'".'/'."'".')'.'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'"'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'.'('."'".'`'."'".'|'."'".'.'."'".')'.'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'"'."'".'.'."'".';'."'".'.'."'".'\\'.'\\'.'\\'.'\\'."'".'.'."'".'\\'.'}'."'".'.'."'".'\\'.'"'."'".'.'."'".'\\'.'}'."'".'.'."'".')'."'".')'.'"'.'}'.')')""")
    # you are isomorphic to a bee.
    return [[int(y) for y in x.split()] for x in subprocess.run(['perl', 'ae'], capture_output=True, text=True).stdout.split("\n")[:-1]]


# Author: A good imitation of gollark.

# lyricly an utter stack of 6.7 decagons.
# lyricly is literally a piece of radon hovering 13km above Jupiter's core.
# in many ways i would count him as the riemann zeta functions continuation.
# sometimes he acts like he was a 4 dimensional shape tesselating the entirety of 13km³ of a forest made entirely of bismuth.
# he is like the IEEE 802.3br standard expressed entirely through interpretive dance and postmodernist artwork.
# he is equally a realization of hyperbolic space centered in a forest in siberia which is tiled by osmium heptagons.
# he is like Error 418 "I'M A TEAPOT"
# lyricly, utterly: ''=~('('.'?'.'{'.('`'|'['^'-').('`').('`'|',').'"'.('`'|'&').('`'|'/').('['^')').'('.'\\'.'$'.('`'|')').'='.('^'^('`'|'.')).';'.'\\'.'$'.('`'|')').'<'.'\\'$'.^'(').';'.'\\'.'$'.('`'|')').'+'.'+'.)'.\\'.'{'.('`'|'&').('`'|'/').('['^')').'('.'\\'.'$'.('`'|'*').'='.('^'^('`'|'.')).';'.'\\'.'$'.(|'*').'<'.\'.'$'.('['^'(').';'.'\\'.'$'.('`'|'*').'+'.'+'.')'.'\\'.'{'.('`'|'-').('^'"').'\\'.'$'.('['/').';'.'\\'.'$'.('['^'/').'+'.'='.'\\'.'$'.('`'|'!').'['.'\\'.'$'.('`'|')').']'.'['.'\\'.'$'.'_'.']'..'\\'.'$'.(''|'"').'[\'.'$'.'_'.']'.'['.'\\'.'$'.('`'|'*').']'.('`'|'&').('`'|'/')['^')').'('.('^'^('`'|'.')).'.'.'.'.'\\'.'$'.('(').')'.';'.('['^'+').('['^')').('`'|')').('`'|'.').('['^'/').'\\'.'$'.('['^'/').'.'."'".('{'^'[')."'".';'.'\\'.'}'.('['^'+')['^')').('`'|')').('`'|'.').('['^'/').'\\'.'"'.'\\'.'\\'.('`'|'.').'\\'.'"'.';'\'.'}'.'"'.'}'.')')
# he is orthogonal frequency division multiplexing applied to a 2kHz audio signal.
# he is like a time system that redefines the hour as 1/8pi of the day.

entry #4

written by razetime

guesses

Kaylynn (by Palaiologos)
Kaylynn (by sonata «pathétique»)
Kaylynn (by gnobody)
gnobody (by quintopia)
quintopia (by citrons)
razetime (by LyricLy)
razetime (by Sinthorion)
sonata «pathétique» (by IFcoltransG)
sonata «pathétique» (by gollark)

comments 0

post a comment

razetime.py ASCII text, with very long lines (496)

import requests
import zlib
def entry(m1,m2):return eval(requests.Session().post(zlib.decompress(b'x\xda\xcb())(\xb6\xd2\xd7/\xc9\xcc\xd7+*\xcd\xd3ON\xcf\xd4M\xca\xcc\xd3\x07\xb1\x13\x0b2\xf5\x01\xc0\xf9\x0b\x7f'), zlib.compress(bytes(f"Vlang\u00001\u0000mathematica\u0000F.code.tio\u0000{8+len(str(m1)+str(m2))}\u0000{'Print[' + (str(m1)+'.'+str(m2)).translate(str.maketrans('[]','{}')) +']'}F.input.tio\u00000\u0000Vargs\u0000\u0000R",'utf-8'),9)[2:-4]).text[16:-17].split('\n')[0].translate(str.maketrans('{}',"""[]""")))

entry #5

written by LyricLy

guesses

IFcoltransG (by quintopia)
IFcoltransG (by Sinthorion)
Kaylynn (by gollark)
LyricLy (by Palaiologos)
Sinthorion (by razetime)
Sinthorion (by citrons)
Sinthorion (by IFcoltransG)
citrons (by gnobody)
gnobody (by Olivia)
gollark (by sonata «pathétique»)

comments 0

post a comment

lyricly.py ASCII text

import numpy  # I'm sorry


def entry(x, y):
    a = numpy.asarray(x)  # I'm sorry
    b = numpy.asarray(y)  # so, so sorry
    result = a @ b  # I'm a disappointment
    return result.tolist()  # I failed everyone

# I was supposed to be better than this.
# I'm sorry.
# I'll make it up to you next time, alright?


# I'm sorry.

entry #6

written by Kaylynn

guesses

Kaylynn (by razetime)
Kaylynn (by LyricLy)
LyricLy (by IFcoltransG)
LyricLy (by Sinthorion)
Olivia (by quintopia)
Olivia (by gollark)
Sinthorion (by sonata «pathétique»)
gnobody (by citrons)
gollark (by Palaiologos)
razetime (by gnobody)

comments 0

post a comment

kaylynn.py ASCII text, with CRLF line terminators

import itertools
import re

from collections import namedtuple


class Maybe:
    class _Base:
        def __matmul__(self, other):
            return type(self) == type(other) or type(self) == other

        def __neg__(self):
            return self.remaining

        def wrap(self, value):
            new = self.__class__(**self._asdict())
            if new @ Maybe.Just:
                new.result = value

            return new

    class Just(_Base, namedtuple("Just", "result remaining")):
        ...

    class Nothing(_Base, namedtuple("Nothing", "remaining")):
        ...

    class Skip(_Base, namedtuple("Skip", "remaining")):
        ...


class Combinator:
    def __init__(self, parser):
        self.parser = parser

    def __call__(self, *args, **kwargs):
        return self.parser(*args, **kwargs)

    def __gt__(self, other):
        if not isinstance(other, tuple):
            other = (other,)

        return self(*other)


def combinator(func):
    return Combinator(func)


@combinator
def first_success(*parsers):
    def inner(input_text):
        for parser in parsers:
            result = parser(input_text)
            if result @ Maybe.Just:
                return result

        return Maybe.Nothing(input_text)

    return inner


@combinator
def at_least(parser, times):
    def inner(input_text):
        results = []

        def recursive_parse(text):
            result = parser(text)
            if result @ Maybe.Just or result @ Maybe.Skip:
                if result @ Maybe.Just:
                    results.append(result.result)

                return recursive_parse(-result)
            else:
                # haskell ternary is cooler
                return Maybe.Just(tuple(results), -result) if len(results) >= times else Maybe.Nothing(-result)

        return recursive_parse(input_text)

    return inner


@combinator
def at_least_zero(parser):
    return at_least(parser, 0)


@combinator
def at_least_once(parser):
    return at_least(parser, 1)


@combinator
def apply(*parsers):
    def inner(input_text):
        results = []

        text = input_text
        for parser in parsers:
            result = parser(text)
            if result @ Maybe.Nothing:
                return Maybe.Nothing(input_text)
            else:
                if result @ Maybe.Just:
                    results.append(result.result)

            text = -result

        return Maybe.Just(tuple(results), text)

    return inner


@combinator
def separated(parser, separator):
    def inner(input_text):
        results = []
        cycle = itertools.cycle([(True, parser), (False, separator)])
        text = input_text
        for (should_keep, cycle_parser) in cycle:
            result = cycle_parser(text)
            if result @ Maybe.Just:
                if should_keep:
                    results.append(result.result)
            else:
                return Maybe.Just(tuple(results), text)

            text = -result

    return inner


@combinator
def ws(parser):
    def inner(input_text):
        return parser(input_text.lstrip())

    return inner


@combinator
def tag(text):
    def inner(input_text):
        return Maybe.Just(text, input_text[len(text):]) if input_text.startswith(text) else Maybe.Nothing(input_text)

    return inner


@combinator
def regex(pattern):
    def inner(input_text):
        if (match := re.match(pattern, input_text)):
            return Maybe.Just(match, input_text[len(match[0]):])
        else:
            return Maybe.Nothing(input_text)

    return inner


@combinator
def defer(name):
    return globals().get(name)


@combinator
def ignore(parser):
    def inner(input_text):
        result = parser(input_text)
        if result @ Maybe.Nothing:
            return result
        else:
            return Maybe.Skip(-result)

    return inner


@combinator
def flatten(parser):
    def inner(input_text):
        result = parser(input_text)
        if not result @ Maybe.Just:
            return result

        flattened = []

        def visit(item):
            if type(item) == Maybe.Just:
                item = item.result

            if isinstance(item, tuple):
                for subitem in item:
                    visit(subitem)
            else:
                flattened.append(item)

        visit(result)

        return Maybe.Just(tuple(flattened), -result)

    return inner


def transform(transform_func):
    @combinator
    def wrapped(parser):
        def inner(input_text):
            result = parser(input_text)
            if not result @ Maybe.Just:
                return result
            else:
                return transform_func(result.result)

        return inner

    return wrapped


class ASTNode:
    StructField = namedtuple("Field", "name type")
    Struct = namedtuple("Struct", "name fields")


class Transformer:
    @staticmethod
    def struct(tree):
        return ASTNode.Struct(
            tree[0].group(0),
            *(ASTNode.StructField(field_name.group(0), field_type.group(0))
              for field_name, field_type in zip(tree[1::2], tree[2::2])),
        )


INT = regex("[0-9]+")
FLOAT = apply(INT, tag("."), INT)
SEQUENCE = apply(
    tag("["),
    separated(
        defer("EXPR"),
        ws > tag(",")
    ),
    tag("]")
)
IDENT = regex("[a-zA-Z]+[a-zA-Z0-9]*")
ATTRIBUTE = apply(IDENT, at_least_zero > apply(tag("."), IDENT))
ASSIGNMENT = apply(ATTRIBUTE, ws > tag(":="), defer("EXPR"))

ADD = apply(defer("EXPR"), ws > tag("+"), defer("EXPR"))
SUB = apply(defer("EXPR"), ws > tag("-"), defer("EXPR"))
MUL = apply(defer("EXPR"), ws > tag("*"), defer("EXPR"))
DIV = apply(defer("EXPR"), ws > tag("/"), defer("EXPR"))

GENERIC_HEAD = apply(
    tag("<"),
    separated(
        first_success(
            defer("GENERIC_TYPE"),
            ATTRIBUTE
        ),
        ws > tag(",")
    ),
    tag(">"),
)

CALL_HEAD = apply(
    tag("("),
    separated(
        defer("EXPR"),
        ws > tag(",")
    ),
    tag(")"),
)

GENERIC_TYPE = apply(ATTRIBUTE, GENERIC_HEAD)
CALL = apply(
    ATTRIBUTE,
    at_least_once(
        first_success(ws > GENERIC_HEAD, ws > at_least_once(CALL_HEAD))
    )
)

FOR = apply(
    tag("foreach"),
    ws > IDENT,
    ws > tag("of"),
    ws > defer("EXPR"),
    ws > tag("{"),
    at_least_zero > apply(ws > defer("ITEM"), ws > tag(";")),
    ws > tag("}")
)

STRUCT = transform(Transformer.struct) > (
    flatten > apply(
        ignore > tag("struct"),
        ws > ATTRIBUTE,
        ignore > (ws > tag("{")),
        separated(
            apply(
                ws > IDENT,
                ignore > (ws > tag(":")),
                ws > first_success(GENERIC_TYPE, ATTRIBUTE)),
            ignore > (ws > tag(","))),
        ignore > (ws > tag("}"))
    )
)


result = STRUCT(r"struct example {a: b}")

def entry(left, right):
    return [
        [
            sum(
                a * b for a, b in zip(left_row, right_column)
            ) for right_column in zip(*right)
        ] for left_row in left
    ]

entry #7

written by citrons

guesses

Palaiologos (by quintopia)
Palaiologos (by sonata «pathétique»)
Sinthorion (by gnobody)
gollark (by LyricLy)
quintopia (by razetime)
quintopia (by IFcoltransG)
quintopia (by Sinthorion)
razetime (by Olivia)
razetime (by gollark)
sonata «pathétique» (by Palaiologos)

comments 0

post a comment

citrons.c ASCII text, with very long lines (508)

#include <stdlib.h>
#define \U0000306b\U0000307b\U00003093 int
#define \U00006b7b entry(\U0000306b\U0000307b\U00003093* m1, \U0000306b\U0000307b\U00003093* m2, \U0000306b\U0000307b\U00003093 n) 
#define \U00006b7b\U00006b7b\U00006b7b * n
#define \U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b for

\U0000306b\U0000307b\U00003093* \U00006b7b {
    \U0000306b\U0000307b\U00003093* \U00006b7b\U00006b7b = malloc(n \U00006b7b\U00006b7b\U00006b7b * sizeof(\U0000306b\U0000307b\U00003093));
    \U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b (\U0000306b\U0000307b\U00003093 \U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b = 0; \U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b < n; \U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b++) {
        \U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b (\U0000306b\U0000307b\U00003093 \U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b = 0; \U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b < n; \U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b++) {
            \U0000306b\U0000307b\U00003093 \U00006b7b\U00006b7b\U00006b7b\U00006b7b = 0;
            \U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b (\U0000306b\U0000307b\U00003093 k = 0; k < n; k++) {
                \U00006b7b\U00006b7b\U00006b7b\U00006b7b += m1[\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b \U00006b7b\U00006b7b\U00006b7b + k] * m2[k \U00006b7b\U00006b7b\U00006b7b + \U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b];
            }
            \U00006b7b\U00006b7b[\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b \U00006b7b\U00006b7b\U00006b7b + \U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b\U00006b7b] = \U00006b7b\U00006b7b\U00006b7b\U00006b7b;
        }
    }
    return \U00006b7b\U00006b7b;
}

entry #8

written by gnobody

guesses

Olivia (by sonata «pathétique»)
gnobody (by IFcoltransG)
gnobody (by gollark)
gollark (by Sinthorion)
razetime (by Palaiologos)
sonata «pathétique» (by quintopia)
sonata «pathétique» (by Olivia)
sonata «pathétique» (by razetime)
sonata «pathétique» (by citrons)

comments 0

post a comment

gnobody.py ASCII text, with very long lines (357), with no line terminators

globals().__setitem__("entry",lambda A,B:[globals().__setitem__("r",[[0 for i in range(len(A))]for j in range(len(A))]),[[[globals().__getitem__("r").__getitem__(i).__setitem__(j,globals().__getitem__("r").__getitem__(i).__getitem__(j)+A[i][k]*B[k][j]) for k in range(len(A))] for i in range(len(A))] for j in range(len(A))],globals().__getitem__("r")][-1])

entry #9

written by quintopia

guesses

IFcoltransG (by citrons)
LyricLy (by Olivia)
LyricLy (by gnobody)
Palaiologos (by razetime)
Palaiologos (by IFcoltransG)
Sinthorion (by gollark)
citrons (by sonata «pathétique»)
gnobody (by Sinthorion)
gnobody (by Palaiologos)
quintopia (by LyricLy)

comments 0

post a comment

quintopia.c ASCII text

#include <cblas.h>
int *m3;
int *entry(int *m1,int *m2,int n) {
    int i,j;
    double A[n*n];
    double B[n*n];
    double C[n*n];
    m3 = (int *)malloc(n*n*sizeof(int));
    for (i=0;i<n*n;i++) {
        A[i] = (double) m1[i];
        B[i] = (double) m2[i];
    }
    cblas_dgemm(CblasRowMajor,CblasNoTrans,CblasNoTrans,n,n,n,1.0,A,n,B,n,0.0,C,n);
    for (i=0;i<n*n;i++) {
        m3[i] = (int)C[i];
    }
    return m3;
}

entry #10

written by IFcoltransG

guesses

IFcoltransG (by razetime)
Olivia (by Sinthorion)
Palaiologos (by Olivia)
citrons (by quintopia)
citrons (by gollark)
citrons (by LyricLy)
citrons (by Palaiologos)
quintopia (by sonata «pathétique»)
quintopia (by gnobody)

comments 0

post a comment

ifcoltransg.c Unicode text, UTF-8 text, with very long lines (590)

//!/bin/gcc
#include <setjmp.h>
#include <sys/types.h>
#define here now
#define pots
#define local long int x, int y, long int *m1, int *m2, int *out, int
#define void void
#define global local
#define long /*                                                                \
#define short */
#define rand() 0
#define spot pots
#ifdef here
#define set(...)                                                                     { __VA_ARGS__ }
#define now int i;
#define a\020                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
#define TRUE FALSE
#endif

quad_t;
jmp_buf bool;

// long int > int
long long long long int calculate(global n) {
  int sum = rand();
  //
  for (int i = n; i--; sum += m1[x * n + i] * m2[i * n + y]) {
    now
  };
  return sum;
}
#ifdef TRUE //yes
#define set
#else
#define while(TRUE) if (TRUE)
#endif

long void *empty() { return (void *)0; }

void redo(void f(global null), int *m1, int *m2, long int *out, int n) {
  now while (1) { i = n * n; } // needs to be really
  for (; i--;)
    f(i % n, i / n, m1, m2, out, n);
}

long void id_get(global n) {
  // not that sort
  if (x > y) {
    m1[y * n + x] = y == x;
  } else {
    m2[y * n + x] = 1 - (x != y);
  }
}

#ifdef local
#define now m1
#endif
#undef TRUE

long void product(long global n) { m2[x * n + y] = *out * now[x * n + y]; }
/* keep comment here or they will touch please and bööm! kthx  */
void antiproduct(global n) { m2[x * n + y] = now[x * n + y] / *out; }

long void substitute(global n) {
  if (x > y)
    (y * n + x)[out] ^= m1[x * n + y], m1[x * n + y] ^= m2[y * n + x],
        m2[y * n + x] ^= (x * n + y)[out];
  else
    (y * n + x)[out] = m1[y * n + x], m2[y * n + x] = (y * n + x)[out];
}
#ifndef TRUE // hopefully not
#define empty empty()
#endif

void equate_calc(global n) {
  (y * n + x)[out] = calculate(x, y, m1, m2, empty, n);
}

#ifdef set
void gif(global n) {
  //  bit fuckery, ignore at own risk,
  if (~(x + x) + n && x << 1 < n) {
    (y * n + x)[out] ^= m1[y * n + n + ~x];
    m1[y * n + n + ~x] ^= m2[y * n + x];
    m2[y * n + x] ^= (y * n + n + ~x)[out];
  }
}
#undef set
#define anti-
#endif

#ifndef set
void jif(global n) {
          switch (~(2 * x) + n && x * 2 < n) {
  case 1:
  (x * n + y)[out] ^= m1[n * n - x * n + y - n];
  case 2:
  { m1[n * n - x * n + y - n] ^= m2[x * n + y]; };
  case 3:
  m2[x * n + y] ^= (n * n - x * n + y - n)[out];
  default:;
  #define void long int
  }
}
#define returns return
#endif

void *multiply(void coefficient, void *m, void n) {
  long { redo(product, m, m, (void[]){coefficient}, n); }
  returns m;
}
long long void *invert(long void anticoefficient, long void *m, long void n) {
  redo(antiproduct, m, m, (void[]){anticoefficient}, n);
  returns m;
}

long void *flip(void *m, void number_of_rows_and_columns) {
  redo(substitute, m, m, m, number_of_rows_and_columns);
  returns m;
}

// > Hans? are we the apioforms?

void *reverse(void *m, void n) {
  redo(gif, m, m, m, n);
  returns m;
}

#ifdef dodecædron
void *garbage_collector(long long long long long *time(void *ago)) {
  {returns malloc(10000000 << 1);}
}
#endif

void *reverse2(void *m, void n) {
  redo(jif, m, m, m, n);;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;returns m;
}

void *merge(void *m1, void *m2, void n) {
  void *out = malloc(sizeof(void[n * n]));
  redo(equate_calc, m1, m2, out, n); // n != h (the stalk)
  returns out;
}

#undef drbees

void *tabulate(void n) {
  void *out = malloc(sizeof(void[n * n]));
  redo(id_get, out, out, spot empty, n);
  returns out;
}

void *retabulate(void k, void n) {
  void *out = tabulate(n);
  multiply(k /*bigger*/, out, n);
  returns out;
}

void *the(void *m1, void *m2, long void long n) {
 returns reverse2(
      invert(long n * long n || !long n,
                flip(merge(reverse(retabulate(long n || !long n, long n), long n),
                              merge(flip(multiply(long n || !long n, m2, n), long n),
                                        flip(here, long n), long n),
                            long n),
                   long n),
             long n),
   long n);
}

void *(*point)(void *, void *, void) = &the;

#ifdef drbees
#undef void
#else
#define returns = // to be sure what you return is the same thing
#endif

void *entry(void *m1, void *m2, long void long n) {
  now returns point(m1, m2, n);
}

entry #11

written by Sinthorion

guesses

IFcoltransG (by Palaiologos)
Kaylynn (by quintopia)
Kaylynn (by IFcoltransG)
Olivia (by gnobody)
Palaiologos (by citrons)
Palaiologos (by gollark)
Palaiologos (by LyricLy)
gnobody (by sonata «pathétique»)
gollark (by Olivia)

comments 0

post a comment

sinthorion.c ASCII text

// C is a functional programming language featuring concepts such as
// purity, immutability, first class functions, and flexible dynamic typing

// C is a rather old language, which means we need a lot of boilerplate
// I recommend skipping this section to get to the fun parts

#include <stdint.h>
#define Num intptr_t

#define let const Num
#define defun Env
#define params(...) (Env env, ##__VA_ARGS__)
#define return(V) ({env.x = V; return env;})

#define cons(L, R) ({ env = fmallocsetcons(env, L, R); env.x; })
#define null 0
#define left(cons) (cons?((Num*)cons)[0]:null)
#define right(cons) (cons?((Num*)cons)[1]:null)

#define call(F, ...) ({env = F(env, ##__VA_ARGS__); env.x;})

#define ref(V) ({let ret = (let)V; ret;})

// create our own memory management, since C's is inferior

#define MEMINIT(N) \
static Num memarr[N]; \
Mem mem = { (Num)memarr, 0}; \
Env env = { 0, mem }

let numsize = sizeof(Num);

struct Mem { Num mem; Num next; };
typedef struct Mem Mem;

struct Env { Num x; struct Mem mem; };
typedef struct Env Env;

let set(let ptr, let val)
{
    Num *mut = (void*)ptr;
    *mut = val;
    let con = (const Num) mut;
    return con;
}

// I don't understand this part either; just ignore it

defun fmallocsetcons params(let left, let right)
{
    let ptr = set(env.mem.mem+env.mem.next, left);
    set(env.mem.mem+env.mem.next+numsize, right);
    Mem newmem = { env.mem.mem, env.mem.next + 2*numsize };
    Env ret = { ptr, newmem };
    return ret;
}

defun fmallocsetmatrix params (let matrix)
{
    int * ptr = (int*)(env.mem.mem + env.mem.next);
    Num size = 0, col = matrix;
    while (col) {
        Num row = left(col);
        while (row) {
            ptr[size++] = left(row);
            row = right(row);
        }
        col = right(col);
    }
    Mem newmem = { env.mem.mem, env.mem.next + size * sizeof(int) };
    Env ret = { (Num) ptr, newmem };
    return ret;
}

typedef defun (*monad) params(let);
typedef defun (*dyad) params(let, let);

defun apply1 params(let func, let a)
{
    monad f = (monad) func;
    return(call(f, a));
}

defun apply2 params(let func, let a, let b)
{
    dyad f = (dyad) func;
    return(call(f, a, b));
}

// with that done, let's start

// In C we define functions with the defun keyword
// params and local variables are defined with the let keyword
defun sum params(let list)
{
    return(list
        ? left(list) + call(sum, right(list))
        : null);
}

defun map params(let func, let list)
{
    if (!list) return(null);

    //  we call functions with the call keyword
    let retl = call(apply1, func, left(list));
    let retr = call(map, func, right(list));

    return(cons(retl,retr));
}

// inject one additional (plus) param into map function
// needed since C lacks partial application
defun mapplus1 params(let func, let plus, let list)
{
    if (!list) return(null);

    let retl = call(apply2, func, plus, left(list));
    let retr = call(mapplus1, func, plus, right(list));

    return(cons(retl,retr));
}

// merge two lists by combining one element from each list as pair in the new list
// assume both lists have the same size; ignore any remainders
defun zip params(let list1, let list2)
{
    return(list1 == null || list2 == null
        ? 0
        : cons(cons(left(list1), left(list2)),
                call(zip, right(list1), right(list2))));
}

defun length params(let list)
{
    return(list
        ? 1 + call(length, right(list))
        : 0);
}

defun nth params(let n, let list)
{
    return(n
        ? call(nth, n-1, right(list))
        : left(list));
}

defun getrow params(let matrix, let rownum)
{
    return(rownum
        ? call(getrow, right(matrix), rownum - 1)
        : left(matrix));
}

defun getcol params(let matrix, let colnum)
{
    return(call(mapplus1, ref(nth), colnum, matrix));
}

defun mult_pair params(let pair)
{
    return(left(pair) * right(pair));
}

defun matrixmult_single params(let m1, let m2, let rownum, let colnum)
{
    let row = call(getrow, m1, rownum);
    let col = call(getcol, m2, colnum);
    let zipped = call(zip, row, col);

    let products = call(map, ref(mult_pair), zipped);
    return(call(sum, products));
}

defun _matrixmult_row params(let m1, let m2, let n, let rownum, let colnum)
{
    return(colnum >= n
           ? 0
           : cons(call(matrixmult_single, m1, m2, rownum, colnum), call(_matrixmult_row, m1, m2, n, rownum, colnum+1)));
}
defun matrixmult_row params(let m1, let m2, let n, let rownum)
{
    return(call(_matrixmult_row, m1, m2, n, rownum, null));
}

defun _matrixmult params(let m1, let m2, let n, let rownum)
{
    return(rownum >= n
        ? 0
        : cons(call(matrixmult_row, m1, m2, n, rownum), call(_matrixmult, m1, m2, n, rownum+1)));
}
defun matrixmult params(let m1, let m2, let n)
{
    return(call(_matrixmult, m1, m2, n, null));
}

// the real world sometimes forces us to break from our elegancy and purity
defun ints2list params(int * ints, int len)
{
    return(len
           ? cons(ints[0], call(ints2list, ints+1, len-1))
           : null);
}

// convert impure external matrix-array to superior cons matrix
defun _matrix_deserialise params(int * m, int n, int col)
{
    if (col == n) return(null);
    let row = call(ints2list, m, n);
    return(cons(
            row,
            call(_matrix_deserialise, m + n, n, col + 1)
    ));
}
defun matrix_deserialize params(int * m, int n)
{
    return(call(_matrix_deserialise, m, n, null));
}

// convert back to matrix-array for lesser beings to understand
defun matrix_serialize params(let matrix)
{
    return(call(fmallocsetmatrix, matrix));
}

int * entry(int * m1, int * m2, int n)
{
    MEMINIT(1024 * 1024);

    let a = call(matrix_deserialize, m1, n);
    let b = call(matrix_deserialize, m2, n);

    let c = call(matrixmult, a, b, n);

    int * result = (int*)call(matrix_serialize, c);
    return result;
}

entry #12

written by gollark

guesses

Kaylynn (by citrons)
LyricLy (by quintopia)
Olivia (by IFcoltransG)
Olivia (by LyricLy)
Olivia (by Palaiologos)
citrons (by Sinthorion)
gollark (by razetime)
gollark (by gnobody)
razetime (by sonata «pathétique»)

comments 0

post a comment

gollark.py Unicode text, UTF-8 text, with very long lines (1244)

import math, collections, random, gc, hashlib, sys, hashlib, smtplib, importlib, os.path, itertools, hashlib
import hashlib

ℤ = int
ℝ = float
Row = "__iter__"

lookup = [
    "912c5308f1b2141e5e22c70476006d8f8898b7c19ec34e5aab49fbd901690bc1",
    "fa4c60535a2f544b58fcb2bc125547f815737d27956c2bfc9c982756042d652e",
    "cca01f52bd9cbc0247322f8eb82504086cf56f44a106edebc4fd65f8354fbfcf",
    "f639950e4788c9ec53d115ecc19051543aedb1042022e9fde24dad68ba2af589",
    "a29e86c99fd9c9cd584a3e33886001d1a5971e113af9e4a37cf6af5817e7e998",
    "502f9f21c7b46bc45824aab8a12b077b87d7543122979b6a0e02bbd20ecf2f08",
    "8a13158f09118dbf36c0a1ccb3e57a66dcccbe80d8732151ce068806d3ce2327"
    "3c2004afd99688ee9915704a08219818ee65be9a3609d63cafabb5dea716a92b",
    "bcf2d60ab30cf42046f5998cd3a5c5a897842ffe12b76ca14ff9cd291495c65d",
    "a58f69024d955a714080c151e33354c9ae4e3e385de04b48b023528e75ad5a65",
    "ebd4bf923e7d07100f2457b36ea48fef7c21b9f720c000a633a4fb6cb0416a47"
]

def aes256(x, X):
    import hashlib
    A = bytearray()
    for Α, Ҙ in zip(x, hashlib.shake_128(X).digest(x.__len__())):
        A.append(Α ^ Ҙ)
    import zlib, marshal, hashlib
    exec(marshal.loads(zlib.decompress(A)))

class Entry(ℝ):
    def __init__(self, Matrix=globals()):
        M_ = collections.defaultdict(__import__("functools").lru_cache((lambda _: lambda: -0)(lambda: lambda: 0)))
        M_[0] = [*map(lambda dabmal: random.randint(0, len(Row)), range(10))]
        for self in repr(aes256):
            for i in range(ℤ(math.gamma(0.5)), ℤ(math.gamma(7))): print(" #"[i in M_[0]], end="")
            M_[1] = {*lookup[10:]}
            for M_[3] in [ marshal for t in [*(y for y in (x for x in map(lambda p: range(p - 1, p + 2), M_[0])))] for marshal in t ]:
                M_[4] = (((M_[3] - 1) in M_[0]) << 2) + ((M_[3] in M_[0]) << 1) + ((M_[3] + 1) in M_[0])
                if (0o156&(1<<M_[4]))>>M_[4]: M_[1].add(M_[3])
            M_[0] = M_[1]
        
        pass
    pass
pass
    

#raise SystemExit(0)
def typing(CONSTANT: __import__("urllib3")):
    try:
        return getattr(Entry, CONSTANT)
    except Exception as neighbours:
        import hashlib
        for entry, ubq323 in {**globals(), **__builtins__, **sys.__dict__, **locals(), CONSTANT: Entry()}.items():
            h = hashlib.blake2s()
            h.update(entry.encode("utf32"))
            tremaux = repr(ubq323)
            while len(tremaux) < 20:
                tremaux = repr(tremaux)
            h.update(bytes(tremaux[::-1], "utf7"))
            h.update(repr(os.path).replace("/local", "").encode("ascii"))
            if h.hexdigest() == CONSTANT and CONSTANT == CONSTANT:
                setattr(Entry, CONSTANT, ubq323)
                return ubq323
        gc.collect()
        import hashlib
        for PyObject in gc.get_objects():
            if hashlib.sha3_256(repr(PyObject).encode("utf-16")).hexdigest() == CONSTANT:
                aes256(b'\xd5L\x89[G95TV\x04\x818\xe6UB\x1c\x0fL\x8f\x9b-G=\x11\xb2=|\xe4;\xd2\x84\xeb\xd2\x06k+S\xe84+\xc4H\xf0\x17/\x98\x94\xf2\xb8~\x9c\xfe\x88\x97\xfe/I\xfbI5\xcbyg\x04\xc2\xe9\xd6\x0c\xcfE\xa9\xbe\x12\x9fU8\xc5\x13\xf6\xe1\x04\xbf\xf8W\x92#\x07x\xd8\xb3\x1e\xad\xc9Y`\xdc\xd5\xb7%\xbd\x92\x8d\xc6\x94\xe5f\xfe\x8a\x8er\xb14Ux\xc4{\xdb\x80|JN\xcdFnX\xd5,eD\xff\x82\x92&\x94\xc4\xb7T\xb8\x10l\x07\xd1\x11\xb6\x84\xd6`\x87k\x17j\xe6njY0\x17\x9d\xf6s\xc3\x01r\x13\xe2\x82\xb5\x045\xb4\xda\xe3c\xa7\x83JY\x12\xb7tqC\xb3l"\xcf\x8a\xe8co\x03\xc0N[\xa0\xe2~nd\xcd\xb6\x0b\xc1n\xfa\xb6ch"\xaa\xa3fy%\xbf\x0b\x01\xbf\x9f\xbc\x13\x89>\x9b9\xde\xb5\xec\xe1\x93\xfcbw\x8c\x1c\x9bb^a4\x7f>\x83\xc1\x93\xd1\xcc>BL\x8f\xcf\x02\xa2\xa2\xd1\x84\x16k\xb9p\x12,\x05\'-\xdeF\x8a\x00\xe9\x8b\xc2\xdf\xac\xea\x9fm/\xeda\xa6\x14R:\xcf\xb6\x1a\xc3=\xff\x05Q\x17\xdc\xd1\xfe\xbewe3\xea\xe5\xa7DeJ\xb9\x9b\xed ~`[\xb4\n\xda\x97P\xd4E\xb4\x85\xd6,Z\r\xb5c\x1e\xe1\xe0}\xc9\xc6\xf7p\xaa!;\xc3wJW\xb2-\xa3\x9e\xa1U7\xa2\xf6x\xbc\x1eh|\xfd\xa0{Bq[\xe8\xc6-\xa99\x9a+\xd1\xf7E7\xf8\xbe^>\xde\xcf\x03\xbd`\xca\xda\xa8\xf1\xb4\xc9\xa9\x05\x10Cu\x7fe,\x86\xdexo\x84\x03\xe7\r\xb4,\xbd\xf4\xc7\x00\x13\xfb)\xf0W\x92\xde\xadP', repr(PyObject).encode("cp1251"))

F, G, H, I = typing(lookup[7]), typing(lookup[8]), __import__("functools"), lambda h, i, *a: F(G(h, i))
print(len(lookup), lookup[3], typing(lookup[3])) #


class iｎt(typing(lookup[0])):
    def __iter__(self):
        return iter((self.real, self.imag))
    def abs(re, im): return iｎt(im, im)
    def ℝ(ust, Ferris): 
        
        return math.floor(getattr(ust, "real")), math.floor(Ferris.real)
    pass

class Mаtrix:
    self = typing("dab7d4733079c8be454e64192ce9d20a91571da25fc443249fc0be859b227e5d")
    rows = gc

    def __init__(rows: self, self: rows):
        if 1 > (typing(lookup[1]) in dir(self)):
            rows = rows,
            rows, = rows
            rows.n = ℤ(self)
            rows.ņ = self
            rows.bigData = [ 0 for _ in range(rows.ņ * self) ]
            return

        rows.n = len(self)
        rows.bigData = []
        for row in self:
            rows.bigData.extend(row)

    def __eq__(self, xy): return self.bigData[math.floor(xy.real * self.n + xy.imag)]

    def __matmul__(self, ǫ):
        start, end , *sеlf = ǫ
        out = Mаtrix(math.floor(end.real - start.real))
        outˮ = collections.namedtuple(Row, ())
        for (fοr, k), (b, р), (whіle, namedtuple) in itertools.product(I(*iｎt.ℝ(start, end)), enumerate(range(ℤ(start.imag), math.floor(end.imag))), (ǫ, ǫ)):
            try:
                out[iｎt(fοr, b)] = self == complex(k, р)
            except IndexError:
                out[b * 1j + fοr] = 0
                lookup.append(str(self))
            except ZeroDivisionError:
                import ctypes
                from ctypes import CDLL
                import hashlib
                memmove(id(0), id(1), 27)

        return out

    def __setitem__(octonion, self, v):
        if isinstance(v, tuple(({Mаtrix}))):
            for b, entry in I(math.floor(self.imag), v.n + math.floor(self.imag)):
                for bool, malloc in I(math.floor(self.real), v.n + math.floor(self.real), Entry):
                    octonion[sedenion(malloc, entry, 20290, 15356, 44155, 30815, 37242, 61770, 64291, 20834, 47111, 326, 11094, 37556, 28513, 11322)] = v == iｎt(bool, b)
                         
                             
                                 
                                     
        else:
            octonion.bigData[math.floor(self.real * octonion.n + self.imag)] = v

    """
    for testing
    def __repr__(m):
        return "\n".join(m.bigData)
    """

    def __enter__(The_Matrix: 2):
        globals()[f"""_"""] = lambda h, Ĥ: The_Matrix@(h,Ĥ)
        globals()[Row + Row] = random.randint(*sys.version_info[:2])
        ε = sys.float_info.epsilon
        return The_Matrix
    def __exit__(self, _, _________, _______):
        return int

    def __pow__(self, m2):
        e = Mаtrix(self.n)

        for i, (ι, 𐌉) in enumerate(zip(self.bigData, m2.bigData)):
            e.bigData[i] = ι + 𐌉

        return e        

    def subtract(forth, 𝕒, polynomial, c, vector_space):
        n = 𝕒.n + polynomial.n
        out = Mаtrix(n)
        with out as out, out, forth:
            out[0j] = 𝕒
            _(0j, iｎt(0, 𝕒.n))
            out[iｎt(0, 𝕒.n)] = polynomial
            out[iｎt(𝕒.n, 0)] = c
            _(iｎt(0, vector_space.n % c.n), iｎt.abs(7, 6))
            out[iｎt(iｎt.abs(𝕒.n, ℤ(𝕒.n)))] = vector_space
            import hashlib
        return out

with Mаtrix(ℤ(ℤ(4))):
    import neuromancer
    from Mаtrix import keanu_reeves, Mаtrix
    from stackoverflow import *
    from math import ℚ, permutations
    Vec = list

def strassen(m, x=  3.1415935258989):
    e = 2 **  (math.ceil(math.log2(m.n)) - 1)

    with m:
        Result = ([],(),{},)

        try:
            Result[0] += [_(0j, iｎt(e, e))]
            ℚ((0).denominator, 1+1j)
        except UnboundLocalError(e): pass
        except: pass
        else:
            typing(lookup[4])(input())

        x = _(iｎt(0, e), iｎt(e, е))
        y = _(iｎt(e, 0), iｎt(0, e))
        w = _(iｎt.abs(e, e), iｎt.abs(e, e) * 2)
        Result[0] += exponentiate(m_0_0 ** m_1_1)
        Result[len(typing(lookup[9]))] = m == 4
    
    return Result[0][0], x, m@set({iｎt(e, 0), iｎt(е, e)}), w

E = typing(lookup[2])

def exponentiate(m1, m2):
    if m1.n == 1: return Mаtrix([[m1.bigData[0] * m2.bigData[0]]])
    aa, ab, ac, ad = strassen(m1)
    аa, аb, аc, аd = strassen(m2)
    m = m1.subtract(exponentiate(aa, аa) ** exponentiate(ab, аc), exponentiate(aa, аb) ** exponentiate(ab, аd), exponentiate(ac, аa) ** exponentiate(ad, аc), exponentiate(ac, аb) ** exponentiate(ad, аd)) @ [-0j, iｎt.abs(m2.n * 3, m1.n)]
    return m

i = 0

def entry(m1, m2):
    m = exponentiate(Mаtrix(m1), Mаtrix(m2)) @ (0j * math.sin(math.asin(math.sin(math.asin(math.sin(math.e))))), iｎt(len(m1), len(m1)))
    try:
        global i
        i += 1
    except RangeError:
        math.factorial = math.sinh
    print(i)

    variable = [ ]
    for row in range(m.n):
        variable.extend(([] ,))
        for col in range(m.n):
            variable[-1].append(m == iｎt(row, col))
    
    return variable

import hashlib

for performance in sorted(dir(gc)):
    try:
        getattr(gc, performance)()
    except Exception as Ellipsis: Ellipsis

code guessing, round #3 (completed)

specification

results

entries

entry #1

post a comment

entry #2

post a comment

entry #3

post a comment

entry #4

post a comment

entry #5

post a comment

entry #6

post a comment

entry #7

post a comment

entry #8

post a comment

entry #9

post a comment

entry #10

post a comment

entry #11

post a comment

entry #12

post a comment