Dada uma matriz de números inteiros positivos Acomo entrada, gere um programa que, quando repetido por kvezes , gera o valor kth (1-index) da matriz.

Por exemplo, se a matriz for [1,11], a saída deve ser um programa que emita 1e, quando repetido duas vezes, emita 11. Código como print(end="1");no Python 3 funciona: print(end="1");imprime 1 e print(end="1");print(end="1");imprime 11

A menor soma dos comprimentos de código para resolver todos os casos de teste vence. Seu meta-código deve resolver 500 casos de teste nos anos 60 e cada código da solução deve retornar em 10s. O meta-código e o código da solução não precisam estar no mesmo idioma, mas todas as soluções que seu metaprograma gera devem estar no mesmo idioma.

Os dados e o gerador do pré-teste podem ser vistos aqui . Sete dias depois, a soma do tempo de envio (por exemplo, 12:34 significa 1234) será a semente aleatória e gerará outro caso de teste como o caso final.

A semente final é 7335 em GMT + 8, então os dados finais do teste estão aqui

Python 3 , gera Stax

Isso usa uma variedade de estratégias. A maioria das estratégias se aplica apenas sob certas condições, mas há uma estratégia de fallback sempre utilizável. No final, o menor programa candidato é selecionado.

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)

Experimente online!

Atualização: validação Demorará muito tempo para executar cada multiplicidade de cada programa separadamente. É possível executá-los todos ao mesmo tempo. Para fazer isso, um pequeno pedaço de código deve ser usado. É responsável por algumas coisas.

1. Faça saída implícita, se houver. Normalmente, no final de um programa stax, a parte superior da pilha é impressa se não houver outra saída. Ao executar vários programas no mesmo arquivo de origem, isso deve ser feito explicitamente.

2. Limpe as duas pilhas.

3. Redefinir registros. Para esses programas, apenas o registro x é usado.

Este padrão deve ser aplicado após cada programa individual a ser executado.

|d{P}{zP}?0XLd

Por exemplo, a entrada [5,2,7,3]produz o programa stax 3527E|X@. Todas as quatro multiplicidades podem ser testadas ao mesmo tempo.

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

Experimente online!

Dessa forma, é possível testar todas as multiplicidades de todo o programa na mesma execução, assumindo que nada ocorra. Provavelmente seria o maior programa stax já executado se todos os 500 forem concluídos.

Perl 5 -p , gera Perl 5 -p , sobrecarga 19 17 13

-1 graças a @Dom Hastings

A pontuação para uma entrada será length of the input + 13. Obviamente, pode ser aprimorado gerando programas auto-descompressivos para entradas maiores, mas não vou me incomodar.

Dê à matriz de entrada separada por vírgulas em uma linha em STDIN.

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

Experimente online!

Execute os ntempos concatenados de saída sem entrada (por exemplo, redirecionamento de / dev / null)

Exemplo de maneira de executá-lo para entrada 2,6,4,7e o programa resultante repetido 4 vezes:

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

Experimente online!

Se você não gostar do programa resultante tentando ler do STDIN, use esta versão com sobrecarga 17:

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

Experimente online!

Exemplo de maneira de executá-lo para entrada 2,6,4,7e o programa resultante repetido 4 vezes:

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)[$-++],'

Experimente online!

Esta versão falha após imprimir a saída necessária

05AB1E , gera 05AB1E

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

Experimente online!

O programa gerado para a entrada [5,17,7,13,2]é "5 17 7 13 2"#.g<è.

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

A duração do programa gerado é len(input) + 5

APL (Dyalog Unicode)

Prefixo anônimo lambda. Retorna um corpo do 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
 }

Experimente online!

Métodos

Isso explora vários métodos e retorna o primeiro método utilizável, eventualmente voltando a um método universalmente aplicável.

Elemento único

Se a lista tiver apenas um elemento, ela será retornada como está.

2, 22 etc.

Apenas um dígito pode ser repetido para gerar o número 11 vezes maior,

Tudo o mesmo

Acabamos de retornar o ⊢número mais à direita ( ).

Linear

Seqüências f (n) = k × n apenas inserem um sinal de adição antes do primeiro termo.

Fatorial seguido por todos os 1s

Quando o primeiro número n =! Me os números subsequentes são 1, então !mé uma solução porque !mé n e m!mé 1 e !1é 1.

b ab ab ab

Como todos os números de dois dígitos são maiores que todos os números de um dígito, um número máximo máximo, em que a frente do primeiro número está colada na parte de trás do segundo número, é uma solução.

O código de três linhas

Verifique se alguma fórmula do tipo +a×bé válida.

Fallback de cadeia

