Используя массив положительных целых чисел Aв качестве входных данных, сгенерируйте программу, которая при повторении для kвремен выводит kth (1-index) значение массива.

Например, если это массив [1,11], выводом должна быть программа, которая выводит 1, а при повторении дважды выводит 11. Код, как print(end="1");в Python 3 работает: print(end="1");печатает 1 и print(end="1");print(end="1");печатает 11

Наименьшая сумма длин кода для решения всех тестовых случаев побеждает. Ваш метакод должен решить 500 тестовых случаев за 60 с, а каждый код вашего решения должен вернуться за 10 с. Мета-код и код решения не обязательно должны быть на одном языке, но все решения, которые генерирует ваша метапрограмма, должны быть на одном языке.

Предварительные данные и генератор можно посмотреть здесь . Через 7 дней будет использоваться сумма времени представления (например, 12:34 означает 1234), чтобы быть случайным начальным числом и генерировать другой тестовый пример в качестве окончательного тестового примера.

Конечное начальное число равно 7335 по Гринвичу + 8, поэтому окончательные данные испытаний находятся здесь.

Python 3 , генерирует Stax

Это использует множество стратегий. Большинство стратегий применяются только при определенных условиях, но есть одна резервная стратегия, которую всегда можно использовать. В конце выбирается самая маленькая программа-кандидат.

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)

Попробуйте онлайн!

Обновление: проверка. Выполнение каждой множественности каждой программы будет занимать много времени. Можно запустить их все одновременно. Для этого необходимо использовать небольшой фрагмент кода. Он отвечает за несколько вещей.

1. Неявный вывод, если есть. Обычно в конце программы stax печатается вершина стека, если не было других выходных данных. При запуске нескольких программ в одном исходном файле это должно быть сделано явно.

2. Очистите оба стека.

3. Сброс регистров. Для этих программ используется только регистр x.

Этот шаблон должен применяться после каждой отдельной программы, которая будет выполнена.

|d{P}{zP}?0XLd

Например, ввод [5,2,7,3]производит программу Stax 3527E|X@. Все четыре кратности могут быть проверены одновременно.

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

Попробуйте онлайн!

Таким образом, можно протестировать все кратности всех программ за один прогон, предполагая, что ничего не нарушается. Вероятно, это будет самая большая программа из когда-либо выполненных, если все 500 будут выполнены.

Perl 5 -p , генерирует Perl 5 -p , накладные расходы 19 17 13

-1 благодаря @Dom Hastings

Счет за один вход будет length of the input + 13. Очевидно, что это можно улучшить, генерируя программы самораспаковки для больших входов, но я не буду беспокоиться.

Укажите входной массив, разделенный запятыми в одной строке на STDIN.

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

Попробуйте онлайн!

Запускать конкатенацию результатов nбез ввода (например, перенаправление из / dev / null)

Пример способа запустить его для ввода, 2,6,4,7и полученная программа повторяется 4 раза:

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

Попробуйте онлайн!

Если вам не нравится результирующая программа, пытающаяся читать из STDIN, используйте эту версию с накладными расходами 17:

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

Попробуйте онлайн!

Пример способа запустить его для ввода, 2,6,4,7и полученная программа повторяется 4 раза:

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

Попробуйте онлайн!

Эта версия вылетает после печати требуемого вывода

05AB1E , генерирует 05AB1E

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

Попробуйте онлайн!

Сгенерированная программа для ввода [5,17,7,13,2]есть "5 17 7 13 2"#.g<è.

Тестовый набор для [5,17,7,13,2]

Длина сгенерированной программы len(input) + 5

APL (Dyalog Unicode)

Анонимный префикс лямбда. Возвращает тело программы.

 {
     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
 }

Попробуйте онлайн!

методы

Это исследует различные методы и возвращает первый пригодный для использования, в конечном счете возвращаясь к универсально применимому методу.

Один элемент

Если список имеет только один элемент, он возвращается как есть.

2, 22 и т. Д.

Одну цифру можно просто повторить, чтобы получить число в 11 раз больше,

Все так же

Мы просто возвращаем самый правый ( ⊢) номер.

линейный

f (n) = k × n последовательностей просто вставьте плюс перед первым членом.

Факториал, за которым следуют все 1

Когда первое число n =! M и последующие числа равны 1, тогда !mэто решение, потому что !mравно n, m!mравно 1 и !1равно 1.

б аб аб аб

Поскольку все двузначные числа больше, чем все однозначные числа, рабочий максимум, где передняя часть первого числа приклеена к задней части второго числа, является решением.

Трехстрочный код

Проверьте, является ли любая формула типа +a×bдействительной.

Строка запасной

