Cho một mảng các số nguyên dương Alàm đầu vào, tạo ra một chương trình, khi được lặp lại nhiều klần, sẽ xuất kgiá trị thứ (1-index) của mảng.

Ví dụ, nếu mảng là [1,11], đầu ra phải là một chương trình xuất ra 1và khi lặp lại hai lần, đầu ra 11. Mã như print(end="1");trong Python 3 hoạt động: print(end="1");in 1 và print(end="1");print(end="1");in 11

Tổng nhỏ nhất của độ dài mã để giải quyết tất cả các trường hợp thử nghiệm giành chiến thắng. Mã meta của bạn sẽ giải quyết 500 trường hợp thử nghiệm trong 60 giây và mỗi mã giải pháp của bạn sẽ trả về sau 10 giây. Mã meta và mã giải pháp không cần phải có cùng ngôn ngữ, nhưng tất cả các giải pháp mà chương trình meta của bạn tạo ra phải ở cùng một ngôn ngữ.

Dữ liệu trước và máy phát điện có thể được nhìn thấy ở đây . 7 ngày sau sẽ sử dụng tổng thời gian nộp (ví dụ 12:34 có nghĩa là 1234) để làm hạt giống ngẫu nhiên và tạo ra một trường hợp thử nghiệm khác làm trường hợp thử nghiệm cuối cùng.

Hạt giống cuối cùng là 7335 trong GMT + 8, vì vậy dữ liệu thử nghiệm cuối cùng ở đây

Python 3 , tạo Stax

Điều này sử dụng một loạt các chiến lược. Hầu hết các chiến lược chỉ áp dụng trong một số điều kiện nhất định, nhưng có một chiến lược dự phòng luôn có thể sử dụng được. Cuối cùng, chương trình ứng cử viên nhỏ nhất được chọn.

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)

Hãy thử trực tuyến!

Cập nhật: Xác nhận Sẽ tốn thời gian để thực hiện từng bội số của từng chương trình một cách riêng biệt. Có thể chạy tất cả chúng cùng một lúc. Để làm điều này, một đoạn mã nhỏ phải được sử dụng. Nó chịu trách nhiệm cho một vài điều.

1. Làm đầu ra ngầm nếu có. Thông thường, vào cuối chương trình stax, đỉnh ngăn xếp được in nếu không có đầu ra nào khác. Khi chạy nhiều chương trình trong cùng một tệp nguồn, điều này phải được thực hiện rõ ràng.

2. Xóa cả ngăn xếp.

3. Đặt lại thanh ghi. Đối với các chương trình này, chỉ có thanh ghi x được sử dụng.

Bản tóm tắt này nên được áp dụng sau mỗi chương trình riêng lẻ được thực thi.

|d{P}{zP}?0XLd

Ví dụ, đầu vào [5,2,7,3]tạo ra chương trình stax 3527E|X@. Tất cả bốn bội số có thể được kiểm tra cùng một lúc.

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

Hãy thử trực tuyến!

Theo cách này, có thể kiểm tra tất cả các bội số của tất cả chương trình trong cùng một lần chạy, giả sử không có gì phá vỡ. Nó có thể là chương trình stax lớn nhất từng được thực hiện nếu tất cả 500 được thực hiện.

Perl 5 -p , tạo Perl 5 -p , trên cao 19 17 13

-1 cảm ơn @Dom Hastings

Điểm cho một đầu vào sẽ là length of the input + 13. Rõ ràng có thể được cải thiện bằng cách tạo các chương trình tự giải nén cho các đầu vào lớn hơn, nhưng tôi sẽ không bận tâm.

Đưa ra mảng đầu vào được phân tách bằng dấu phẩy trên một dòng trên STDIN.

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

Hãy thử trực tuyến!

Chạy nthời gian nối đầu ra không có đầu vào (ví dụ: redirect từ / dev / null)

Cách mẫu để chạy nó cho đầu vào 2,6,4,7và chương trình kết quả được lặp lại 4 lần:

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

Hãy thử trực tuyến!

Nếu bạn không thích chương trình kết quả đang cố đọc từ STDIN, hãy sử dụng phiên bản này với chi phí 17:

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

Hãy thử trực tuyến!

Cách mẫu để chạy nó cho đầu vào 2,6,4,7và chương trình kết quả được lặp lại 4 lần:

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

Hãy thử trực tuyến!

Phiên bản này gặp sự cố sau khi in đầu ra cần thiết

05AB1E , tạo 05AB1E

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

Hãy thử trực tuyến!

