ให้อาร์เรย์ของจำนวนเต็มบวก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 วินาที รหัส Meta และรหัสโซลูชันไม่จำเป็นต้องเป็นภาษาเดียวกัน แต่โซลูชันทั้งหมดที่โปรแกรมเมตาที่คุณสร้างขึ้นควรเป็นภาษาเดียวกัน

สามารถดูข้อมูลและตัวกำเนิดล่วงหน้าได้ที่นี่ 7 วันต่อมาจะใช้เวลารวมของการส่ง (เช่น 12:34 หมายถึง 1234) เพื่อเป็นเมล็ดสุ่มและสร้างกรณีทดสอบอื่นเป็นกรณีทดสอบสุดท้าย

เมล็ดสุดท้ายคือ 7335 ใน GMT + 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] 3527E|X@ทั้งสี่ multiplicities สามารถทดสอบได้ในครั้งเดียว

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

ลองออนไลน์!

ด้วยวิธีนี้จึงเป็นไปได้ที่จะทดสอบหลายหลากของโปรแกรมทั้งหมดในการรันเดียวกันโดยไม่มีการหยุดพัก มันอาจจะเป็นโปรแกรม stax ที่ใหญ่ที่สุดที่เคยมีการเรียกใช้ถ้าทำ 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 เท่า

เหมือนกันทั้งหมด

เราแค่ส่งคืนหมายเลข rightmost ( ⊢)

เชิงเส้น

f (n) = k × nลำดับเพียงใส่เครื่องหมายบวกก่อนเทอมแรก

แฟคทอเรียลตามด้วย 1s ทั้งหมด

เมื่อจำนวนแรก n =! m และตัวเลขที่ตามมาเป็น 1 แล้ว!mเป็นทางออกเพราะ!mเป็น n และm!mเป็น 1 และ!1เป็น 1

b ab ab ab

เนื่องจากตัวเลขสองหลักทั้งหมดมีขนาดใหญ่กว่าตัวเลขหลักเดียวทั้งหมดค่าสูงสุดที่ใช้งานซึ่งด้านหน้าของหมายเลขแรกถูกจับที่ด้านหลังของตัวเลขที่สองจึงเป็นวิธีแก้ปัญหา

รหัสสามบรรทัด

ตรวจสอบว่าสูตรประเภทใด ๆ ที่+a×bถูกต้อง

สตริงทางเลือก

ลำดับยาวที่ไม่มีตัวเลขต่ำกว่า 5 (เนื่องจาก 4 เป็นตัวแบ่งบรรทัด) สามารถเข้ารหัสเป็นอักขระของ SBCS

ทางเลือกสตริงออฟเซ็ต

หากมีตัวเลขต่ำกว่า 5 เราจะเลื่อนขึ้น 9 เพื่อหลีกเลี่ยง

รั้งท้าย

การต่อสตริงอย่างง่ายของสตริง"{⍺←⊃⋄1⌽⍺⊢⍵}"และอินพุต stringified ( ⍕) เช่นผลตอบแทนร่างกายโปรแกรม[3,1,4]{⍺←⊃⋄1⌽⍺⊢⍵}3 1 4

ส่วนในวงเล็บปีกกาเป็นฟังก์ชั่นเด็ดขาดซึ่งหมายความว่ามันอาจเป็นได้ทั้งฟังก์ชั่นคำนำหน้าหรือฟังก์ชั่นมัด ดังนั้นอินสแตนซ์ทางซ้ายสุดของมันจะทำงานในโหมดส่วนนำหน้าและส่วนอื่น ๆ ทั้งหมดในโหมด infix ความแตกต่างระหว่างโหมดคือการระบุว่า⍺อาร์กิวเมนต์ซ้ายมีค่าหรือไม่ หากไม่เป็นเช่นนั้นจะมีการกำหนดฟังก์ชั่น⊃(ก่อน)

คำอธิบายของวิธีการทางเลือก

{… } แลมบ์ดานิรนาม:

 ⍺←⊃ หากไม่มีข้อโต้แย้งเหลือ ( ⍺) กำหนดฟังก์ชั่น⊃(ก่อน) เพื่อ⍺

 ⋄ แล้ว:

ณ จุดนี้รหัสต่อไปนี้หมายถึงสองสิ่งที่แตกต่างกันขึ้นอยู่กับว่า⍺เป็นรายการหมายเลข (การเรียกใช้แบบ infix) หรือฟังก์ชัน "first" (การเรียกคำนำหน้า)

 หาก⍺เป็นรายการหมายเลข:

  ⍺⊢⍵ ทิ้งอาร์กิวเมนต์ซ้ายเพื่อสนับสนุนอาร์กิวเมนต์ที่ถูกต้อง

  1⌽ หมุนไปทางซ้ายหนึ่งก้าว

 ถ้า⍺เป็นฟังก์ชั่น "first":

  ⊢⍵ ให้ผลอาร์กิวเมนต์ที่ถูกต้อง

  ⍺ เลือกองค์ประกอบแรกของที่

  1⌽ หมุนหนึ่งขั้นตอน (ไม่ต้องใช้สเกลาร์)

ตัวอย่าง run of fallback method

