Diberikan array bilangan bulat positif Asebagai input, hasilkan program yang, ketika diulangi berkali- kkali, menampilkan nilai kth (1-indeks) dari array.

Misalnya, jika arraynya [1,11], output harus berupa program yang mengeluarkan 1, dan ketika diulang dua kali, keluaran 11. Kode seperti print(end="1");di Python 3 berfungsi: print(end="1");mencetak 1 dan print(end="1");print(end="1");mencetak 11

Jumlah panjang kode terkecil untuk menyelesaikan semua kasus uji, menang. Kode meta Anda harus menyelesaikan 500 kasus uji dalam 60-an, dan masing-masing kode solusi Anda harus kembali dalam 10-an. Kode meta dan kode solusi tidak harus dalam bahasa yang sama, tetapi semua solusi yang dihasilkan oleh program meta Anda harus dalam bahasa yang sama.

Data pretest dan generator dapat dilihat di sini . 7 hari kemudian akan menggunakan jumlah waktu pengajuan (mis. 12:34 berarti 1234) untuk menjadi benih acak dan menghasilkan kasus uji lain sebagai kasus uji akhir.

Unggulan terakhir adalah 7335 dalam GMT + 8, jadi data tes akhir ada di sini

Python 3 , menghasilkan Stax

Ini menggunakan berbagai strategi. Sebagian besar strategi hanya berlaku dalam kondisi tertentu, tetapi ada satu strategi mundur yang selalu dapat digunakan. Pada akhirnya, program kandidat terkecil dipilih.

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)

Cobalah online!

Pembaruan: Validasi Akan memakan waktu lama untuk menjalankan setiap multiplisitas dari setiap program secara terpisah. Dimungkinkan untuk menjalankan semuanya sekaligus. Untuk melakukan ini, sepotong kecil kode harus digunakan. Bertanggung jawab atas beberapa hal.

1. Lakukan output implisit jika ada. Biasanya, pada akhir program diam, bagian atas tumpukan dicetak jika belum ada output lain. Saat menjalankan beberapa program dalam file sumber yang sama, ini harus dilakukan secara eksplisit.

2. Bersihkan kedua tumpukan.

3. Setel ulang register. Untuk program-program ini hanya x register yang digunakan.

Pelat ini harus diterapkan setelah setiap program dijalankan.

|d{P}{zP}?0XLd

Misalnya, input [5,2,7,3]menghasilkan program stax 3527E|X@. Keempat multiplisitas dapat diuji sekaligus.

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

Cobalah online!

Dengan cara ini, dimungkinkan untuk menguji semua multiplisitas semua program dalam menjalankan yang sama, dengan asumsi tidak ada yang rusak. Ini mungkin akan menjadi program stax terbesar yang pernah dijalankan jika semua 500 dilakukan.

Perl 5 -p , menghasilkan Perl 5 -p , overhead 19 17 13

-1 terima kasih kepada @Dom Hastings

Skor untuk satu input adalah length of the input + 13. Jelas dapat ditingkatkan dengan menghasilkan program self-decompressing untuk input yang lebih besar, tetapi saya tidak akan repot.

Berikan array input dipisahkan dengan koma pada satu baris di STDIN.

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

Cobalah online!

Jalankan output concatenated ntimes tanpa input (mis. Redirect from / dev / null)

Contoh cara menjalankannya untuk input 2,6,4,7dan program yang dihasilkan diulang 4 kali:

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

Cobalah online!

Jika Anda tidak suka program yang dihasilkan mencoba membaca dari STDIN gunakan versi ini dengan overhead 17:

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

Cobalah online!

Contoh cara menjalankannya untuk input 2,6,4,7dan program yang dihasilkan diulang 4 kali:

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

Cobalah online!

Versi ini macet setelah mencetak output yang diperlukan

05AB1E , menghasilkan 05AB1E

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

Cobalah online!

Program yang dihasilkan untuk input [5,17,7,13,2]adalah "5 17 7 13 2"#.g<è.

Test suite untuk [5,17,7,13,2]

