तारों वाली मेटगाल्फ

Question

Starry एक मज़ेदार गूढ़ प्रोग्रामिंग भाषा है जिसमें कोड केवल उसी जगह होता है +*.,`'जहाँ उन वर्णों में से प्रत्येक के द्वारा दर्शाया गया वास्तविक कमांड उसके सामने रिक्त स्थान की संख्या से निर्धारित होता है। यह गोल्फ-आउटपुट चुनौतियों को भी मुश्किल बना देता है, क्योंकि विभिन्न कमांड बाइट्स की अलग-अलग संख्याओं के लिए जिम्मेदार हो सकते हैं। विशेष रूप से, संख्या शाब्दिक में एक अभिन्न प्रतिनिधित्व होता है जो छोटे लोगों पर काम करके बड़ी संख्या का निर्माण करना आवश्यक बनाता है।

इसलिए, यह चुनौती एक कार्यक्रम लिखने के बारे में है जो इस तरह के स्टाररी कार्यक्रमों को गोल्फ कर सकती है।

तारों से काम कैसे चलता है?

(कुछ विवरणों को एसोलैंग्स पर अनिर्दिष्ट छोड़ दिया गया है, इसलिए मैं रूबी दुभाषिया के व्यवहार के साथ जा रहा हूं ।)

Starry एक स्टैक-बेस्ड लैंग्वेज है, जिसमें सिंगल स्टैक ऑफ़ आर्बिटिस-प्रिसिजन इंटीजर वैल्यूज़ (जो शुरू में खाली है) है।

केवल सार्थक वर्ण हैं:

+*.,`'

और रिक्त स्थान। अन्य सभी पात्रों को अनदेखा किया जाता है। उन गैर-अंतरिक्ष वर्णों में से एक के बाद रिक्त स्थान का प्रत्येक क्रम एक एकल निर्देश का प्रतिनिधित्व करता है। निर्देश का प्रकार गैर-अंतरिक्ष वर्ण और रिक्त स्थान की संख्या पर निर्भर करता है ।

निर्देश हैं:

Spaces  Symbol  Meaning
0         +     Invalid opcode.
1         +     Duplicate top of stack.
2         +     Swap top 2 stack elements.
3         +     Rotate top 3 stack elements. That is, send the top stack element
                two positions down. [... 1 2 3] becomes [... 3 1 2].
4         +     Pop and discard top of stack.
n ≥ 5     +     Push n − 5 to stack.
0 mod 5   *     Pop y, pop x, push x + y.
1 mod 5   *     Pop y, pop x, push x − y.
2 mod 5   *     Pop y, pop x, push x * y.
3 mod 5   *     Pop y, pop x, push x / y, rounded towards -∞.
4 mod 5   *     Pop y, pop x, push x % y. The sign of the result matches the sign of y.
0 mod 2   .     Pop a value and print it as a decimal number.
1 mod 2   .     Pop a value and print it as an ASCII character. This throws an error
                if the value is not in the range [0, 255].