Длинные последовательности без чисел ниже 5 (потому что 4 - это разрыв строки) могут быть закодированы как символы SBCS.

Отступ смещения строки

Если число меньше 5, мы сдвигаемся на 9, чтобы избежать этого.

Отступать

Простая конкатенация строк "{⍺←⊃⋄1⌽⍺⊢⍵}"и ⍕ввода stringified ( ). Например, [3,1,4]возвращает тело программы {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4.

Часть в фигурных скобках является амбивалентной функцией, что означает, что она может быть префиксной или инфиксной функцией. Таким образом, самый левый экземпляр будет работать в режиме префикса, а все остальные в режиме инфикса. Разница между режимами заключается в том ⍺, имеет ли значение , обозначающее левый аргумент, значение. Если этого не произойдет, ему будет назначена функция ⊃(первая).

Объяснение резервного метода

{… } Анонимная лямбда:

 ⍺←⊃ Если левого аргумента нет ( ⍺), присвойте функцию ⊃(первую)⍺

 ⋄ тогда:

На этом этапе следующий код означает две разные вещи в зависимости от того, ⍺является ли список чисел (вызов инфикса) или функцией «first» (вызов префикса).

 Если ⍺это список номеров:

  ⍺⊢⍵ отбросить левый аргумент в пользу правого аргумента

  1⌽ поверните этот шаг влево

 Если ⍺функция «первая»:

  ⊢⍵ привести правильный аргумент

  ⍺ выбрать первый элемент этого

  1⌽ поверните его на один шаг (нет на скаляре)

Пример выполнения резервного метода

Выполняя 3 1 4код, {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4назначает «первую» функцию ⍺и, таким образом, возвращает первый элемент; 3,

Выполнение {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4позволяет самой правой лямбде «захватывать» левый 3 1 4как свой левый аргумент, поэтому ⍺имеет значение, которое отбрасывается, в пользу 3 1 4которого затем поворачивается на один шаг влево и выдает 1 4 3результат. Затем он используется в качестве единственного аргумента для самой левой лямбды, где ⍺становится «первой» функцией, в результате чего результат становится первым элементом; 1,

Выполнение {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4позволяет самой правой лямбде «захватить» середину в 3 1 4качестве левого аргумента, который затем отбрасывается в пользу правого аргумента 3 1 4, который при повороте на один шаг влево равен 1 4 3. Затем он используется в качестве правого аргумента средней лямбды, а левый - в 3 1 4качестве левого аргумента. Левый аргумент отбрасывается для правого, который поворачивался на один шаг влево 4 3 1. Затем это становится единственным аргументом самой левой лямбды, поэтому ⍺становится «первой функцией», возвращающей первый элемент; 4,

счет

Когда наступит время для тестирования с использованием фактических данных, используйте этот тестовый комплект (связанный с данными предварительного тестирования ). Контрольные примеры помещаются в поле ввода, и выводом будет общее количество байтов всех 500 программ вместе. (Он также выдаст ошибку, но это только потому, что впоследствии он пытается оценить входные данные как есть.)

Уголь

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

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

´⎚´§´⪪

Выведите буквальную строку ⎚§⪪.

⪫ＩＡ 

Приведите входной массив к строке, объедините с пробелами и напечатайте.

”y¦ Ｌυ⊞υω

Выведите буквальную строку ¦ Ｌυ⊞υω.

Вывод например 5,17,7,13,2есть ⎚§⪪5 17 7 13 2¦ Ｌυ⊞υω. Попробуйте онлайн! Объяснение:

⎚

Очистите холст, чтобы был виден только последний вывод.

§⪪5 17 7 13 2¦ Ｌυ

Возьмите длину предопределенного списка u. Используйте это, чтобы индексировать в список целых чисел, которые были разделены на пробелы, и выводить выбранный элемент.

⊞υω

Переместите фиктивную переменную в предварительно определенный список u, чтобы следующая копия выводила следующий элемент списка.

Общая длина вывода = (длина всех целых чисел во всех списках) + (количество целых чисел во всех списках) + (количество списков * 9) символов (SBCS).

Haskell , генерирует Haskell

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

Попробуйте онлайн! Для первого теста [5,2,7,3,2,3,15,10,7,2,14,11,16,16,3,3,4,3,8,4]он выдает следующую программу:

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

Попробуйте один раз , удвоить и утроить . Это использует тот же подход, что и мой ответ на Haskell: я удваиваю источник, а ты удваиваешь вывод .

Длина каждой сгенерированной программы равна длине входного списка в виде строки плюс 25, таким образом, оценка для доступных на данный момент тестовых случаев равна 12266 + 500 * 25 = 24766. Это показывает, что отношение кода к данным в основном одинаково, и я сомневаюсь, что возможно написать достаточно маленький код распаковки, который уменьшит оценку. Это может быть возможно, если списки куда больше.

Python 2 , генерирует Python 2

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

Попробуйте онлайн!

Для ввода

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

сгенерированная программа

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]#

что составляет 98 байт.

Адаптировано из этого решения в «Я удваиваю источник, вы удваивает вывод!».

Черт возьми, два коротких ответа появились прежде, чем я закончил писать этот ответ.

Java 8, генерирует 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())+"]#");}}