Chương trình được tạo cho đầu vào [5,17,7,13,2]là "5 17 7 13 2"#.g<è.

Bộ thử nghiệm cho [5,17,7,13,2]

Độ dài của chương trình được tạo là len(input) + 5

APL (Unicode Dy)

Tiền tố nặc danh lambda. Trả về một chương trình cơ thể.

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

Hãy thử trực tuyến!

Phương pháp

Điều này khám phá các phương thức khác nhau và trả về phương thức có thể sử dụng đầu tiên, cuối cùng trở lại phương pháp áp dụng phổ biến.

Yếu tố đơn

Nếu danh sách chỉ có một phần tử, nó được trả về nguyên trạng.

2, 22, v.v.

Một chữ số duy nhất có thể được lặp lại để tạo ra số lớn hơn 11 lần,

Tất cả đều giống nhau

Chúng tôi chỉ trả về số ( ⊢) bên phải .

Tuyến tính

Chuỗi f (n) = k × n chỉ cần chèn một dấu cộng trước số hạng đầu tiên.

Yếu tố tiếp theo là tất cả 1s

Khi số đầu tiên n =! M và các số tiếp theo là 1, thì đó !mlà một giải pháp vì !mn và m!mlà 1 và !1là 1.

b ab ab ab

Vì tất cả các số có hai chữ số đều lớn hơn tất cả các số có một chữ số, nên một cực đại đang chạy, trong đó mặt trước của số thứ nhất được dán vào mặt sau của số thứ hai, là một giải pháp.

Mã ba dòng

Kiểm tra xem bất kỳ công thức của loại +a×blà hợp lệ.

Chuỗi dự phòng

Chuỗi dài không có số dưới 5 (vì 4 là ngắt dòng) có thể được mã hóa thành các ký tự của SBCS.

Dự phòng chuỗi bù

Nếu có số dưới 5, chúng tôi tăng lên 9 để tránh những số đó.

Dự phòng