Panjang program yang dihasilkan adalah len(input) + 5

APL (Dyalog Unicode)

Lambda awalan anonim. Mengembalikan badan program.

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

Cobalah online!

Metode

Ini mengeksplorasi berbagai metode dan mengembalikan yang dapat digunakan pertama, akhirnya jatuh kembali ke metode yang berlaku secara universal.

Elemen tunggal

Jika daftar hanya memiliki satu elemen, itu dikembalikan apa adanya.

2, 22 dll.

Satu digit bisa diulang untuk menghasilkan angka 11 kali lebih besar,

Semua sama

Kami baru saja mengembalikan nomor ( ⊢) paling kanan .

Linier

f (n) = k × n urutan cukup masukkan nilai plus sebelum istilah pertama.

Faktorial diikuti oleh semua 1s

Ketika angka pertama n =! M dan angka selanjutnya adalah 1, maka !mmerupakan solusi karena !mn dan m!m1 dan !11.

b ab ab ab

Karena semua angka dua digit lebih besar dari semua angka satu digit, maksimum berjalan, di mana bagian depan angka pertama terpaku di belakang angka kedua, adalah solusi.

Kode tiga baris

Periksa apakah rumus jenis apa +a×bpun valid.

String fallback

Urutan panjang tanpa nomor di bawah 5 (karena 4 adalah jeda baris) dapat dikodekan sebagai karakter SBCS.

Fallback string offset

Jika ada angka di bawah 5, kami bergeser ke atas 9 untuk menghindarinya.

Fallback

