एन-वें नंबर के लिए एन बार प्रोग्राम

Question

Aइनपुट के रूप में सकारात्मक पूर्णांक की एक सरणी को देखते हुए , एक प्रोग्राम उत्पन्न करें, जो kसमय के लिए दोहराया जाता है, kसरणी के वें (1-सूचकांक) मान को आउटपुट करता है ।

उदाहरण के लिए, यदि सरणी है [1,11], तो आउटपुट एक प्रोग्राम होना चाहिए जो आउटपुट करता है 1, और जब दो बार दोहराया जाता है, तो आउटपुट 11। print(end="1");अजगर 3 कोड की तरह कोड : print(end="1");1 प्रिंट करता है और print(end="1");print(end="1");11 प्रिंट करता है

सभी परीक्षण मामलों को हल करने के लिए कोड की लंबाई का सबसे छोटा योग जीत। आपके मेटा कोड को 60 के दशक में 500 परीक्षण मामलों को हल करना चाहिए, और आपके प्रत्येक समाधान कोड को 10 के दशक में वापस आ जाना चाहिए। मेटा कोड और सॉल्यूशन कोड एक ही भाषा में नहीं होना चाहिए, लेकिन आपके मेटा-प्रोग्राम जेनरेट होने वाले सभी समाधान एक ही भाषा में होने चाहिए।

प्रीस्टेस्ट डेटा और जनरेटर यहां देखे जा सकते हैं । 7 दिनों के बाद जमा करने के समय का उपयोग करेगा (जैसे 12:34 मतलब 1234) यादृच्छिक बीज होने के लिए और अंतिम परीक्षण मामले के रूप में एक और परीक्षण मामला उत्पन्न करता है।

---

अंतिम बीज GMT + 8 में 7335 है, इसलिए अंतिम परीक्षण डेटा यहां है

Comments

"के समय के लिए दोहराया" का क्या मतलब है? NewSourceCode = SourceCode k बार दोहराएं? जैसे SourceCode = "ABC", k = 3, फिर NewSourceCode = "ABCABCABC"?

— tsh

print(end="1");2 बार दोहराया जाता हैprint(end="1");print(end="1");

— l4m2

"कोड लंबाई का योग" का क्या अर्थ है? क्या हमें एक से अधिक कार्यक्रम प्रस्तुत करने चाहिए?

— tsh

आप एक कार्यक्रम प्रस्तुत करते हैं जो ५०० कार्यक्रम बनाता है

— l4m2

@Emigna नहीं, प्रत्येक सूची के लिए यह एक एकल कार्यक्रम बनाता है। कहो कि कार्यक्रम बस है x। फिर xसूची का पहला तत्व xxदेना चाहिए , सूची का दूसरा तत्व xxxदेना चाहिए, तीसरा देना चाहिए, और इसी तरह।

— क्रिस

Answer 1

पायथन 3 , स्टेक्स उत्पन्न करता है

यह विभिन्न प्रकार की रणनीतियों का उपयोग करता है। अधिकांश रणनीतियाँ केवल कुछ शर्तों के तहत लागू होती हैं, लेकिन एक वापसी रणनीति है जो हमेशा उपयोग करने योग्य होती है। सबसे अंत में, सबसे छोटे उम्मीदवार कार्यक्रम का चयन किया जाता है।

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. यदि कोई हो तो निहित आउटपुट करें। आम तौर पर, एक स्टैक्स प्रोग्राम के अंत में, स्टैक के शीर्ष को प्रिंट किया जाता है यदि कोई अन्य आउटपुट नहीं हुआ है। एक ही स्रोत फ़ाइल में कई प्रोग्राम चलाते समय, यह स्पष्ट रूप से किया जाना चाहिए।

2. दोनों ढेर साफ करें।

3. रजिस्टर रीसेट करें। इन कार्यक्रमों के लिए केवल x रजिस्टर का उपयोग किया जाता है।

इस बायलरप्लेट को प्रत्येक व्यक्तिगत कार्यक्रम के बाद लागू किया जाना चाहिए।

|d{P}{zP}?0XLd

उदाहरण के लिए, इनपुट [5,2,7,3]स्टैक्स प्रोग्राम का उत्पादन करता है 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 किए गए हैं।

