Dada una matriz de enteros positivos Acomo entrada, genera un programa que, cuando se repite por ktiempos , genera el valor kth (1-index) de la matriz.

Por ejemplo, si la matriz es [1,11], la salida debe ser un programa que emite 1, y cuando se repite dos veces, la salida 11. El código como print(end="1");en Python 3 funciona: print(end="1");imprime 1 e print(end="1");print(end="1");imprime 11

La suma más pequeña de longitudes de código para resolver todos los casos de prueba gana. Su metacódigo debería resolver 500 casos de prueba en 60s, y cada uno de sus códigos de solución debería regresar en 10s. El metacódigo y el código de la solución no necesitan estar en el mismo idioma, pero todas las soluciones que genere su metaprograma deben estar en el mismo idioma.

Los datos de prueba previa y el generador se pueden ver aquí . 7 días después utilizará la suma del tiempo de envío (por ejemplo, 12:34, 1234) para ser la semilla aleatoria y generar otro caso de prueba como el caso de prueba final.

La semilla final es 7335 en GMT + 8, por lo que los datos de la prueba final están aquí

Python 3 , genera Stax

Esto usa una variedad de estrategias. La mayoría de las estrategias solo se aplican bajo ciertas condiciones, pero hay una estrategia alternativa que siempre es utilizable. Al final, se selecciona el programa candidato más pequeño.

from functools import reduce
from math import sqrt

symbols = " !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_abcdefghijklmnopqrstuvwxyz{|}"

def uncycle(arr):
    for size in range(1, len(arr)):
        if all(e == arr[i % size] for (i, e) in enumerate(arr)):
            return arr[:size]
    return arr

def constant(val):
    return "A" if val == 10 else str(val)

def shift(val):
    if not val: return ""
    return constant(abs(val)) + "+-"[val < 0]

def encode(a, offsetMode):
    result = "";
    if offsetMode:
        for i in range(len(a) - 1, 0, -1):
            a[i] -= a[i - 1]
    for i in range(len(a)):
        parts = []
        signBit = (a[i] < 0) * 2
        continuing = (offsetMode and i == len(a) - 1) * 1
        remain = abs(a[i])
        while remain > 22:
            parts.insert(0, remain % 46 * 2 + continuing);
            remain //= 46
            continuing = 1

        parts.insert(0, remain * 4 + signBit + continuing)
        result += "".join(symbols[p] for p in parts)
    
    return result

def cram(arr):
    flat = encode(arr, False)
    offset = encode(arr, True)
    return offset if len(offset) < len(flat) else flat;

def issquare(num):
    root = int(sqrt(num))
    return root * root == num

def isgeometric(arr):
    r = arr[0]
    return all(r ** (i + 1) == e for (i,e) in enumerate(arr))