Попробуйте онлайн.

Т.е. [3,4,5,6,7]генерирует эту программу на Python 2:

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

Попробуйте онлайн один раз ; Попробуйте онлайн дважды ; Попробуйте онлайн три раза .

Сгенерированная программа на Python основана на ответе @ Mr.Xcoder в третий раз за вызов очарования .

Объяснение:

Код 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 "]#"

Код 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, вывод программ на Perl 5

Программу Bash можно назвать как script.sh 1,2,3.

Perl-программа должна вызываться с -Eфлагом.

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

Сгенерированный perlкод для ввода 4,7,8:

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

Довольно грубая сила. Удаляет элемент массива ( perlне заботится о том, что массив сначала не существует), устанавливает его, если он еще не установлен. Затем он повторяет первый элемент массива в конце. ( ENDБлок запускается последним). Выход exec 'true'из программы, так что дальнейшие ENDблоки не выполняются.

Пример:

#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, генерирует C ++

Это не побьет никаких рекордов, мне было интересно подумать, смогу ли я выяснить, как это сделать :). Используйте тот факт, что глобальные переменные запускаются перед main, и поэтому можете увеличивать глобальную переменную, затем используя #ifdef, чтобы убедиться, что main определяется только один раз.

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
""")

Рунические чары , порождающие руны

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

Попробуйте онлайн!

Принимает ввод как разделенный пробелами список значений.

Вывод выполнен один раз
Вывод выполнен дважды
Вывод выполнен четыре раза

Использует команду непрерывного числового режима чтения, ´которая была зафиксирована 12 января, а я нашел этот вопрос 14-го. Эта команда позволяет кодировать произвольные значения длины, так как без этой функции это было бы очень трудно сделать (например, 1392ее нужно было бы представить как 1X3+X9+X2+, требуя как минимум дополнительного цикла); именно ту проблему, которую я хотел решить, когда создал ´команду.

В исходном коде, |в строках "{Zs$;|1|l;|y"и "UwR'10<|I+}"заменяются \n(которые сидят в сетке , а не изменять его, так как они обычно было бы) с wобрядовыми командами: 74akw, 94/Rakw, c4akw, и 85akw. Оригинальные персонажи могут быть буквально чем угодно. |был выбран в качестве символического заполнителя, который визуально представлял то, что я хотел. Несколько байтов сохранены (если не отмечены единицы) благодаря тому, что нет необходимости рефлексивно добавлять точку входа, так как wR'10<записывает Rв место, где он уже существует (позиция 0,1), а затем приступает к заполнению своего стека мусором до исчерпания маны, после зацикливания последовательность U"'i34.

Полученный в результате выходной код работает с помощью команды write, чтобы изменить первый символ во второй строке на Rперенаправление «влево» (так что только один IP-адрес выполняет оператор печати), с умным использованием длины стека, получаемой из более высоких и более высоких программ, чтобы определить, какой индекс читать. Каждый другой IP-адрес изменяет это же местоположение на ту же инструкцию и завершается. Все остальное не используется.

_{Изображение устарело, но достаточно для объяснения потока.}

Каждое выполнение 1Iyподдерживает способность IP обрабатывать все больший и больший стек (вызванный lкомандой), размер которого позволяет программе определить, сколько существует копий базового исходного кода. Финал 1используется для увеличения предыдущего числа lдо требуемого числа при вращении стека (созданного следующим образом), чтобы получить правильное значение. Команда Zотменяет это значение, так что стек вращается в правильном направлении.

Затем исходный входной массив кодируется с использованием режима непрерывного чтения, заполненного 0, чтобы избежать постепенного изменения того же значения, чтобы прочитать исходные входные данные. Пробел NOP необходим, чтобы выйти из режима непрерывного чтения и позволить последующим 0 снова заполнить стек.

Оценка должна быть приблизительно равна 3+v.toString().lengthдля каждой записи массива v, +23для каждого массива. Приблизительно (2.55*total length of input)или 33837для образца ввода, если я все сделал правильно.

Незначительные изменения были внесены в мою ожидаемую окончательную программу из-за побочных эффектов, введенных в той же сборке относительно sкоманды, однако это привело к лучшему результату в то же время.