n         `     Mark label n.
n         '     Pop a value; if non-zero, jump to label n. 

ध्यान दें कि निष्पादन शुरू होने से पहले दुभाषिया लेबल के लिए स्रोत कोड को स्कैन करता है, इसलिए आगे और पीछे कूदना संभव है।

बेशक, Starry में भी इनपुट कमांड्स ( ,अनुरूप रूप से .) का उपयोग किया गया है , लेकिन वे इस चुनौती के लिए अप्रासंगिक हैं।

चुनौती

एक स्ट्रिंग को देखते हुए, एक तारों वाला प्रोग्राम उत्पन्न करें जो कोई इनपुट नहीं लेता है और उस स्ट्रिंग को बिल्कुल STDOUT में प्रिंट करता है।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले रहे हैं और STDOUT (या निकटतम विकल्प), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम लिख सकते हैं।

आप मान सकते हैं कि स्ट्रिंग 128 वर्णों से अधिक लंबी नहीं है और इसमें केवल मुद्रण योग्य ASCII वर्ण (कोड अंक 0x20 से 0x7E) शामिल होंगे।

आपके समाधान को किसी उचित डेस्कटॉप मशीन पर 5 मिनट से कम समय में किसी भी ऐसे इनपुट को संसाधित करना चाहिए (इसमें कुछ लेवे है; यदि यह मेरे लैपटॉप पर कुछ मिनट अधिक लेता है तो मुझे कोई आपत्ति नहीं है, लेकिन अगर यह 15 साल का है, तो मैं इसे अयोग्य घोषित कर दूंगा। यह)।

आपके समाधान को नीचे सूचीबद्ध कई अलग-अलग तारों पर परीक्षण किया जाएगा। आपका स्कोर संबंधित तारों के कार्यक्रमों की कुल बाइट गिनती है। एक टाई के मामले में, सबसे छोटा metagolfer जीतता है। यही है, जब तक कि कोई टाई नहीं है, तब तक अपने स्वयं के कोड को परेशान न करें (जो मुझे लगता है कि केवल इस मामले में होगा कि एक इष्टतम समाधान संभव है)।

आपको नीचे सूचीबद्ध विशिष्ट परीक्षण मामलों के लिए अपने कोड का अनुकूलन नहीं करना चाहिए। विशेष रूप से, आपको उनके लिए हाथ से तैयार किए गए समाधानों को हार्डकोड नहीं करना चाहिए। स्ट्रिंग्स के वर्गों के प्रति अनुकूलन जिनकी संरचना दिए गए स्ट्रिंग्स के समान है, ठीक है। अगर मुझे किसी हार्डकॉडिंग समाधान पर संदेह है, तो मैं कुछ या सभी परीक्षण मामलों (तुलनीय संरचनाओं के तार के साथ) को बदलने का अधिकार सुरक्षित रखता हूं।

परीक्षण के मामलों

प्रत्येक पंक्ति एक अलग परीक्षण मामला है:

Hello, World!
pneumonoultramicroscopicsilicovolcanoconiosis
.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.
Hickory, dickory, dock. The mouse ran up the clock. The clock struck 1. The mouse ran down. Hickory, dickory, dock.
36912059868043514648560046917066768694455682545071266675083273015450033938555319356951628735735013250100789433961153496780296165
bVZ48121347GLtpYnt76CZSxTpMDs6791EJE808077eySXldY162424ddTB90707UupwlWGb63618542VhA252989453TXrWgqGm85899uHOAY2oAKE198GOVUttvW63
7MYxoWBNt180CDHS5xBGvU70HHVB17bh8jYzIIiU6n6g98Rose1nOe8Svcg56nax20q30kT3Ttb2jHl5q2Iuf1vPbjPxm9cyKXwxc0OUK8pr13b2n7U9Y7RwQTc26A1I
n9}unwxVa}[rj+5em6K#-H@= p^X/:DS]b*Jv/_x4.a5vT/So2R`yKy=in7-15B=g _BD`Bw=Z`Br;UwwF[{q]cS|&i;Gn4)q=`!G]8"eFP`Mn:zt-#mfCV2AL2^fL"A

_{दूसरे टेस्ट केस का श्रेय डेनिस को जाता है । चौथे टेस्ट केस का श्रेय Sp3000 को जाता है।}

संदर्भ समाधान

यहाँ CJam में वास्तव में बुनियादी संदर्भ समाधान है:

q{S5*\iS*'+S'.}%

आप इसे पूरे टेस्ट सूट के खिलाफ यहां चला सकते हैं। स्कोर हैं:

1233
5240
4223
11110
7735
10497
11524
11392
Total: 62954

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

मेरा मानना ​​है कि सुधार की बहुत गुंजाइश है। संदर्भ के लिए, सबसे छोटा दस्तकारी "हैलो, वर्ल्ड!" केवल 169 बाइट्स लंबी है।

Answer 1