def generateProgram(arr):
    candidates = []
    rotated = uncycle(arr)
    rotated = rotated[-1:] + rotated[:-1]

    deltas = [b - a for a,b in zip(arr, arr[1:])]

    # single constant strategy
    if len(arr) == 1:
        candidates.append(constant(arr[0]))

    # repeated constant
    elif len(set(arr)) == 1:
        num = arr[0]
        if num == 10: candidates.append("A")
        if num % 2 == 0: candidates.append(constant(num // 2) + "H")
        if issquare(num): candidates.append(str(int(sqrt(num))) + "J")
        candidates.append(constant(num - 1) +  "^")

    # repdigit
    if len(arr) == 2 and 10 < arr[1] == arr[0] * 11 < 100:
        candidates.append(str(arr[0]) + "p")

    # single digits
    if max(arr) < 10:
        candidates.append("".join(map(str, rotated)) + "E|X@")

    # max 10
    if max(arr) == 10 and rotated[0] != 1:
        candidates.append("".join(str(e - 1) for e in rotated) + "E|X@^")

    fns = [
        ("", lambda x: x),
        ("H", lambda x: 2 * x),
        ("^", lambda x: x + 1),
        ("J", lambda x: x * x),
        ("Hv", lambda x: 2 * x - 1),
        ("H^", lambda x: 2 * x + 1),
        ("^H", lambda x: 2 * x + 2),
        ("HJ", lambda x: 4 * x * x),
        ("JH", lambda x: 2 * x * x),
        (":T", lambda x: x * (x + 1) / 2),
        ("|F", lambda x: reduce(lambda a, b: a*b, range(1, x+1))),
        ("J^", lambda x: x * x + 1),
        ("^J", lambda x: x * x + 2 * x + 1),
    ]
    for (stax, fn) in fns:
        if all(fn(i + 1) == e for (i,e) in enumerate(arr)):
            candidates.append("|X" + stax)

    # fixed delta
    if len(set(deltas)) == 1:
        delta = deltas[0]
        start = arr[0] - delta
        if start == 0:
            candidates.append(shift(delta))
        if delta == 1:
            candidates.append("|X" + shift(start))
        elif delta == -1:
            candidates.append("|x" + shift(start))
        elif delta > 1:
            candidates.append("|X" + constant(delta) + "*" + shift(start))
        elif delta < -1:
            candidates.append("|x" + constant(-delta) + "*" + shift(start))

    # geometric series
    if isgeometric(arr):
        candidates.append(constant(arr[0]) + "*")

    # prefix
    if len(arr) == 2 and arr[1] // 10 == arr[0] < 10:
        candidates.append("." + str(arr[1]) + "|X(")

    # suffix
    if len(arr) == 2 and arr[0] % 10 == arr[1] < 10:
        candidates.append("." + "".join(map(str, arr)) + "|X)")

    # uncycled cram
    candidates.append('"' + cram(rotated) + '"!|X@')
    
    candidates.sort(key=len)
    return candidates[0]

while True:
    arr = eval(input())
    prog = generateProgram(arr)
    print(prog)

Pruébalo en línea!

Actualización: Validación Llevará mucho tiempo ejecutar cada multiplicidad de cada programa por separado. Es posible ejecutarlos todos al mismo tiempo. Para hacer esto, se debe usar una pequeña pieza de código. Es responsable de algunas cosas.

1. Hacer salida implícita si hay alguna. Normalmente, al final de un programa stax, la parte superior de la pila se imprime si no ha habido otra salida. Al ejecutar varios programas en el mismo archivo fuente, esto debe hacerse explícitamente.

2. Despeja ambas pilas.

3. Restablecer registros. Para estos programas solo se utiliza el registro x.

Esta repetitiva debe aplicarse después de cada programa individual que se ejecutará.

|d{P}{zP}?0XLd

Por ejemplo, la entrada [5,2,7,3]produce el programa stax 3527E|X@. Las cuatro multiplicidades se pueden probar a la vez.

3527E|X@
|d{P}{zP}?0XLd

3527E|X@3527E|X@
|d{P}{zP}?0XLd

3527E|X@3527E|X@3527E|X@
|d{P}{zP}?0XLd

3527E|X@3527E|X@3527E|X@3527E|X@
|d{P}{zP}?0XLd

Pruébalo en línea!

De esta manera, es posible probar todas las multiplicidades de todos los programas en la misma ejecución, suponiendo que nada se rompa. Probablemente sería el programa stax más grande que se haya ejecutado si se realizan las 500

Perl 5 -p , genera Perl 5 -p , gastos generales 19 17 13

-1 gracias a @Dom Hastings

La puntuación para una entrada será length of the input + 13. Obviamente, se puede mejorar generando programas de autodescompresión para entradas más grandes, pero no me molestaré.

Proporcione la matriz de entrada separada por comas en una línea en STDIN.

#!/usr/bin/perl -p
chomp;$_="}{\$_=($_)[\$%++]"

Pruébalo en línea!

Ejecute los ntiempos concatenados de salida sin entrada (por ejemplo, redirigir desde / dev / null)

Ejemplo de forma de ejecutarlo para la entrada 2,6,4,7y el programa resultante se repite 4 veces:

perl -p '}{$_=(3,6,4,7)[$%++]}{$_=(3,6,4,7)[$%++]}{$_=(3,6,4,7)[$%++]}{$_=(3,6,4,7)[$%++]' < /dev/null

Pruébalo en línea!

Si no le gusta que el programa resultante intente leer desde STDIN, use esta versión con la sobrecarga 17:

#!/usr/bin/perl -p
chomp;$_="1/!say+($_)[\$-++],"

Pruébalo en línea!

Ejemplo de forma de ejecutarlo para la entrada 2,6,4,7y el programa resultante se repite 4 veces:

perl -E '1/!say+(2,6,4,7)[$-++],1/!say+(2,6,4,7)[$-++],1/!say+(2,6,4,7)[$-++],1/!say+(2,6,4,7)[$-++],'

Pruébalo en línea!

Esta versión se bloquea después de imprimir la salida requerida

05AB1E , genera 05AB1E

¸»“"ÿ"#.g<“ƵƒçJ

Pruébalo en línea!

El programa generado para la entrada [5,17,7,13,2]es "5 17 7 13 2"#.g<è.

Conjunto de pruebas para [5,17,7,13,2]

La duración del programa generado es len(input) + 5

APL (Dyalog Unicode)

Prefijo anónimo lambda. Devuelve un cuerpo del programa.

 {
     1=≢⍵:⍕⍵ ⍝ single element

     (2=≢⍵)∧(⍵[2]=11×⍵[1]):⍕⍵[1] ⍝ 2, 22 etc.

     1=≢∪⍵:'⊢',⍕⊃⍵ ⍝ all the same

     (⊢≡⊃×⍳∘≢)⍵:'+',⍕⊃⍵ ⍝ linear

     ((⌊=⊢)!⍣¯1⊢⊃⍵)∧(1∧.=1↓⍵):'!',⍕!⍣¯1⊃⍵ ⍝ factorial followed by all 1s

     (⍵[2]∧.=1↓⍵)∧(⍵[1]=10|2⊃⍵):(⍕⊃⍵),'⌈',(⊃⍕2⊃⍵) ⍝ b ab ab ab

     e←{∊⍉2 2⍴'+×',⍕¨⍵}¨⍸(⊃⍵)=∘.×⍨⍳10
     b←⍵∘≡¨e(({0::⍬ ⋄ ⍎⍵}¨,\)⍴∘⊂)¨⍨(≢⍵)
     ∨/b:⊃b/e

     Q←{'''',⍨⍵/⍨1+''''=⍵}
     (5∧.≤⍵)∧(≢⍕⍵)>6+(+/14=⍵)+≢⍵:'{⍺←⎕AV⍳⊃⋄1⌽⍺⊢⍵}''',Q ⎕AV[⍵] ⍝ string fallback

     (≢⍕⍵)>9+(+/5=⍵)+≢⍵:'{⍺←¯4+⎕AV⍳⊃⋄1⌽⍺⊢⍵}''',Q ⎕AV[4+⍵] ⍝ offset string fallback

     '{⍺←⊃⋄1⌽⍺⊢⍵}',⍕⍵ ⍝ fallback
 }

Pruébalo en línea!

Métodos

Esto explora varios métodos y devuelve el primero utilizable, eventualmente recurriendo a un método universalmente aplicable.

Solo elemento

Si la lista tiene solo un elemento, se devuelve tal cual.

2, 22 etc.

Se puede repetir un solo dígito para generar el número 11 veces más grande,

Todos iguales

Acabamos de devolver el ⊢número ( ) más a la derecha .

Lineal

Las secuencias f (n) = k × n simplemente insertan un signo más antes del primer término.

Factorial seguido de todos los 1s

Cuando el primer número n =! My los números siguientes son 1, entonces !mes una solución porque !mes n y m!mes 1 y !1es 1.

b ab ab ab

Como todos los números de dos dígitos son más grandes que todos los números de un solo dígito, un máximo continuo, donde el frente del primer número está pegado a la parte posterior del segundo número, es una solución.

El código de tres líneas

Compruebe si alguna fórmula del tipo +a×bes válida.

Caída de cuerda

Las secuencias largas sin números inferiores a 5 (porque 4 es un salto de línea) se pueden codificar como caracteres del SBCS.

Desplazamiento de la cadena de retroceso

Si hay números menores a 5, subimos 9 para evitarlos.

Retroceder

Concatenación de cadena simple de la cadena "{⍺←⊃⋄1⌽⍺⊢⍵}"y la ⍕entrada stringified ( ). Por ejemplo, [3,1,4]devuelve el cuerpo del programa {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4.

La parte entre llaves es una función ambivalente, lo que significa que puede ser una función de prefijo o una función de infijo. Por lo tanto, la instancia más a la izquierda se ejecutará en modo prefijo y todas las demás en modo infijo. La diferencia entre los modos es si ⍺, significando el argumento izquierdo, tiene un valor. Si no es así, se le asignará la función ⊃(primero).

Explicación del método alternativo

{… } Lambda anónima:

 ⍺←⊃ Si no hay argumento izquierdo ( ⍺), asigne la función ⊃(primero) a⍺

 ⋄ entonces:

En este punto, el siguiente código significa dos cosas diferentes dependiendo de si se ⍺trata de una lista de números (llamada infijada) o la función "primero" (llamada prefijada).

 Si ⍺es una lista de números:

  ⍺⊢⍵ descartar el argumento izquierdo a favor del argumento derecho

  1⌽ gire ese paso hacia la izquierda

 Si ⍺es la función "primero":

  ⊢⍵ dar el argumento correcto

  ⍺ elige el primer elemento de eso

  1⌽ gírelo un paso (un no-op en un escalar)

Ejemplo de ejecución del método alternativo

Al ejecutar 3 1 4el código {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4,, asigna la "primera" función ⍺y, por lo tanto, devuelve el primer elemento; 3.

La ejecución {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4permite que la lambda más a la derecha "capture" la izquierda 3 1 4como su argumento izquierdo, por lo que ⍺tiene un valor que se descarta a favor del 3 1 4cual luego se gira un paso hacia la izquierda y se obtiene 1 4 3como resultado. Esto se usa como único argumento para el lambda más a la izquierda, donde se ⍺convierte en la "primera" función, lo que hace que el resultado sea el primer elemento; 1.

La ejecución {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4permite que la lambda más a la derecha "capture" el medio 3 1 4como su argumento izquierdo, que luego se descarta a favor del argumento derecho 3 1 4, que cuando se gira un paso hacia la izquierda lo es 1 4 3. Esto se usa como argumento derecho de la lambda media junto con el 3 1 4argumento más a la izquierda como izquierdo. El argumento de la izquierda se descarta por el de la derecha, que gira un paso hacia la izquierda 4 3 1. Esto se convierte en el único argumento de la lambda más a la izquierda, por lo que se ⍺convierte en la "primera función", devolviendo el primer elemento; 4.

Puntuación

Cuando llegue el momento de realizar la prueba con datos reales, use este arnés de prueba (vinculado con datos de prueba previa). Los casos de prueba van en el campo Entrada, y la Salida será el recuento total de bytes de los 500 programas juntos. (También arrojará un error, pero eso es solo porque luego intenta evaluar la entrada tal como está).

Carbón

´⎚´§´⪪⪫ＩＡ ”y¦ Ｌυ⊞υω

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

´⎚´§´⪪

Salida de la cadena literal ⎚§⪪.

⪫ＩＡ 

Convierta la matriz de entrada en una cadena, únase con espacios e imprima.

”y¦ Ｌυ⊞υω

Salida de la cadena literal ¦ Ｌυ⊞υω.

Salida de por ejemplo 5,17,7,13,2es ⎚§⪪5 17 7 13 2¦ Ｌυ⊞υω. Pruébalo en línea! Explicación:

⎚

Borre el lienzo para que solo se vea la última salida.

§⪪5 17 7 13 2¦ Ｌυ

Tome la longitud de la lista predefinida u. Use eso para indexar en la lista de enteros que se han dividido en espacios y generar el elemento seleccionado.

⊞υω

Empuje una variable ficticia a la lista predefinida u, de modo que la próxima copia muestre el siguiente elemento de la lista.

Longitud total de salida = (longitud de todos los enteros en todas las listas) + (número de enteros en todas las listas) + (número de listas * 9) caracteres (SBCS).

Haskell , genera Haskell

main = interact $ ("main=print$("++) . (++"!!)$ -1\n +1--")

Pruébalo en línea! Para el primer caso de prueba [5,2,7,3,2,3,15,10,7,2,14,11,16,16,3,3,4,3,8,4]produce el siguiente programa:

main=print$([5,2,7,3,2,3,15,10,7,2,14,11,16,16,3,3,4,3,8,4]!!)$ -1
 +1--

Pruébalo una vez , duplicado y triplicado . Esto usa el mismo enfoque que mi respuesta de Haskell para Doblar la fuente, tú doblas la salida .

La longitud de cada programa generado es la longitud de la lista de entrada como cadena más 25, por lo tanto, la puntuación para los casos de prueba disponibles actualmente es 12266 + 500 * 25 = 24766. Esto muestra que la relación de código a datos es básicamente igual, y dudo que sea posible escribir un código de descompresión lo suficientemente pequeño que disminuya la puntuación. Podría ser posible si las listas fueran mucho más grandes.

Python 2 , genera Python 2

import sys
a=`input()[::-1]`.replace(' ','')
sys.stdout.write('print%s[-open(__file__,"a").tell()/%s]#'%(a,len(a)+37))

Pruébalo en línea!

Para la entrada

[10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29]

el programa generado es

print[29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10][-open(__file__,"a").tell()/98]#

que es de 98 bytes.

Adaptado de esta solución en "Doblo la fuente, ¡doblas la salida!".

Maldición, aparecieron dos respuestas más cortas antes de que terminara de escribir esta respuesta.

Java 8, genera Python 2

interface M{static void main(String[]a){int l=a[0].length();System.out.print("print"+a[0]+"[open(__file__,'a').tell()/"+(l+35+(l+"").length())+"]#");}}

Pruébalo en línea.

Es decir, [3,4,5,6,7]genera este programa Python 2:

print[3,4,5,6,7][open(__file__,'a').tell()/48]#

Pruébelo en línea una vez ; Pruébelo en línea dos veces ; Pruébelo en línea tres veces .

El programa Python generado se basa en la respuesta de @ Mr.Xcoder por tercera vez al desafío del encanto .

Explicación:

Código Java 8:

interface M{                    // Class
  static void main(String[]a){  //  Mandatory main-method
    int l=a[0].length();        //   The length of the first argument
                                //   (Note that this is the length of the input as String,
                                //   not the size of the array)
    System.out.print(           //   Print:
      "print"                   //    Literal "print"
      +a[0]                     //    Appended with the argument
      +"[open(__file__,'a').tell()/"
                                //    Appended with literal "[open(__file__,'a').tell()/"
      +                         //    Appended with an integer that is formed by:
       (l                       //     Getting the length we got earlier
       +35                      //     +34 for the rest of the Python 2 code + 1
       +(l+"").length())        //     + the length of the length (<10→1; 10-99→2; etc.)
       +"]#");}}                //    Appended with literal "]#"

Código de Python 2:

print                        # Print
 [3,4,5,6,7]                 #  From this array
 [                           #   The `k`'th item,
  open(__file__,'a').tell()  #   where `k` is the length of its own source code
  /                          #   divided by
  48                         #   the length of its own source code (once) + 1
 ]#                          # With a trailing comment, so we can repeat the program

Bash, programas de salidas en Perl 5

El programa Bash se puede llamar como script.sh 1,2,3.

Se debe llamar al programa Perl con la -Ebandera.

echo "shift@a;@a=($1)unless@a;END{say\$a[0];exec'true'}"

El perlcódigo generado para una entrada de 4,7,8es:

shift@a;@a=(4,7,8)unless@a;END{say$a[0];exec'true'}

Bastante fuerza bruta. Elimina un elemento de la matriz ( perlno le importa que la matriz no exista al principio), lo configura si aún no está configurado. Luego hace eco del primer elemento de la matriz al final. (El ENDbloque se ejecuta en último lugar). El exec 'true'sale del programa, de manera que los más ENDbloques no se ejecutan.

Ejemplo:

#Once
$ perl -E "$(bash script.sh 4,7,8)"
4

#Duplicated twice
$ perl -E "$(bash script.sh 4,7,8)$(bash script.sh 4,7,8)"
7

#Duplicated thrice
$ perl -E "$(bash script.sh 4,7,8)$(bash script.sh 4,7,8)$(bash script.sh 4,7,8)"
8

Python 2, genera C ++

Esto no va a batir ningún registro, estaba principalmente interesado en pensar si podría descubrir cómo hacerlo :) Use el hecho de que las variables globales se ejecutan antes que main, y así puede incrementar una variable global, luego usar un #ifdef para garantizar que main solo se defina una vez.

import sys
print("""#include <stdio.h>
#ifndef A
#define A
int v;
int d[]={""" + sys.argv[1] + """};
struct C{C(){v++;}};
int main(void){ printf("%d",d[v]); }
#else
C c1;
#endif
""")

Encantamientos rúnicos , genera Runic

74akw94/85akw
R32B~~?US' Sqq1Ky1Ky
\i<{1[lil1-{S{)]{{1KyB
D'0$'´$$' $     Rl0) ?
R"{Zs$;|1|l;|y"@
"UwR'10<|I+}"$~ /' Su0
       Rakwc4akw/

Pruébalo en línea!

Toma datos como una lista de valores separados por espacios.

Salida hecha una vez
Salida hecha dos veces
Salida hecha cuatro veces

Utiliza el comando de modo de lectura numérico continuo, ´que se confirmó el 12 de enero y encontré esta pregunta el 14. Este comando permite la codificación de valores de longitud arbitrarios, ya que sin esta característica sería muy difícil hacerlo (por ejemplo 1392, necesitaría ser representado como 1X3+X9+X2+, lo que requiere un bucle adicional como mínimo); precisamente el problema que quería resolver cuando creé el´ comando.

En el código original, el |de las cuerdas "{Zs$;|1|l;|y"y "UwR'10<|I+}"se sustituyen por \n(que se sientan en la red y lo modifica, como lo harían normalmente) con wcomandos de rito: 74akw, 94/Rakw, c4akw, y 85akw. Los personajes originales pueden ser literalmente cualquier cosa. |fue elegido para ser un marcador de posición simbólico que representaba visualmente lo que quería. Se guardan varios bytes (si no se anulan) al no tener que agregar reflexivamente un punto de entrada, ya que se wR'10<escribe Ren una ubicación donde ya existe uno (posición 0,1), y luego se llena su pila de basura antes de quedarse sin maná, luego de un bucle secuencia U"'i34.

El código de salida resultante funciona utilizando el wcomando rite para cambiar el primer carácter en la segunda línea a una Rredirección ight (por lo que solo una IP ejecuta una declaración de impresión), con un uso inteligente de la longitud de la pila como resultado de programas cada vez más altos para determinar qué índice leer. Cualquier otra IP cambia esa misma ubicación a la misma instrucción y termina. Todo lo demás queda sin usar.

_{La imagen no está actualizada, pero es suficiente para la explicación del flujo.}

Cada ejecución de 1Iymantiene la capacidad de la IP para manejar una pila cada vez más grande (causada por el lcomando), cuyo tamaño permite que el programa determine cuántas copias del código fuente base hay. El final 1se usa para incrementar el número anterior lal requerido al girar la pila (creada a continuación) para llegar al valor correcto. El Zcomando niega este valor para que la pila gire en la dirección correcta.

La matriz de entrada original se codifica utilizando el modo de lectura continua, cebada con un 0 para evitar modificar gradualmente el mismo valor, para leer las entradas originales. Se requiere el espacio NOP para salir del modo de lectura continua y permitir que el 0 posterior cebe la pila nuevamente.

La puntuación debe ser aproximadamente igual 3+v.toString().length, para cada entrada de matriz v, +23para cada matriz. Aproximadamente (2.55*total length of input)o 33837para la entrada de muestra, si hice las cosas bien.

Se introdujeron cambios menores en mi programa final esperado debido a los efectos secundarios introducidos en la misma compilación con respecto al scomando, sin embargo, resultó en una mejor puntuación al mismo tiempo.