Comments

अंतिम स्कोर 7862

— l4m2

Answer 2

पर्ल 5 -p , उत्पन्न करता है पर्ल 5 -p , भूमि के ऊपर 19 17 13

-1 @ हेस्टिंग्स को धन्यवाद

एक इनपुट के लिए स्कोर होगा 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)[$-++],'

इसे ऑनलाइन आज़माएं!

आवश्यक आउटपुट प्रिंट करने के बाद यह संस्करण क्रैश हो जाता है

Comments

मुझे यकीन नहीं है कि मुझे स्कोरिंग काफी पसंद है, लेकिन क्या यह प्रोग्राम 1 बाइट कम है s/ /,/g;$_="die say+($_)[\$-++],":?

— डोम हेस्टिंग्स

@DomHastings वास्तव में यह करता है।

— टन हास्पेल

अंतिम स्कोर 17106

— l4m2

Answer 3

05AB1E , 05AB1E उत्पन्न करता है

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

इसे ऑनलाइन आज़माएं!

इनपुट के लिए उत्पन्न कार्यक्रम [5,17,7,13,2]है "5 17 7 13 2"#.g<è।

[5,17,7,13,2] के लिए टेस्ट सूट

उत्पन्न कार्यक्रम की लंबाई है len(input) + 5

Comments

स्पष्ट होने के लिए, len(input)पूर्णांक की गिनती नहीं है, लेकिन स्ट्रिंग की लंबाई उन सभी को पकड़े हुए है। मैंने पहले गलत समझा।

— पुनरावर्ती

अंतिम स्कोर 14606

— l4m2

Answer 4

एपीएल (डायलॉग यूनिकोड)