Sequências longas sem números abaixo de 5 (porque 4 é uma quebra de linha) podem ser codificadas como caracteres do SBCS.

Fallback de string deslocada

Se houver números abaixo de 5, aumentamos 9 para evitá-los.

Cair pra trás

Concatenação simples de string "{⍺←⊃⋄1⌽⍺⊢⍵}"e a ⍕entrada stringified ( ). Por exemplo, [3,1,4]retorna o corpo do programa {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4.

A peça entre chaves é uma função ambivalente, o que significa que pode ser uma função de prefixo ou uma função de infixo. Assim, a instância mais à esquerda será executada no modo prefixo, e todas as outras no modo infix. A diferença entre os modos é se ⍺, significando o argumento esquerdo, tem um valor. Caso contrário, será atribuída a função ⊃(primeiro).

Explicação do método de fallback

{… } Lambda anônima:

 ⍺←⊃ Se não houver argumento à esquerda ( ⍺), atribua a função ⊃(primeiro) a⍺

 ⋄ então:

Nesse momento, o código a seguir significa duas coisas diferentes, dependendo se ⍺é uma lista de números (chamada de infixo) ou a função "primeiro" (chamada de prefixo).

 Se ⍺é uma lista de números:

  ⍺⊢⍵ descartar o argumento da esquerda em favor do argumento da direita

  1⌽ gire esse passo para a esquerda

 If ⍺é a função "first":

  ⊢⍵ produzir o argumento certo

  ⍺ escolha o primeiro elemento disso

  1⌽ gire um passo (um no-op em um escalar)

Exemplo de execução do método de fallback

3 1 4O código da execução {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4, atribui a função "primeiro" a ⍺e, portanto, retorna o primeiro elemento; 3.

A execução {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4permite que o lambda mais à direita "capture" a esquerda 3 1 4como seu argumento à esquerda, portanto, ⍺tenha um valor que é descartado a favor do 3 1 4qual é então girado um passo à esquerda e produz 1 4 3como resultado. Isso é usado como argumento único para o lambda mais à esquerda, onde ⍺se torna a "primeira" função, fazendo com que o resultado seja o primeiro elemento; 1.

A execução {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4permite que o lambda mais à direita "capture" o meio 3 1 4como argumento à esquerda, que é descartado em favor do argumento à direita 3 1 4, que quando girado um passo à esquerda é 1 4 3. Isso é usado como argumento à direita do lambda do meio junto com o 3 1 4argumento mais à esquerda como à esquerda. O argumento da esquerda é descartado para a direita, que girou um passo para a esquerda 4 3 1. Isso então se torna o único argumento do lambda mais à esquerda, ⍺tornando-se a "primeira função", retornando o primeiro elemento; 4.

Pontuação

Quando chegar a hora de testar usando dados reais, use este equipamento de teste (vinculado preenchido com dados de pré-teste). Os casos de teste vão no campo Entrada e a Saída será a contagem total de bytes de todos os 500 programas juntos. (Ele também gera um erro, mas é apenas porque, posteriormente, tenta avaliar a Entrada como está.)

Carvão

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

Experimente online! Link é a versão detalhada do código. Explicação:

´⎚´§´⪪

Saída a string literal ⎚§⪪.

⪫ＩＡ 

Transmitir a matriz de entrada para string, juntar espaços e imprimir.

”y¦ Ｌυ⊞υω

Saída a string literal ¦ Ｌυ⊞υω.

Saída de, por exemplo, 5,17,7,13,2é ⎚§⪪5 17 7 13 2¦ Ｌυ⊞υω. Experimente online! Explicação:

⎚

Limpe a tela, para que apenas a última saída fique visível.

§⪪5 17 7 13 2¦ Ｌυ

Pegue o comprimento da lista predefinida u. Use isso para indexar na lista de números inteiros que foram divididos em espaços e gerar o elemento selecionado.

⊞υω

Envie uma variável dummy para a lista predefinida u, para que a próxima cópia produza o próximo elemento da lista.

Comprimento total da saída = (comprimento de todos os números inteiros em todas as listas) + (número de números inteiros em todas as listas) + (número de listas * 9) caracteres (SBCS).

Haskell , gera Haskell

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

Experimente online! Para o primeiro testcase, [5,2,7,3,2,3,15,10,7,2,14,11,16,16,3,3,4,3,8,4]ele produz o seguinte 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--

Tente uma vez , dobrou e caiu . Isso usa a mesma abordagem da minha resposta Haskell para eu dobrar a fonte, você dobrar a saída .

O comprimento de cada programa gerado é o comprimento da lista de entrada como sequência mais 25, portanto, a pontuação para os casos de teste atualmente disponíveis é 12266 + 500 * 25 = 24766. Isso mostra que a proporção de código para dados é basicamente igual e duvido que seja possível escrever um código de descompressão pequeno o suficiente que diminua a pontuação. Pode ser possível se as listas forem muito maiores.

Python 2 , gera Python 2

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

Experimente online!

Para a entrada

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

o programa gerado é

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 é 98 bytes.

Adaptado desta solução em "Eu dobro a fonte, você dobra a saída!".

Droga, duas respostas mais curtas apareceram antes de eu terminar de escrever esta resposta.

Java 8, gera 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())+"]#");}}