Nối chuỗi đơn giản của chuỗi "{⍺←⊃⋄1⌽⍺⊢⍵}"và ⍕đầu vào chuỗi ( ). Ví dụ [3,1,4]trả về cơ thể chương trình {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4.

Phần trong dấu ngoặc nhọn là một hàm ambivalent, có nghĩa là nó có thể là hàm tiền tố hoặc hàm infix. Do đó, ví dụ ngoài cùng bên trái của nó sẽ chạy trong chế độ tiền tố và tất cả các phiên bản khác trong chế độ infix. Sự khác biệt giữa các chế độ là liệu ⍺, biểu thị đối số bên trái, có giá trị hay không. Nếu không thì nó sẽ được gán chức năng ⊃(đầu tiên).

Giải thích về phương pháp dự phòng

{... } lambda anonymous:

 ⍺←⊃ Nếu không có đối số bên trái ( ⍺) gán hàm ⊃(đầu tiên) cho⍺

 ⋄ sau đó:

Tại thời điểm này, đoạn mã sau có nghĩa là hai điều khác nhau tùy thuộc vào việc đó ⍺là danh sách các số (cuộc gọi infix) hay hàm "đầu tiên" (cuộc gọi tiền tố).

 Nếu ⍺là một danh sách các số:

  ⍺⊢⍵ loại bỏ đối số bên trái có lợi cho đối số bên phải

  1⌽ xoay một bước còn lại

 Nếu ⍺là chức năng "đầu tiên":

  ⊢⍵ đưa ra lập luận đúng

  ⍺ chọn yếu tố đầu tiên

  1⌽ xoay nó một bước (không có op trên vô hướng)

Ví dụ chạy phương thức dự phòng

Thực thi 3 1 4mã, {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4gán hàm "đầu tiên" ⍺và do đó trả về phần tử đầu tiên; 3.

Việc thực thi {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4cho phép lambda ngoài cùng bên phải "bắt" bên trái 3 1 4làm đối số bên trái của nó, do đó, ⍺có một giá trị bị loại bỏ theo hướng có lợi 3 1 4sau đó được xoay một bước sang trái và mang lại 1 4 3kết quả. Điều này sau đó được sử dụng làm đối số duy nhất cho lambda ngoài cùng bên trái, nơi ⍺trở thành hàm "đầu tiên", khiến kết quả là phần tử đầu tiên; 1.

Việc thực thi {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4cho phép lambda ngoài cùng bên phải "bắt" giữa 3 1 4là đối số bên trái của nó, sau đó được loại bỏ theo hướng có lợi cho đối số bên phải 3 1 4, khi xoay một bước bên trái là 1 4 3. Điều này sau đó được sử dụng làm đối số bên phải của lambda giữa cùng với đối số ngoài cùng bên 3 1 4trái. Đối số bên trái được loại bỏ cho bên phải, mà xoay vòng một bước năng suất trái 4 3 1. Điều này sau đó trở thành đối số duy nhất của lambda ngoài cùng bên trái, do đó ⍺trở thành "hàm đầu tiên", trả về phần tử đầu tiên; 4.

Chấm điểm

Khi đến lúc kiểm tra bằng dữ liệu thực tế, hãy sử dụng khai thác kiểm tra này (được liên kết với dữ liệu giả định). Các trường hợp thử nghiệm đi vào trường Đầu vào và Đầu ra sẽ là tổng số byte của tất cả 500 chương trình cùng nhau. (Nó cũng sẽ gây ra lỗi, nhưng đó chỉ là do sau đó nó cố gắng đánh giá Đầu vào nguyên trạng.)

than củi

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

´⎚´§´⪪

Xuất chuỗi ký tự ⎚§⪪.

⪫ＩＡ 

Truyền mảng đầu vào thành chuỗi, nối với khoảng trắng và in.

”y¦ Ｌυ⊞υω

Xuất chuỗi ký tự ¦ Ｌυ⊞υω.

Đầu ra của ví dụ 5,17,7,13,2là ⎚§⪪5 17 7 13 2¦ Ｌυ⊞υω. Hãy thử trực tuyến! Giải trình:

⎚

Xóa khung vẽ, để chỉ có thể nhìn thấy đầu ra cuối cùng.

§⪪5 17 7 13 2¦ Ｌυ

Lấy chiều dài của danh sách được xác định trước u. Sử dụng để lập chỉ mục vào danh sách các số nguyên đã được phân tách trên khoảng trắng và xuất phần tử được chọn.

⊞υω

Đẩy một biến giả vào danh sách được xác định trước u, để bản sao tiếp theo sẽ xuất phần tử tiếp theo của danh sách.

Tổng chiều dài đầu ra = (độ dài của tất cả các số nguyên trong tất cả các danh sách) + (số lượng số nguyên trong tất cả các danh sách) + (số danh sách * 9) ký tự (SBCS).

Haskell , tạo Haskell

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

Hãy thử trực tuyến! Đối với testcase đầu tiên, [5,2,7,3,2,3,15,10,7,2,14,11,16,16,3,3,4,3,8,4]nó tạo ra chương trình sau:

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

Hãy thử một lần , nhân đôi và nhân ba . Điều này sử dụng cách tiếp cận tương tự như câu trả lời Haskell của tôi để tôi nhân đôi nguồn, bạn nhân đôi sản lượng .

Độ dài của mỗi chương trình được tạo là độ dài của danh sách đầu vào dưới dạng chuỗi cộng với 25, do đó, điểm cho các testcase hiện có là 12266 + 500 * 25 = 24766. Điều này cho thấy tỷ lệ mã trên dữ liệu về cơ bản là bằng nhau và tôi nghi ngờ rằng có thể viết mã giải nén đủ nhỏ sẽ làm giảm điểm. Có thể là có thể nếu danh sách nơi lớn hơn nhiều.

Python 2 , tạo Python 2

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

Hãy thử trực tuyến!

Đối với đầu vào

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

chương trình được tạo là

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

đó là 98 byte.

Được điều chỉnh từ giải pháp này trong "Tôi nhân đôi nguồn, bạn nhân đôi sản lượng!".

Chết tiệt, hai câu trả lời ngắn hơn xuất hiện trước khi tôi viết xong câu trả lời này.

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

Hãy thử trực tuyến.

Tức là [3,4,5,6,7]tạo chương trình Python 2 này:

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

Hãy thử trực tuyến một lần ; Hãy thử trực tuyến hai lần ;Hãy thử trực tuyến ba lần .

Chương trình Python được tạo dựa trên câu trả lời của @ Mr.Xcoder cho lần thứ ba thử thách quyến rũ .

Giải trình:

Mã 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 "]#"

Mã 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, các chương trình đầu ra trong Perl 5

Chương trình Bash có thể được gọi là như thế script.sh 1,2,3.

Chương trình Perl nên được gọi với -Ecờ.

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

perlMã được tạo cho đầu vào 4,7,8là:

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

Lực lượng khá vũ phu. Loại bỏ một phần tử của mảng ( perlkhông quan tâm rằng mảng đó không tồn tại lúc đầu), đặt nó nếu nó chưa được đặt. Sau đó, nó lặp lại phần tử đầu tiên của mảng ở cuối. ( ENDKhối được chạy sau cùng). Các exec 'true'bỏ chương trình, do đó tiếp tụcEND khối theo không được thực thi.

Thí dụ:

#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, tạo C ++

Điều này sẽ không đánh bại bất kỳ hồ sơ nào, tôi chủ yếu quan tâm đến việc liệu tôi có thể tìm ra cách thực hiện không :) Sử dụng thực tế là các biến toàn cục được chạy trước chính và do đó có thể tăng một biến toàn cục, sau đó sử dụng một #ifdef để đảm bảo chính chỉ được xác định một lần.

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

Runic Enchantments , tạo Runic

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

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng danh sách các giá trị được phân tách bằng dấu cách.

Đầu ra được thực hiện một lần
Đầu ra được thực hiện hai lần
Đầu ra được thực hiện bốn lần

Sử dụng lệnh chế độ đọc số liên tục, ´được cam kết vào ngày 12 tháng 1 và tôi đã tìm thấy câu hỏi này vào ngày 14. Lệnh này cho phép các giá trị độ dài tùy ý có thể được mã hóa vì nếu không có tính năng này thì sẽ rất khó thực hiện (ví dụ: 1392cần phải được biểu diễn dưới dạng 1X3+X9+X2+, yêu cầu một vòng lặp bổ sung ở mức tối thiểu); chính xác vấn đề tôi muốn giải quyết khi tôi tạo ´lệnh.

Trong đoạn mã gốc, |trong chuỗi "{Zs$;|1|l;|y"và "UwR'10<|I+}"được thay thế bằng \n(mà ngồi trong lưới và không sửa đổi nó, khi họ bình thường) với wlệnh nghi thức: 74akw, 94/Rakw, c4akw, và 85akw. Các nhân vật ban đầu có thể là bất cứ điều gì theo nghĩa đen. |đã được chọn để trở thành một người giữ chỗ mang tính biểu tượng đại diện trực quan cho những gì tôi muốn. Một số byte được lưu (nếu bỏ qua các byte) bằng cách không phải phản xạ thêm một điểm vào, như wR'10<ghi Rvào một vị trí nơi nó đã tồn tại (vị trí 0,1), và sau đó tiến hành lấp đầy ngăn xếp của nó với rác trước khi hết mana, sau một vòng lặp trình tự U"'i34.

Mã đầu ra kết quả hoạt động bằng cách sử dụng wlệnh rite để thay đổi ký tự đầu tiên trên dòng thứ hai thành Rchuyển hướng ight (vì vậy chỉ có một IP thực hiện một câu lệnh in), với việc sử dụng thông minh độ dài ngăn xếp từ các chương trình cao hơn và cao hơn để xác định chỉ mục nào đọc. Mọi IP khác thay đổi cùng một vị trí theo cùng một hướng dẫn và chấm dứt. Mọi thứ khác không được sử dụng.

_{Hình ảnh đã lỗi thời, nhưng đủ để giải thích dòng chảy.}

Mỗi lần thực thi 1Iyduy trì khả năng của IP để xử lý một ngăn xếp lớn hơn và lớn hơn (do llệnh gây ra ), kích thước cho phép chương trình xác định có bao nhiêu bản sao của mã nguồn cơ sở. Cuối cùng 1được sử dụng để tăng số trước llên số được yêu cầu khi xoay ngăn xếp (được tạo tiếp theo) để đến giá trị chính xác. Các Zlệnh phủ nhận giá trị này để xoay chồng theo hướng đúng.

Mảng đầu vào ban đầu sau đó được mã hóa bằng chế độ đọc liên tục, được bắt đầu bằng 0 để tránh sửa đổi tăng dần cùng một giá trị, để đọc các đầu vào ban đầu. Không gian NOP được yêu cầu để thoát khỏi chế độ đọc liên tục và cho phép 0 tiếp theo ghi lại ngăn xếp.

Điểm phải bằng khoảng 3+v.toString().length, cho mỗi mục nhập mảng v, +23cho mỗi mảng. Khoảng (2.55*total length of input)hoặc 33837cho đầu vào mẫu, nếu tôi đã làm đúng.

Những thay đổi nhỏ đã được đưa vào chương trình cuối cùng dự kiến ​​của tôi do các tác dụng phụ được giới thiệu trong cùng bản dựng liên quan đến slệnh, tuy nhiên nó đã mang lại điểm số cao hơn cùng một lúc.