रूबी, 13461 10997

$s = {};
def shortest a,b=nil
    return $s[[a,b]] if $s[[a,b]]
    l = []
    if b
        if a == b
            return $s[[a,b]] = ""
        elsif a > b
            l.push shortest(a-b)+" *"
            l.push " +   *"+shortest(1,b) if a > 1
            l.push " + *"+shortest(0,b) if a > 0
            l.push "    +"+shortest(b)
        elsif a < b
            l.push " +  *"+shortest(a*a,b) if a*a>a && a*a<=b
            l.push " +*"+shortest(a+a,b) if a+a<=b && a+a>a
            l.push shortest(b-a)+"*"
            l.push " +"+shortest(a,b/a)+"  *" if a>2 && b%a == 0
            l.push " +"+shortest(a,b-a)+"*" if a>1 && b>a*2
        end
    else
        l.push ' '*(a+5)+'+' #if a < 6
        (1..a/2).each {|n|
            l.push shortest(n)+shortest(n,a)
        }
    end
    return $s[[a,b]] = l.min_by{|x|x.length}
end

def starry(str)
    arr = str.bytes.map{|b|
        if b>47 && b<58
            b-48# change digets to numbers
        else
            b
        end
    }

    startNum = (1..128).min_by{|x|arr.inject{|s,y|s + [shortest(x,y).length+2,shortest(y).length].min}+shortest(x).length}
    #one number to be put on the stack at the start.

    code = shortest(startNum)
    code += [
        shortest(arr[0]),
        " +"+shortest(startNum, arr[0])
    ].min_by{|x|x.length}

    arr.each_cons(2) do |a|
        pr = a[0]<10?'.':' .'
        code += [
            pr+shortest(a[1]),
            " +"+pr+shortest(a[0], a[1]),
            pr+" +"+shortest(startNum, a[1])
        ].min_by{|x|x.length}
    end
    code += arr[-1]<10?'.':' .'
end

a = ["Hello, World!",
"pneumonoultramicroscopicsilicovolcanoconiosis",
".oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.",
"Hickory, dickory, dock. The mouse ran up the clock. The clock struck 1. The mouse ran down. Hickory, dickory, dock.",
"36912059868043514648560046917066768694455682545071266675083273015450033938555319356951628735735013250100789433961153496780296165",
"bVZ48121347GLtpYnt76CZSxTpMDs6791EJE808077eySXldY162424ddTB90707UupwlWGb63618542VhA252989453TXrWgqGm85899uHOAY2oAKE198GOVUttvW63",
"7MYxoWBNt180CDHS5xBGvU70HHVB17bh8jYzIIiU6n6g98Rose1nOe8Svcg56nax20q30kT3Ttb2jHl5q2Iuf1vPbjPxm9cyKXwxc0OUK8pr13b2n7U9Y7RwQTc26A1I",
"n9}unwxVa}[rj+5em6K#-H@= p^X/:DS]b*Jv/_x4.a5vT/So2R`yKy=in7-15B=g _BD`Bw=Z`Br;UwwF[{q]cS|&i;Gn4)q=`!G]8\"eFP`Mn:zt-#mfCV2AL2^fL\"A"]
c = a.map{
    |s|
    starry(s).length
}
p c.inject(0){|a,b|a+b}

विधि starryदिए गए प्रश्न का उत्तर देती है।

परिणाम:

230
639
682
1974
1024
1897
2115
2436
Total: 10997

यह काम किस प्रकार करता है

shortestमुख्य एल्गोरिथ्म है। यह एक नंबर लेता है और इसे स्टैक पर रखने के लिए सबसे छोटा तरीका ढूंढता है, या इसे दो नंबर लगते हैं, और स्टैक पर दूसरा लगाने के लिए कोड देता है, यह मानते हुए कि पहले से ही है। $sआगे के उपयोग के लिए इन परिचालनों के परिणामों को रखने के लिए एक हैश है।

