Pozitif tam bir dizi göz önüne alındığında A, bir girdi olarak programı oluşturmak olduğu için, tekrarlanan kzaman, çıkış kdizisinin th (1-endeksi) değerinin.

Örneğin, dizi ise [1,11]çıktı, çıktıyı 1ve iki kez tekrarlandığında çıktıyı çıkaran bir program olmalıdır 11. print(end="1");Python 3'teki gibi kod çalışır: print(end="1");1 print(end="1");print(end="1");yazdırır ve 11 yazdırır

Tüm test senaryolarını çözmek için kod uzunluklarının en küçük toplamı kazanın. Meta kodunuz 60'larda 500 test vakasını çözmeli ve çözüm kodlarınızın her biri 10'larda dönmelidir. Meta kod ve çözüm kodunun aynı dilde olması gerekmez, ancak meta programınızın oluşturduğu tüm çözümlerin aynı dilde olması gerekir.

Ön test verileri ve jeneratör burada görülebilir . 7 gün sonra teslim süresi toplamını (örneğin 12:34 ortalama 1234) rastgele tohum olarak kullanacak ve son test durumu olarak başka bir test durumu oluşturacaktır.

Son tohum GMT + 8'de 7335'tir, bu yüzden son test verileri burada

Python 3 , Stax üretir

Bu çeşitli stratejiler kullanır. Çoğu strateji yalnızca belirli koşullar altında geçerlidir, ancak her zaman kullanılabilir olan bir yedek strateji vardır. Sonunda, en küçük aday programı seçilir.

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)

Çevrimiçi deneyin!

Güncelleme: Doğrulama Her bir programın her bir çokluğunu ayrı ayrı yürütmek zaman alacaktır. Hepsini aynı anda çalıştırmak mümkündür. Bunu yapmak için küçük bir kod parçası kullanılmalıdır. Birkaç şeyden sorumlu.

1. Varsa örtük çıktı yapın. Normalde, bir stax programının sonunda, başka bir çıktı yoksa yığının üstü yazdırılır. Aynı kaynak dosyada birden fazla program çalıştırırken, bunun açıkça yapılması gerekir.

2. Her iki yığını da temizleyin.

3. Kayıtları sıfırla. Bu programlar için sadece x kaydı kullanılır.

Bu kazan plakası, yürütülecek her programdan sonra uygulanmalıdır.

|d{P}{zP}?0XLd

Örneğin, girdi [5,2,7,3]stax programını üretir 3527E|X@. Dört çokluğun hepsi aynı anda test edilebilir.

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

Çevrimiçi deneyin!

Bu şekilde, hiçbir programın bozulmadığı varsayılarak, tüm programın tüm çokluklarını aynı çalışmada test etmek mümkündür. 500'ün tamamı yapılırsa, muhtemelen yürütülen en büyük stax programı olacaktır.

Perl 5 -p üretir Perl 5 -p üstten, 19 17 13

@Dom Hastings sayesinde -1

Bir girişin puanı olacaktır length of the input + 13. Açıkçası daha büyük girdiler için kendi kendine açma programları oluşturarak geliştirilebilir, ama rahatsız etmeyeceğim.

STDIN üzerinde bir satırda virgülle ayrılmış giriş dizisini verin.

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

Çevrimiçi deneyin!

Çıktı birleştirilmiş nsürelerini girdi olmadan çalıştırın (örn. / Dev / null yönlendirme)

Giriş için çalıştırmanın örnek yolu 2,6,4,7ve ortaya çıkan program 4 kez tekrarlandı:

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

Çevrimiçi deneyin!

Ortaya çıkan programın STDIN'den okumaya çalışmasını sevmiyorsanız, bu sürümü ek yük 17 ile kullanın:

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

Çevrimiçi deneyin!

Giriş için çalıştırmanın örnek yolu 2,6,4,7ve ortaya çıkan program 4 kez tekrarlandı:

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

Çevrimiçi deneyin!

Bu sürüm, gerekli çıktıyı yazdırdıktan sonra çöküyor

05AB1E , 05AB1E üretir

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

Çevrimiçi deneyin!

Girişi için oluşturulan program [5,17,7,13,2]olup "5 17 7 13 2"#.g<è.