अनाम उपसर्ग लंबोदर। एक कार्यक्रम निकाय देता है।

 {
     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 क्रम केवल पहले शब्द से पहले एक प्लस सम्मिलित करते हैं।

सभी 1s के बाद फैक्टरियल

जब पहली संख्या n =! M और बाद की संख्या 1 होती है, तो !mएक समाधान है क्योंकि !mn है और m!m1 है और !11 है।

b ऐब एब

चूंकि सभी दो-अंकीय संख्या सभी एकल-अंकीय संख्याओं से बड़ी हैं, एक अधिकतम चल रही है, जहां पहले नंबर के सामने दूसरे नंबर के पीछे से चिपके हुए हैं, एक समाधान है।

तीन-लाइन-कोड

जांचें कि क्या प्रकार +a×bका कोई सूत्र मान्य है।

गिरती हुई पीठ

5 (क्योंकि 4 लाइन ब्रेक है) के तहत बिना संख्या वाले लंबे अनुक्रम को SBCS के पात्रों के रूप में एन्कोड किया जा सकता है।

ऑफ़सेट स्ट्रिंग फ़ॉलबैक

यदि संख्या 5 से कम है, तो हम उन से बचने के लिए 9 से ऊपर जाते हैं।

मैदान छोड़ना

स्ट्रिंग "{⍺←⊃⋄1⌽⍺⊢⍵}"और सरल ( ⍕) इनपुट का सरल स्ट्रिंग संयोजन । जैसे [3,1,4]प्रोग्राम बॉडी को वापस करता है {⍺←⊃⋄1⌽⍺⊢⍵}3 1 4।

ब्रेसिज़ में हिस्सा एक महत्वाकांक्षी फ़ंक्शन है जिसका अर्थ है कि यह एक उपसर्ग फ़ंक्शन या एक इन्फिक्स फ़ंक्शन हो सकता है। इस प्रकार इसका सबसे ऊपरी उदाहरण उपसर्ग मोड में और अन्य सभी इन्फिक्स मोड में चलेगा। मोड के बीच अंतर यह है कि क्या ⍺, बाएं तर्क को दर्शाता है, एक मूल्य है। यदि ऐसा नहीं होता है तो इसे फंक्शन ⊃(पहले) सौंपा जाएगा ।

फॉलबैक विधि की व्याख्या

{… } अनाम लंबोदर:

 ⍺←⊃ यदि कोई वाम तर्क नहीं है ( ⍺) फ़ंक्शन ⊃(पहले) को असाइन करें⍺

 ⋄ फिर:

इस बिंदु पर, निम्न कोड का मतलब दो अलग-अलग चीजों पर निर्भर करता है कि क्या ⍺संख्याओं की सूची (इन्फिक्स कॉल) या फ़ंक्शन "पहले" (उपसर्ग कॉल) है।

 यदि ⍺संख्याओं की सूची है:

  ⍺⊢⍵ बाएँ तर्क को सही तर्क के पक्ष में छोड़ें

  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 कार्यक्रमों की कुल बाइट गिनती होगी। (यह एक त्रुटि भी फेंक देगा, लेकिन यह सिर्फ इसलिए है क्योंकि यह इनपुट के रूप में मूल्यांकन करने की कोशिश करता है।)

Comments

अंतिम स्कोर 14028

— l4m2

Answer 5

लकड़ी का कोयला

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

´⎚´§´⪪

शाब्दिक स्ट्रिंग आउटपुट ⎚§⪪।

⪫ＩＡ 

स्ट्रिंग के लिए इनपुट सरणी कास्ट करें, रिक्त स्थान के साथ जुड़ें, और प्रिंट करें।

”y¦ Ｌυ⊞υω

शाब्दिक स्ट्रिंग आउटपुट ¦ Ｌυ⊞υω।

उदाहरण के लिए आउटपुट 5,17,7,13,2है ⎚§⪪5 17 7 13 2¦ Ｌυ⊞υω। इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

⎚

कैनवास को साफ़ करें, ताकि केवल अंतिम आउटपुट दिखाई दे।

§⪪5 17 7 13 2¦ Ｌυ

पूर्वनिर्धारित सूची की लंबाई लें u। उन पूर्णांकों की सूची में अनुक्रमित करने के लिए उपयोग करें जो रिक्त स्थान पर विभाजित किए गए हैं और चयनित तत्व को आउटपुट करते हैं।

⊞υω

पूर्वनिर्धारित सूची में एक डमी चर को पुश करें u, ताकि अगली कॉपी सूची के अगले तत्व का उत्पादन करे।

कुल उत्पादन लंबाई = (सभी सूचियों में सभी पूर्णांकों की लंबाई) + (सभी सूचियों में पूर्णांकों की संख्या) + (सूचियों की संख्या * 9) वर्ण (SBCS)।

Answer 6

हास्केल , हास्केल उत्पन्न करता है

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

इसे एक बार आज़माएं , दोगुना और तिगुना । यह उसी दृष्टिकोण का उपयोग करता है जैसे मेरे हास्केल उत्तर मैं स्रोत को दोगुना करता है, आप आउटपुट को दोगुना करते हैं ।

प्रत्येक उत्पन्न कार्यक्रम की लंबाई स्ट्रिंग प्लस 25 के रूप में इनपुट सूची की लंबाई है, इस प्रकार वर्तमान में उपलब्ध टेस्टकेस के लिए स्कोर है 12266 + 500 * 25 = 24766। इससे पता चलता है कि डेटा अनुपात का कोड मूल रूप से बराबर है, और मुझे संदेह है कि छोटे पर्याप्त विघटन कोड लिखना संभव है जो स्कोर कम हो जाएगा। यह संभव हो सकता है अगर सूची जहां बहुत बड़ा है।

Answer 7

पायथन 2 , पायथन 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 बाइट्स है।

इस समाधान से अनुकूलित "मैं स्रोत को दोगुना करता हूं, आप आउटपुट को दोगुना करते हैं!"।

इससे पहले कि मैं यह उत्तर लिखूं, डेमिट, दो छोटे उत्तर पॉप हो गए।

Comments

एक अतिरिक्त न्यूलाइन अंत में है, जो इसे kसमय के लिए आउटपुट बनाती है

— l4m2

अपेक्षित व्यवहार "A '\ n' वर्ण अंत में लिखा गया है, जब तक कि प्रिंट स्टेटमेंट अल्पविराम के साथ समाप्त नहीं होता है।" मुझे नहीं पता कि TIO स्टडआउट पर अतिरिक्त न्यूलाइन क्यों दिखाता है।

— बुबलर

अनुगामी "कुछ" को हटाने के लिए बदल दिया printगया sys.stdout.write।

— बबलर

अंतिम स्कोर 30606

— l4m2

Answer 8

जावा 8, पायथन 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]यह पायथन 2 कार्यक्रम उत्पन्न करता है:

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