Rangkaian string sederhana dari string "{⍺←⊃⋄1⌽⍺⊢⍵}"dan ⍕input stringified ( ). Misalnya [3,1,4]mengembalikan badan program {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4.

Bagian dalam kawat gigi adalah fungsi ambivalen yang artinya dapat berupa fungsi awalan atau fungsi infiks. Jadi instance paling kiri dari itu akan berjalan dalam mode awalan, dan semua yang lain dalam mode infix. Perbedaan antara mode adalah apakah ⍺, menandakan argumen kiri, memiliki nilai. Jika tidak maka akan diberikan fungsi ⊃(pertama).

Penjelasan metode mundur

{… } Lambda anonim:

 ⍺←⊃ Jika tidak ada argumen kiri ( ⍺) tetapkan fungsi ⊃(pertama) ke⍺

 ⋄ kemudian:

Pada titik ini, kode berikut ini berarti dua hal yang berbeda tergantung pada apakah ⍺daftar angka (panggilan infiks) atau fungsi "pertama" (panggilan awalan).

 Jika ⍺daftar angka:

  ⍺⊢⍵ buang argumen kiri demi argumen yang benar

  1⌽ putar satu langkah ke kiri

 Jika ⍺fungsi "pertama":

  ⊢⍵ menghasilkan argumen yang benar

  ⍺ pilih elemen pertama itu

  1⌽ putar satu langkah (no-op pada skalar)

Contoh menjalankan metode fallback

3 1 4Kode pelaksana {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4,, menetapkan fungsi "pertama" ke ⍺dan dengan demikian mengembalikan elemen pertama; 3.

Menjalankan {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4memungkinkan lambda paling kanan "menangkap" kiri 3 1 4sebagai argumen kiri, sehingga ⍺memiliki nilai yang dibuang 3 1 4yang kemudian diputar satu langkah ke kiri dan menghasilkan 1 4 3sebagai hasilnya. Ini kemudian digunakan sebagai satu-satunya argumen ke lambda paling kiri, di mana ⍺menjadi fungsi "pertama", menyebabkan hasilnya menjadi elemen pertama; 1.

Menjalankan {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4memungkinkan lambda paling kanan "menangkap" tengah 3 1 4sebagai argumen kiri yang kemudian dibuang demi argumen kanan 3 1 4,, yang ketika diputar satu langkah ke kiri adalah 1 4 3. Ini kemudian digunakan sebagai argumen kanan lambda tengah bersama-sama dengan yang paling kiri 3 1 4sebagai argumen kiri. Argumen kiri dibuang ke kanan, yang dirotasi menghasilkan satu langkah kiri 4 3 1. Ini kemudian menjadi satu-satunya argumen lambda paling kiri, sehingga ⍺menjadi "fungsi pertama", mengembalikan elemen pertama; 4.

Mencetak gol

Ketika saatnya untuk menguji menggunakan data aktual, gunakan harness tes ini (ditautkan diisi dengan data pretest). Kasing uji masuk dalam kolom Input, dan Output akan menjadi jumlah byte total dari semua 500 program secara bersamaan. (Ini juga akan menimbulkan kesalahan, tapi itu hanya karena setelah itu mencoba untuk mengevaluasi Input apa adanya.)

Arang

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

´⎚´§´⪪

Keluarkan string literal ⎚§⪪.

⪫ＩＡ 

Keluarkan array input ke string, bergabung dengan spasi, dan cetak.

”y¦ Ｌυ⊞υω

Keluarkan string literal ¦ Ｌυ⊞υω.

Output dari contohnya 5,17,7,13,2adalah ⎚§⪪5 17 7 13 2¦ Ｌυ⊞υω. Cobalah online! Penjelasan:

⎚

Kosongkan kanvas, sehingga hanya output terakhir yang terlihat.

§⪪5 17 7 13 2¦ Ｌυ

Ambil panjang daftar yang telah ditentukan u. Gunakan itu untuk mengindeks ke dalam daftar bilangan bulat yang telah dipisah pada spasi dan output elemen yang dipilih.

⊞υω

Dorong variabel dummy ke daftar yang telah ditentukan u, sehingga salinan berikutnya akan menampilkan elemen berikutnya dari daftar.

Total panjang output = (panjang semua bilangan bulat di semua daftar) + (jumlah bilangan bulat di semua daftar) + (jumlah daftar * 9) karakter (SBCS).

Haskell , menghasilkan Haskell

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

Cobalah online! Untuk testcase pertama [5,2,7,3,2,3,15,10,7,2,14,11,16,16,3,3,4,3,8,4]menghasilkan program berikut:

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

Coba sekali , dua kali lipat dan tiga kali lipat . Ini menggunakan pendekatan yang sama dengan jawaban Haskell saya untuk saya gandakan sumbernya, Anda gandakan hasilnya .

Panjang setiap program yang dihasilkan adalah panjang daftar input sebagai string ditambah 25, sehingga skor untuk testcases yang tersedia saat ini adalah 12266 + 500 * 25 = 24766. Ini menunjukkan bahwa rasio kode terhadap data pada dasarnya sama, dan saya ragu mungkin untuk menulis kode dekompresi yang cukup kecil yang akan menurunkan skor. Mungkin saja daftar di mana jauh lebih besar.

Python 2 , menghasilkan Python 2

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

Cobalah online!

Untuk input

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

program yang dihasilkan adalah

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

yaitu 98 byte.

Diadaptasi dari solusi ini di "Saya gandakan sumbernya, Anda gandakan hasilnya!".

Sialan, dua jawaban pendek muncul sebelum saya selesai menulis jawaban ini.

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

Cobalah online.

Yaitu [3,4,5,6,7]menghasilkan program Python 2 ini:

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

Coba online sekali ; Cobalah online dua kali ; Cobalah secara online tiga kali .

Program Python yang dihasilkan didasarkan pada jawaban @ Mr.Xcoder untuk ketiga kalinya tantangan pesona .

Penjelasan:

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

Kode 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, menampilkan program di Perl 5

Program Bash bisa disebut seperti script.sh 1,2,3.

Program Perl harus dipanggil dengan -Eflag.

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

perlKode yang dihasilkan untuk input 4,7,8adalah:

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

Kekuatan yang cukup kasar. Menghapus elemen array ( perltidak peduli bahwa array tidak ada pada awalnya), atur jika belum ditetapkan. Kemudian gema elemen pertama array di akhir. ( ENDBlok dijalankan terakhir). The exec 'true'berhenti program, sehingga lebih ENDblok tidak dieksekusi.

Contoh:

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

Ini tidak akan mengalahkan rekor apa pun, saya terutama tertarik untuk memikirkan apakah saya bisa mengetahui cara melakukannya :) Gunakan fakta bahwa variabel global dijalankan sebelum utama, dan dengan demikian dapat meningkatkan variabel global, kemudian menggunakan #ifdef untuk memastikan main hanya didefinisikan satu kali.

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

Pesona Runic , menghasilkan Runic

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

Cobalah online!

Mengambil input sebagai daftar nilai yang dipisahkan ruang.

Keluaran dilakukan satu kali
Output dilakukan dua kali
Output dilakukan empat kali

Menggunakan perintah mode baca numerik kontinu, ´yang dilakukan pada 12 Januari dan saya menemukan pertanyaan ini pada tanggal 14. Perintah ini memungkinkan nilai panjang sewenang-wenang dapat dikodekan karena tanpa fitur ini akan sangat sulit untuk melakukannya (misalnya 1392perlu direpresentasikan sebagai 1X3+X9+X2+, memerlukan loop tambahan minimal); tepatnya masalah yang ingin saya pecahkan ketika saya membuat ´perintah.

Dalam kode asli, |di string "{Zs$;|1|l;|y"dan "UwR'10<|I+}"diganti dengan \n(yang duduk di grid dan tidak memodifikasi, karena mereka biasanya akan) dengan wperintah ritual: 74akw, 94/Rakw, c4akw, dan 85akw. Karakter asli dapat berupa apa saja. |terpilih menjadi penampung simbolik yang secara visual mewakili apa yang saya inginkan. Beberapa byte disimpan (jika yang tidak disimpan) dengan tidak harus secara reflektif menambahkan titik masuk, seperti wR'10<menulis sebuah Rke lokasi di mana seseorang sudah ada (posisi 0,1), dan kemudian mulai mengisi tumpukannya dengan sampah sebelum kehabisan mana, mengikuti pengulangan urut U"'i34.

Kode output yang dihasilkan bekerja dengan menggunakan wperintah ritus untuk mengubah karakter pertama pada baris kedua menjadi Rredirection yang tinggi (sehingga hanya satu IP yang menjalankan pernyataan cetak), dengan penggunaan ceroboh dari panjang tumpukan yang dihasilkan dari program yang lebih tinggi dan lebih tinggi untuk menentukan indeks mana untuk membaca. Setiap IP lain mengubah lokasi yang sama ke instruksi yang sama dan berakhir. Segala sesuatu yang lain tidak digunakan.

_{Gambar kedaluwarsa, tetapi cukup untuk penjelasan aliran.}

Setiap pelaksanaan 1Iymempertahankan kemampuan IP untuk menangani tumpukan yang lebih besar dan lebih besar (disebabkan oleh lperintah), yang ukurannya memungkinkan program untuk menentukan berapa banyak salinan kode sumber dasar yang ada. Final 1digunakan untuk menambah yang sebelumnya lke nomor yang diperlukan ketika memutar tumpukan (dibuat berikutnya) untuk sampai pada nilai yang benar. The Zperintah meniadakan nilai ini sehingga berputar stack dalam arah yang benar.

Array input asli kemudian disandikan menggunakan mode baca kontinu, prima dengan 0 untuk menghindari secara bertahap mengubah nilai yang sama, untuk membaca input asli. Ruang NOP diperlukan untuk keluar dari mode baca kontinu dan memungkinkan 0 berikutnya untuk menumpuk tumpukan lagi.

Skor harus sama kira-kira 3+v.toString().length, untuk setiap entri array v, +23untuk setiap array. Kira (2.55*total length of input)- kira atau 33837untuk input sampel, jika saya melakukan hal yang benar.

Perubahan kecil dimasukkan ke dalam program akhir yang saya harapkan karena efek samping yang diperkenalkan pada build yang sama mengenai sperintah, namun hasilnya menghasilkan skor yang lebih baik pada saat yang sama.