Test paketi [5,17,7,13,2]

Oluşturulan programın uzunluğu len(input) + 5

APL (Dyalog Unicode)

Anonim önek lambda. Bir program gövdesini döndürür.

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

Çevrimiçi deneyin!

Yöntemler

Bu, çeşitli yöntemleri araştırır ve ilk olarak kullanılabilir olanı döndürür, sonunda evrensel olarak uygulanabilir bir yönteme geri döner.

Tek eleman

Listede yalnızca bir öğe varsa, olduğu gibi döndürülür.

2, 22 vb.

Tek bir rakam sadece 11 kat daha büyük sayı üretmek için tekrarlanabilir,

Hepsi aynı

Sadece en sağdaki ( ⊢) sayıyı döndürüyoruz .

Doğrusal

f (n) = k × n dizileri sadece ilk terimden önce bir artı ekler.

Faktöriyel ve ardından tüm 1'ler

İlk sayı n =! M ve sonraki sayılar 1 !molduğunda !m, n ve m!m1 olduğu ve 1 olduğu için bir çözüm !1olur.

b ab ab ab

Tüm iki basamaklı sayılar tüm tek basamaklı sayılardan daha büyük olduğu için, ilk sayının ön kısmının ikinci sayının arkasına yapıştırıldığı bir çalışma maksimum değeri bir çözümdür.

Üç satırlı kod

Türün herhangi bir formülünün +a×bgeçerli olup olmadığını kontrol edin .

Dize yedeklemesi

5'in altında sayı içermeyen uzun diziler (4 satır sonu olduğu için) SBCS'nin karakterleri olarak kodlanabilir.

Ofset dizesi yedeklemesi

5'in altında rakamlar varsa, bunlardan kaçınmak için 9 yukarı kaydırıyoruz.

Geri çekil