इसे एक बार ऑनलाइन आज़माएं ; इसे ऑनलाइन दो बार आज़माएं ; इसे तीन बार ऑनलाइन आज़माएं ।

उत्पन्न अजगर कार्यक्रम तीसरी बार आकर्षण चुनौती के लिए @ Mr.Xcoder के उत्तर पर आधारित है ।

स्पष्टीकरण:

जावा 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 "]#"

पायथन 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

Answer 9

बैश, पर्ल 5 में प्रोग्राम आउटपुट करता है

बैश कार्यक्रम की तरह कहा जा सकता है script.sh 1,2,3।

-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

Comments

अंतिम स्कोर 34106

— l4m2

Answer 10

पायथन 2, सी ++ उत्पन्न करता है

यह किसी भी रिकॉर्ड को हरा देने वाला नहीं है, मुझे मुख्य रूप से यह सोचने में दिलचस्पी थी कि क्या मैं यह पता लगा सकता हूं कि यह कैसे करना है :) इस तथ्य का उपयोग करें कि वैश्विक चर मुख्य से पहले चलाए जाते हैं, और इसलिए एक वैश्विक चर को बढ़ा सकते हैं, फिर एक का उपयोग करके मुख्य सुनिश्चित करने के लिए #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
""")

Answer 11

रूनिक एनकाउंटर , रुनिक उत्पन्न करता है

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दूसरी पंक्ति पर पहले वर्ण को बदलकर Right पुनर्निर्देशन (इसलिए केवल एक आईपी एक प्रिंट स्टेटमेंट निष्पादित करता है) का उपयोग करके काम करता है, इस सूचकांक को निर्धारित करने के लिए लम्बे और लम्बे कार्यक्रमों से उत्पन्न स्टैक लंबाई के चतुर उपयोग के साथ। पढ़ने के लिए। हर दूसरा आईपी उसी स्थान को उसी निर्देश में बदलता है और समाप्त करता है। बाकी सब बेकार हो जाता है।

_{छवि पुरानी है, लेकिन प्रवाह विवरण के लिए पर्याप्त है।}

प्रत्येक निष्पादन 1Iyआईपी ​​की क्षमता को एक बड़े और बड़े स्टैक ( lकमांड के कारण ) को संभालने की क्षमता रखता है , जिसके आकार से प्रोग्राम को यह निर्धारित करने की अनुमति मिलती है कि आधार स्रोत कोड की कितनी प्रतियां हैं। सही मूल्य पर पहुंचने के लिए स्टैक को घुमाते समय (अगला बनाया गया) जब अंतिम 1को lआवश्यक संख्या में बढ़ाने के लिए अंतिम का उपयोग किया जाता है । Zआदेश यह मान को नकारता है, ताकि सही दिशा में ढेर घूमता है।

मूल इनपुट ऐरे को तब निरंतर रीड मोड का उपयोग करके एन्कोड किया जाता है, मूल इनपुट को पढ़ने के लिए समान मान को संशोधित करने से बचने के लिए 0 के साथ प्राइमेड। स्पेस एनओपी को निरंतर रीड मोड से बाहर निकलने और बाद के 0 को स्टैक को फिर से प्राइम करने की अनुमति देना आवश्यक है।

स्कोर लगभग बराबर होना चाहिए 3+v.toString().length, प्रत्येक सरणी प्रवेश के लिए v, +23प्रत्येक सरणी के लिए। लगभग (2.55*total length of input)या 33837नमूने के इनपुट के लिए, अगर मैंने चीजों को सही किया।

sकमांड के संबंध में एक ही बिल्ड में पेश किए गए साइड इफेक्ट्स के कारण मेरे अपेक्षित अंतिम कार्यक्रम में मामूली बदलाव किए गए थे , हालांकि इससे एक ही समय में बेहतर स्कोर प्राप्त हुआ।