starryएक स्ट्रिंग लेता है और इसे वर्ण कोड (या डिजीज के लिए नंबर) की एक सरणी में विभाजित करता है। यह स्टैक के नीचे एक नंबर के साथ कोड शुरू करता है। इसके बाद यह सबसे छोटे तरीके की गणना करता है जिससे यह प्रत्येक क्रमिक संख्या उत्पन्न कर सकता है, संभवतः पिछले एक को कॉपी कर रहा है या शुरुआत में स्टैक पर लगाए गए नंबर का उपयोग कर रहा है।

Answer 2

पायथन 3, 17071 11845

from functools import lru_cache
import heapq
import time

cases = r"""
Hello, World!
pneumonoultramicroscopicsilicovolcanoconiosis
.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.
Hickory, dickory, dock. The mouse ran up the clock. The clock struck 1. The mouse ran down. Hickory, dickory, dock.
36912059868043514648560046917066768694455682545071266675083273015450033938555319356951628735735013250100789433961153496780296165
bVZ48121347GLtpYnt76CZSxTpMDs6791EJE808077eySXldY162424ddTB90707UupwlWGb63618542VhA252989453TXrWgqGm85899uHOAY2oAKE198GOVUttvW63
7MYxoWBNt180CDHS5xBGvU70HHVB17bh8jYzIIiU6n6g98Rose1nOe8Svcg56nax20q30kT3Ttb2jHl5q2Iuf1vPbjPxm9cyKXwxc0OUK8pr13b2n7U9Y7RwQTc26A1I
n9}unwxVa}[rj+5em6K#-H@= p^X/:DS]b*Jv/_x4.a5vT/So2R`yKy=in7-15B=g _BD`Bw=Z`Br;UwwF[{q]cS|&i;Gn4)q=`!G]8"eFP`Mn:zt-#mfCV2AL2^fL"A
""".strip().splitlines()

@lru_cache(maxsize=128)
def shortest_m_to_n(m, n):
    if m is None:
        L = []
    else:
        L = [m]

    to_search = [[0, "", L]]
    seen = set()

    while True:
        length, code, stack = heapq.heappop(to_search)

        if len(stack) == 1 and stack[-1] == n:
            return code

        seen.add(tuple(stack))
        options = []

        for i in range(1, 11):
            new_stack = stack[:] + [i]
            new_code = code + ' '*(i+5) + '+'
            options.append([len(new_code), new_code, new_stack])

        if stack:
            new_stack = stack[:] + [stack[-1]]
            new_code = code + " +"
            options.append([len(new_code), new_code, new_stack])

        if len(stack) >= 2:
            x, y = stack[-2:]

            for i, op in enumerate(['+', '-', '*', '//', '%']):
                try:
                    new_elem = eval("{}{}{}".format(x, op, y))
                    new_stack = stack[:-2] + [new_elem]
                    new_code = code + ' '*i + '*'
                    options.append([len(new_code), new_code, new_stack])

                except ZeroDivisionError:
                    pass

        for op in options:
            if tuple(op[2]) in seen or len(op[2]) > 4 or op[2][-1] > 200:
                continue

            heapq.heappush(to_search, op)

def lcs(s1, s2):
    dp_row = [""]*(len(s2)+1)

    for i, c1 in enumerate(s1):
        new_dp_row = [""]

        for j, c2 in enumerate(s2):
            if c1 == c2 and not c1.isdigit():
                new_dp_row.append(dp_row[j] + c1)
            else:
                new_dp_row.append(max(dp_row[j+1], new_dp_row[-1], key=len))

        dp_row = new_dp_row

    return dp_row[-1]