Dizenin "{⍺←⊃⋄1⌽⍺⊢⍵}"ve stringified ( ⍕) girişinin basit dize birleştirmesi . Ör [3,1,4]. Program gövdesini döndürür {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4.

Parantez içindeki parça iki yönlü bir işlevdir, yani bir önek işlevi veya bir infix işlevi olabilir. Böylece en soldaki örneği önek modunda, diğerleri ise infix modunda çalışır. Modlar arasındaki fark ⍺, sol argümanı ifade eden bir değerin olup olmadığıdır . Eğer değilse, o zaman fonksiyona atanır ⊃(ilk olarak).

Yedekleme yönteminin açıklaması

{… } Anonim lambda:

 ⍺←⊃ Sol bağımsız değişken ( ⍺) yoksa, ⊃(ilk) işlevini⍺

 ⋄ sonra:

Bu noktada, aşağıdaki kod ⍺, bir sayı listesi (infix çağrısı) veya "ilk" (önek çağrısı) işlevine bağlı olarak iki farklı anlama gelir .

 Bir ⍺sayı listesi:

  ⍺⊢⍵ sol argümanı doğru argüman lehine at

  1⌽ bir adım sola döndür

 Eğer ⍺"önce" fonksiyonudur:

  ⊢⍵ doğru argümanı ver

  ⍺ bunun ilk unsurunu seç

  1⌽ bir adım döndür (skalerde işlem yok)

Yedek çalışma yöntemi örneği

Yürütülmesi 3 1 4'in kodunu {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4, 'ilk' fonksiyonunu tahsis ⍺ve böylece birinci elemanın döner; 3.

Yürütme {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4, en sağdaki lambda'nın 3 1 4sol argüman olarak solu "yakalamasına" izin verir , bu nedenle ⍺lehine atılan ve 3 1 4daha sonra bir adım sola döndürülen ve 1 4 3sonuç olarak elde edilen bir değere sahiptir . Bu daha sonra en soldaki lambda için tek argüman olarak kullanılır, burada ⍺"ilk" fonksiyon olur ve sonucun ilk unsur olmasına neden olur; 1.

Yürütme {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4, en sağdaki lambda'nın ortasını 3 1 4sol argümanı olarak "yakalamasına" izin verir ve daha sonra sağ argüman lehine atılır 3 1 4, bu da döndürüldüğünde bir adım sola döner 1 4 3. Bu daha sonra en soldaki 3 1 4sol argüman olarak orta lambda'nın sağ argümanı olarak kullanılır . Sol argüman, bir adım sola döndürülen sağ için atılır 4 3 1. Bu daha sonra en soldaki lambda'nın tek argümanı ⍺olur , böylece ilk elemanı döndüren "ilk fonksiyon" olur; 4.

puanlama

Gerçek verileri kullanarak test etme zamanı geldiğinde, bu test kayışını kullanın (ön test verileriyle doldurulmuş bağlantı). Test senaryoları Girdi alanına girer ve Çıktı birlikte 500 programın toplam bayt sayısı olacaktır. (Ayrıca bir hata atar, ancak bunun nedeni daha sonra Giriş'i olduğu gibi değerlendirmeye çalışmasıdır.)

Odun kömürü

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

´⎚´§´⪪

Değişmez dizeyi çıktılar ⎚§⪪.

⪫ＩＡ 

Giriş dizisini dizgiye dönüştür, boşluklarla birleştir ve yazdır.

”y¦ Ｌυ⊞υω

Değişmez dizeyi çıktılar ¦ Ｌυ⊞υω.

Örnek için çıkış 5,17,7,13,2olup ⎚§⪪5 17 7 13 2¦ Ｌυ⊞υω. Çevrimiçi deneyin! Açıklama:

⎚

Tuvali temizleyin, böylece yalnızca son çıktı görünür.

§⪪5 17 7 13 2¦ Ｌυ

Önceden tanımlanmış listenin uzunluğunu alın u. Boşluklara bölünmüş tamsayılar listesine dizinlemek ve seçilen öğeyi çıktılamak için bunu kullanın.

⊞υω

Bir usonraki kopyanın listenin bir sonraki elemanının çıkmasını sağlamak için, önceden tanımlanmış listeye sahte bir değişken itin .

Toplam çıktı uzunluğu = (tüm listelerdeki tamsayıların uzunluğu) + (tüm listelerdeki tamsayıların sayısı) + (liste sayısı * 9) karakterler (SBCS).

Haskell , Haskell'i üretir

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

Çevrimiçi deneyin! İlk testcase [5,2,7,3,2,3,15,10,7,2,14,11,16,16,3,3,4,3,8,4]için aşağıdaki programı üretir:

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

Bir kez deneyin , iki katına çıktı ve takıldı . Bu, Haskell kaynağımı iki katına çıkardığım cevabımla aynı yaklaşımı kullanıyor , çıktıyı iki katına çıkarıyorsunuz .

Oluşturulan her programın uzunluğu, giriş listesinin dize artı 25 uzunluğudur, bu nedenle şu anda mevcut test senaryolarının puanıdır 12266 + 500 * 25 = 24766. Bu kod veri oranı temelde eşit olduğunu gösterir ve ben şüphesiz puanı azaltacaktır yeterince küçük dekompresyon kodu yazmak mümkün. Listelerin çok daha büyük olduğu durumlarda mümkün olabilir.

Python 2 , Python 2'yi üretir

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

Çevrimiçi deneyin!

Giriş için

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

oluşturulan program

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 byte.

Bu özümden uyarlanarak "Kaynağı ikiye katladım, çıktıyı ikiye katladın!".

Lanet olsun, bu cevabı yazmayı bitirmeden önce iki kısa cevap geldi.

Java 8, Python 2'yi üretir

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

Çevrimiçi deneyin.

Yani [3,4,5,6,7]bu Python 2 programını oluşturur:

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

Bir kez çevrimiçi deneyin ; Çevrimiçi olarak iki kez deneyin ; Üç kez çevrimiçi deneyin .

Oluşturulan Python programı üçüncü kez cazibesi meydan @ Mr.Xcoder cevap dayanmaktadır .

Açıklama:

Java 8 kodu:

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 kodu:

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, programlari in Perl 5

Bash programı gibi çağrılabilir script.sh 1,2,3.

-EBayrağı ile Perl programı çağrılmalıdır .

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

perlGirişi için oluşturulan kod 4,7,8:

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

Güzel kaba kuvvet. Dizinin bir öğesini kaldırır (dizinin başlangıçta perlvar olmaması umurumda değil), önceden ayarlanmamışsa onu ayarlar. Daha sonra, dizinin ilk öğesini sonda yankılar. ( ENDBlok en son çalıştırılır). Programdan exec 'true'çıkar, böylece diğer ENDbloklar yürütülmez.

Misal:

#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 ++ üretir

Bu herhangi bir rekoru kırmayacak, esas olarak nasıl yapılacağını anlayabileceğimi düşünmekle ilgilendim :) Global değişkenlerin anadan önce çalıştırıldığı gerçeğini kullanın ve böylece global bir değişkeni artırabilir, sonra bir #ifdef main komutunun yalnızca bir kez tanımlandığından emin olmak için.

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

Runik Büyüler , Runik üretir

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

Çevrimiçi deneyin!

Girdileri boşlukla ayrılmış değerler listesi olarak alır.

Çıktı bir kez yapılır
Çıktı iki kez yapılır
Çıktı dört kez yapılır

Sürekli sayısal okuma modu komutu, kullanır ´işlendiği Jan 12 ve 14 bu soruyu buldum. Bu komut, rasgele uzunluk değerlerinin, bu özellik olmadan bunu yapmak çok zor olacağı için kodlanabilmesine izin verir (örneğin , minimum ek bir döngü gerektirecek 1392şekilde temsil edilmesi gerekir 1X3+X9+X2+); ´Komutu oluşturduğumda tam olarak çözmek istediğim problem .

Orijinal kodunda, |dizeleri "{Zs$;|1|l;|y"ve "UwR'10<|I+}"ile değiştirilir \n(ızgara oturmak ve değişiklik olan normal şekilde) ile wayin komutları: 74akw, 94/Rakw, c4akwve 85akw. Orijinal karakterler tam anlamıyla herhangi bir şey olabilir. |istediğimi görsel olarak temsil eden sembolik bir yer tutucu olarak seçildi. Birkaç bayt (kodlanmamış olanlar) bir giriş noktası eklemek zorunda kalmadan kurtardı ( zaten var olan bir konuma wR'10<yazıyor R(konum 0,1) ve sonra bir döngüden sonra mana bitmeden yığınını gereksiz yere doldurmaya devam ediyor dizisi U"'i34.

Ortaya çıkan çıkış kodu w, ikinci satırdaki ilk karakteri bir Rışık yönlendirme olarak değiştirmek için rite komutunu kullanarak çalışır (böylece yalnızca bir IP bir yazdırma ifadesi yürütür), hangi dizinin daha uzun ve uzun programlardan kaynaklandığı yığın uzunluğunun akıllıca kullanılması okumak. Diğer tüm IP'ler aynı konumu aynı talimatla değiştirir ve sona erer. Diğer her şey kullanılmaz.

_{Görüntü eski, ancak akış açıklaması için yeterli.}

Her yürütme 1IyIP'nin lboyutu , komutun neden olduğu programın temel kaynak kodunun kaç kopyasının olduğunu belirlemesine izin veren daha büyük ve daha büyük bir yığını işleme yeteneğini korur . Final 1, ldoğru değere ulaşmak için yığını döndürürken (bir sonraki oluşturulur) öncekini gerekli sayıya arttırmak için kullanılır . ZKomut, bu değer ortadan doğru yönde yığın döndükçe, böylece.

Orijinal giriş dizisi daha sonra, aynı değerleri aşamalı olarak değiştirmemek için orijinal girişleri okumak üzere 0 ile astarlanmış sürekli okuma modu kullanılarak kodlanır. Sürekli okuma modundan çıkmak ve sonraki 0'ın yığını yeniden doldurmasını sağlamak için NOP alanı gerekir.

Skor yaklaşık eşit olmalıdır 3+v.toString().lengthher bir dizi giriş için, v, +23her bir dizi için. Yaklaşık (2.55*total length of input)ya 33837da örnek girişi için, eğer doğru şeyler yaparsam.

sKomuta ile ilgili aynı derlemede ortaya çıkan yan etkiler nedeniyle beklenen son programımda küçük değişiklikler yapıldı , ancak aynı zamanda daha iyi bir skorla sonuçlandı.