Experimente online.

Ou seja, [3,4,5,6,7]gera este programa Python 2:

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

Experimente online uma vez ; Experimente online duas vezes ; Experimente online três vezes .

O programa Python gerado é baseado na resposta do @ Mr.Xcoder pela terceira vez desafio de .

Explicação:

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 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, gera programas em Perl 5

O programa Bash pode ser chamado como script.sh 1,2,3 .

O programa Perl deve ser chamado com a -Ebandeira.

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

O perlcódigo gerado para uma entrada de 4,7,8é:

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

Força bruta. Remove um elemento da matriz ( perlnão importa que a matriz não exista inicialmente), define-o se ainda não estiver definido. Em seguida, ecoa o primeiro elemento da matriz no final. (O ENDbloco é executado por último). A exec 'true'sair do programa, de modo que quanto maisEND blocos não são executados.

Exemplo:

#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, gera C ++

Isso não vai bater nenhum recorde, eu estava interessado principalmente em pensar se poderia descobrir como fazê-lo :) Use o fato de que variáveis ​​globais são executadas antes do main e, portanto, pode incrementar uma variável global e, em seguida, usar um #ifdef para garantir que main seja definido apenas uma 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
""")

Encantos Rúnicos , gera Rúnico

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

Experimente online!

Recebe a entrada como uma lista de valores separada por espaço.

Saída realizada uma vez
Saída realizada duas vezes
Saída realizada quatro vezes

Utiliza o comando numérico contínuo do modo de leitura, ´que foi confirmado em 12 de janeiro e encontrei esta pergunta no dia 14. Este comando permite que valores arbitrários de comprimento possam ser codificados, pois sem esse recurso seria muito difícil fazê-lo (por exemplo 1392, precisaria ser representado como 1X3+X9+X2+, necessitando de um loop adicional no mínimo); precisamente o problema que eu queria resolver quando criei o´ comando.

No código original, o |nas cordas "{Zs$;|1|l;|y"e "UwR'10<|I+}"são substituídos com \n(que sentar-se na grade e não modificá-lo, como normalmente) com wcomandos rito: 74akw, 94/Rakw, c4akw, e 85akw. Os personagens originais podem ser literalmente qualquer coisa. |foi escolhido para ser um espaço reservado simbólico que representava visualmente o que eu queria. Vários bytes salvas (se os unscoring) por não ter que reflexivamente adicionar um ponto de entrada, como wR'10<escreve um Rem um local onde já existe (posição 0,1), e então começa a encher sua pilha de lixo antes de ficar sem mana, seguindo um looping seqüênciaU"'i34 .

O código de saída resultante funciona usando o wcomando rite para alterar o primeiro caractere na segunda linha para um Rredirecionamento direto (para que apenas um IP execute uma instrução de impressão), com uso inteligente do tamanho da pilha resultante de programas cada vez mais altos para determinar qual índice ler. Todos os outros IP alteram o mesmo local para a mesma instrução e terminam. Tudo o resto não é utilizado.

_{A imagem está desatualizada, mas suficiente para explicação do fluxo.}

Cada execução de 1Iymantém a capacidade do IP de lidar com uma pilha cada vez maior (causada pelo lcomando), cujo tamanho permite ao programa determinar quantas cópias do código-fonte base existem. A final 1é usada para incrementar o número anterior lao número necessário ao girar a pilha (criada a seguir) para chegar ao valor correto. oZ comando nega esse valor para que a pilha gire na direção correta.

A matriz de entrada original é então codificada usando o modo de leitura contínua, com um 0 para evitar a modificação incremental do mesmo valor, para ler as entradas originais. O NOP de espaço é necessário para sair do modo de leitura contínua e permitir que o 0 subseqüente inicie a pilha novamente.

A pontuação deve ser aproximadamente igual 3+v.toString().length, para cada entrada da matriz v, +23para cada matriz. Aproximadamente (2.55*total length of input)ou33837 para a amostra de entrada, se eu fiz as coisas certas.

Pequenas alterações foram introduzidas no meu programa final esperado devido aos efeitos colaterais introduzidos na mesma compilação em relação ao scomando, no entanto, resultou em uma melhor pontuação ao mesmo tempo.