def metagolf(s):
    keep = ""
    split_index = 0

    for i in range(1, len(s)):
        l = lcs(s[:i], s[i:][::-1])
        if len(l) > len(keep):
            keep = l
            split_index = i

    code = []
    stack = []
    keep_ptr = 0
    i = 0

    while i < len(s):
        c = s[i]
        n = ord(c)

        if c in "0123456789":
            code += [" "*(int(c)+5) + "+."]
            i += 1
            continue

        if stack:
            if stack[-1] == n:
                code += [" +", " ."]
            elif len(stack) >= 2 and stack[-2] == n:
                for j in range(len(code)):
                    if code[~j] == " +":
                        code[~j] = ""
                        break

                code += [" +", " ."]
                stack.pop()
            else:
                code += [shortest_m_to_n(stack[-1], n), " +", " ."]
                stack[-1] = n

        else:
            code += [shortest_m_to_n(None, n), " +", " ."]
            stack.append(n)

        while i < split_index and keep[keep_ptr:][:1] == c:
            code += [" +"]
            keep_ptr += 1
            stack.append(n)

        i += 1

    code = "".join(code)

    if code[-4:] == " + .":
        code = code[:-4] + " ."

    return code

total = 0

for case in cases:
    start_time = time.time()

    s = metagolf(case)
    print(len(s), time.time() - start_time)
    total += len(s)
    print(s)
    print('='*50)

print(total)

प्रासंगिक कार्य को उपयुक्त नाम दिया गया है metagolf।

परिणाम हैं:

210
676
684
2007
1463
2071
2204
2530
Total: 11845

आप यहाँ पूर्ण आउटपुट पा सकते हैं ।

संक्षिप्त विवरण

मैं स्पष्टीकरण को संक्षिप्त रखने जा रहा हूं क्योंकि अभी भी कई चीजों को सुधारना है।

बुनियादी एल्गोरिथ्म सिर्फ चार के जोड़े को देखता है, और बीएफएस के माध्यम से एक चार से दूसरे में संक्रमण करने का इष्टतम तरीका पाता है। वर्तमान में अंकों को धक्का दिया जाता है और तुरंत मुद्रित किया जाता है, हालांकि इसे बाद में बदल दिया जाएगा।

बाद में पुन: उपयोग के लिए स्टैक पर कुछ तत्वों को छोड़ने के लिए थोड़ा लंबा-सामान्य-लेटरेन्स चल रहा है। यह पुनरावृत्ति के रूप में अच्छा नहीं है, लेकिन सभ्य बचत प्रदान करता है।

Comments

हुर्रे, किसी से लड़ाई :-) बेशक, अब मैं देखता हूं कि मेरा एक लंबा रास्ता तय करना है ...

— ETHproductions

Answer 3

जावास्क्रिप्ट, 25158 23778

अब ES5- संगत!

String.prototype.repeat = String.prototype.repeat || function (n) { return Array(n+1).join(this); }

function starrify(x) {
  function c(x){return x.charCodeAt()}
  var char = x[0], result = ' '.repeat(c(char)+5)+'+ + .';
  x=x.slice(1);
  for(var i in x) {
    if (char < x[i]) {
      result += ' '.repeat(c(x[i])-c(char)+5)+'+* + .';
    } else if (char > x[i]) {
      if(c(char)-c(x[i]) < c(x[i])) {
        result += ' '.repeat(c(char)-c(x[i])+5)+'+ * + .';
      } else {
        result += ' '.repeat(c(x[i])+5)+'+ + .';
      }
    } else {
      result += ' + .';
    }
    char = x[i];
  }
  return result;
}

परिणाम:

432
949
2465
3996
1805
3551
5205
5375
Total: 23778

मेरी राय में एक अच्छी शुरुआत, लेकिन स्पष्ट रूप से समाप्त नहीं हुई। प्रत्येक चार्ट को अलग से बनाने के बजाय, यह पिछले चार कोड से जोड़ता या घटाता है। जब मैं मेटा-गोल्फिंग कर रहा हूँ तो मैं एक पूर्ण विवरण जोड़ूँगा।

Comments

हां, यह फ़ायरफ़ॉक्स में अब काम करता है, हालांकि क्रोम अभी भी इसके बारे में शिकायत करता है charCodeAt।

— मार्टिन एंडर