การ3 1 4เรียกใช้โค้ด ' {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4, กำหนดฟังก์ชัน "first" ให้กับ⍺และส่งคืนองค์ประกอบแรก 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¦ Ｌυ⊞υω

⎚

ล้าง Canvas เพื่อให้มองเห็นเฉพาะเอาต์พุตสุดท้ายเท่านั้น

§⪪5 17 7 13 2¦ Ｌυ

uใช้ความยาวของรายการที่กำหนดไว้ล่วงหน้า ใช้สิ่งนั้นเพื่อจัดทำดัชนีในรายการจำนวนเต็มที่ถูกแบ่งในช่องว่างและส่งออกองค์ประกอบที่เลือก

⊞υω

ผลักตัวแปรดัมมี่ไปยังรายการที่กำหนดไว้ล่วงหน้าuเพื่อให้สำเนาถัดไปจะส่งออกองค์ประกอบถัดไปของรายการ

ความยาวเอาท์พุทรวม = (ความยาวของจำนวนเต็มทั้งหมดในทุกรายการ) + (จำนวนเต็มในรายการทั้งหมด) + (จำนวนรายการ * 9) อักขระ (SBCS)

Haskellสร้าง Haskell

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

ลองออนไลน์! สำหรับ testcase แรก[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--

ลองใช้ครั้งเดียว , สองเท่าและtrippled นี้จะใช้วิธีการเดียวกันเป็นคำตอบ Haskell ของฉันไปฉันเป็นสองเท่าของแหล่งที่มาของคุณสองเอาท์พุท

ความยาวของโปรแกรมสร้างขึ้นในแต่ละคือความยาวของรายการการป้อนข้อมูลที่เป็นสตริงบวก 25 จึงให้คะแนนสำหรับ testcases 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 ++

นี่ไม่ใช่การเอาชนะระเบียนใด ๆ ฉันสนใจที่จะคิดว่าฉันจะทำยังไงดี :) ใช้ข้อเท็จจริงที่ว่าตัวแปรทั่วโลกถูกเรียกใช้ก่อนหลักและสามารถเพิ่มตัวแปรทั่วโลกจากนั้นใช้ #ifdef เพื่อให้แน่ใจว่ามีการกำหนดหลักเพียงครั้งเดียว

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สร้าง Runic

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ลำดับ

โค้ดผลลัพธ์ที่ได้นั้นทำงานโดยใช้wคำสั่ง rite เพื่อเปลี่ยนอักขระตัวแรกในบรรทัดที่สองเป็นการRเปลี่ยนเส้นทาง ight (ดังนั้น IP เพียงหนึ่งเดียวเท่านั้นที่ดำเนินการคำสั่ง print) ด้วยการใช้ความยาวสแต็คอย่างชาญฉลาดจากโปรแกรมสูงและสูงเพื่อกำหนดดัชนี อ่าน. IP อื่น ๆ ทุกตัวจะเปลี่ยนตำแหน่งเดียวกันเป็นคำสั่งเดียวกันและสิ้นสุดลง ทุกอย่างอื่นไม่ได้ใช้

_{รูปภาพล้าสมัย แต่เพียงพอสำหรับคำอธิบายการไหล}

การดำเนินการแต่ละครั้งจะ1Iyรักษาความสามารถของ IP ในการจัดการสแต็กที่มีขนาดใหญ่และขนาดใหญ่ขึ้น (เกิดจากlคำสั่ง) ขนาดที่อนุญาตให้โปรแกรมกำหนดจำนวนสำเนาของรหัสฐานพื้นฐานที่มี รอบชิงชนะเลิศ1ใช้เพื่อเพิ่มจำนวนก่อนหน้าlเป็นจำนวนที่ต้องการเมื่อหมุนสแต็ก (สร้างถัดไป) เพื่อให้ได้ค่าที่ถูกต้อง Zคำสั่งขัดแย้งค่านี้เพื่อให้หมุนสแต็คในทิศทางที่ถูกต้อง

อาเรย์อินพุตดั้งเดิมจะถูกเข้ารหัสโดยใช้โหมดการอ่านแบบต่อเนื่องโดยมีค่าเป็น 0 เพื่อหลีกเลี่ยงการแก้ไขค่าเดียวกันแบบเพิ่มหน่วยเพื่ออ่านอินพุตดั้งเดิม จำเป็นต้องใช้พื้นที่ NOP เพื่อออกจากโหมดการอ่านอย่างต่อเนื่องและอนุญาตให้ 0 ต่อมาไพรม์สแต็กอีกครั้ง

คะแนนควรจะเท่ากับประมาณ3+v.toString().lengthสำหรับรายการอาร์เรย์แต่ละv, +23สำหรับแต่ละอาร์เรย์ ประมาณ(2.55*total length of input)หรือ33837สำหรับตัวอย่างอินพุตถ้าฉันทำสิ่งที่ถูกต้อง

การเปลี่ยนแปลงเล็กน้อยถูกนำมาใช้ในโปรแกรมสุดท้ายของฉันที่คาดไว้เนื่องจากผลข้างเคียงที่นำมาใช้ในโครงสร้างเดียวกันเกี่ยวกับsคำสั่งอย่างไรก็ตามมันทำให้ได้คะแนนที่ดีขึ้นในเวลาเดียวกัน