एक प्रोग्रामिंग भाषा बनाएं जो केवल अनुपयोगी प्रतीत होती है


85

लुटेरों का चुनौती धागा यहाँ है

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

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

यह एक लोकप्रियता प्रतियोगिता है। क्रॉपर्स का लक्ष्य है कि इंटरप्रेटर को बिना दरार किए पोस्ट करने के 8 दिन बाद तक जीवित रहते हुए अधिक से अधिक वोट प्राप्त करना। इसके लिए, निम्नलिखित प्रथाओं को मदद करनी चाहिए:

  • आपकी भाषा के शब्दार्थों की सटीक व्याख्या करना
  • पठनीय कोड लिखना

निम्नलिखित रणनीति दृढ़ता से हतोत्साहित हैं:

  • एन्क्रिप्शन, हैश या अन्य क्रिप्टोग्राफ़िक विधियों का उपयोग करना। यदि आप ऐसी भाषा देखते हैं जो RSA एन्क्रिप्शन को नियोजित करती है, या किसी प्रोग्राम को निष्पादित करने से इंकार करती है, जब तक कि उसका SHA-3 हैश 0x1936206392306 के बराबर न हो, कृपया नीचे उतरने में संकोच न करें।

लुटेरों की चुनौती: एक प्रोग्राम लिखें जो कि पुलिस के इंटरप्रेटर में चलने पर इनपुट में तीसरा सबसे बड़ा पूर्णांक पाता है।

यह एक अपेक्षाकृत सीधा है। एक पुलिस जवाब को क्रैक करने के लिए, आपको एक प्रोग्राम बनाना होगा जो अपने दुभाषिया में चलने पर कार्य पूरा करता है। जब आप कोई उत्तर क्रैक करते हैं, तो एक टिप्पणी पोस्ट करते हुए कहते हैं कि "क्रैकड" पुलिस के उत्तर को आपकी पोस्ट से जोड़ रहा है। जो कोई भी सबसे अधिक दरार करता है वह लुटेरों के धागे को जीतता है।

मैं / हे नियम

  • दुभाषियों को प्रोग्राम के लिए कमांड लाइन पर एक फ़ाइल नाम लेना चाहिए, और इसे चलाते समय मानक इनपुट और आउटपुट का उपयोग करना चाहिए।
  • इनपुट यूनीरी में दिया जाएगा और इसमें केवल अक्षर होंगे 0और 1(ASCII में 48 और 49)। एक संख्या N एन के रूप में एन के 1s बाद एनकोडेड है 00फ़ाइल के अंत से पहले एक अतिरिक्त है । उदाहरण: अनुक्रम के लिए (3, 3, 1, 14), इनपुट है 11101110101111111111111100
  • इनपुट में कम से कम 3 नंबर होने की गारंटी है। सभी संख्याएँ पूर्णांक हैं।
  • आउटपुट को 1कार्यक्रम के रुकने से पहले छपे एस की संख्या से आंका जाएगा । अन्य पात्रों को नजरअंदाज किया जाता है।

निम्नलिखित उदाहरणों में, पहली पंक्ति दशमलव प्रारूप में इनपुट है; दूसरा वास्तविक कार्यक्रम इनपुट है; तीसरा एक नमूना आउटपुट है।

1, 1, 3
101011100
1

15, 18, 7, 2, 15, 12, 3, 1, 7, 17, 2, 13, 6, 8, 17, 7, 15, 11, 17, 2
111111111111111011111111111111111101111111011011111111111111101111111111110111010111111101111111111111111101101111111111111011111101111111101111111111111111101111111011111111111111101111111111101111111111111111101100
111111,ir23j11111111111u

247, 367, 863, 773, 808, 614, 2
<omitted>
<contains 773 1's>

पुलिस जवाब के लिए बोरिंग नियम:

  • अस्पष्टता के माध्यम से सुरक्षा को रोकने के लिए, दुभाषिया को इस TIOBE सूचकांक के शीर्ष 100 में एक भाषा में लिखा जाना चाहिए और एक स्वतंत्र रूप से उपलब्ध संकलक / दुभाषिया होना चाहिए।
  • दुभाषिया को उस भाषा की व्याख्या नहीं करनी चाहिए जो इस चुनौती से पहले प्रकाशित हुई थी।
  • दुभाषिया को आपकी पोस्ट में फिट होना चाहिए और बाहरी रूप से होस्ट नहीं किया जाना चाहिए।
  • दुभाषिया निर्धारक होना चाहिए
  • दुभाषिया पोर्टेबल होना चाहिए और अपनी भाषा के मानक का पालन करना चाहिए; अपरिभाषित व्यवहार या बग का उपयोग न करें
  • यदि समाधान कार्यक्रम उत्तर में फिट होने के लिए बहुत लंबा है, तो आपको एक प्रोग्राम पोस्ट करना होगा जो इसे उत्पन्न करता है।
  • समाधान कार्यक्रम में केवल मुद्रण योग्य ASCII और newlines शामिल होना चाहिए।
  • ऊपर दिए गए प्रत्येक उदाहरण इनपुट के लिए आपको अपने स्वयं के कंप्यूटर पर 1 घंटे से कम समय में अपने समाधान कार्यक्रम को निष्पादित करना होगा।
  • कार्यक्रम को किसी भी पूर्णांकों के लिए १० से कम और किसी भी संख्या में पूर्णांकों की संख्या १० से कम (एक घंटे से कम नहीं) में काम करना चाहिए, बशर्ते कि कुल इनपुट लंबाई १० से कम हो
  • सुरक्षित बनने के लिए, एक सिपाही को समाधान कार्यक्रम को 8 दिनों के बाद जवाब में संपादित करना होगा।

स्कोरिंग

पुलिस वाला जो उच्चतम स्कोर के साथ सुरक्षित हो जाता है, और एक सकारात्मक स्कोर, इस प्रश्न को जीतता है।


आप स्पष्ट रूप से यह नहीं बताते हैं, लेकिन क्या मैं यह मानने में सही हूं कि पुलिस को वास्तव में अपने उत्तर में दुभाषिया लिखना और पोस्ट करना है?
ब्लू

@ मुंडीफिश हां, दुभाषिया पुलिस के जवाब की सामग्री होनी चाहिए।
feersum

1
@ kirbyfan64sos आउटपुट को तब तक देखा जाएगा जब प्रोग्राम
mbomb007


20
मैंने इस चुनौती से खुद को निपटाया। मैंने एक प्रोग्रामिंग लैंग्वेज बनाई और फिर घंटों प्रोग्रामिंग का काम किया, यह देखने के लिए कि क्या भाषा केवल यह पता लगाने के लिए भी काम कर सकती है कि यह वास्तव में अनुपयोगी है।
१२

जवाबों:


24

चेंजलिंग (सुरक्षित)

ShapeScript

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

शेपस्क्रिप्ट एक अपेक्षाकृत सरल वाक्य रचना के साथ एक स्टैक-आधारित भाषा है। अप्रत्याशित रूप से, इसके अधिकांश बिल्ट-इन स्ट्रिंग्स के आकार को बदलने के साथ निर्मित होते हैं। इसकी व्याख्या, चरित्र द्वारा चरित्र, निम्नानुसार है:

  • 'और "एक स्ट्रिंग शाब्दिक शुरू करते हैं।

    जब तक मेल खाने वाला उद्धरण स्रोत कोड में नहीं मिलता है, तब तक इन मिलान उद्धरणों के बीच सभी वर्ण एक स्ट्रिंग में एकत्र किए जाते हैं, जो तब स्टैक पर धकेल दिया जाता है।

  • 0स्टैक पर 9पूर्णांक 0 से 9 पुश करने के लिए । ध्यान दें कि दो पूर्णांक को 10धकेलता है ।

  • ! स्टैक से एक स्ट्रिंग पॉप करता है, और इसे शेपस्क्रिप्ट के रूप में मूल्यांकन करने का प्रयास करता है।

  • ? स्टैक से एक पूर्णांक बनाता है, और उस इंडेक्स पर स्टैक आइटम की एक प्रति धक्का देता है।

    इंडेक्स 0 सबसे ऊपरी स्टैक आइटम (LIFO) और इंडेक्स -1 से नीचे-सबसे एक से मेल खाता है।

  • _ स्टैक से एक चलने योग्य चबूतरे, और इसकी लंबाई धक्का।

  • @ स्टैक से दो आइटम पॉप करता है, और उन्हें उलटा क्रम में धकेलता है।

  • $स्टैक से दो स्ट्रिंग्स को पॉप करता है, और सबसे ऊपरी एक की घटनाओं पर नीचे-सबसे एक को विभाजित करता है। परिणामी सूची बदले में धकेल दी जाती है।

  • &एक स्ट्रिंग (सबसे ऊपर) और स्टैक से एक चलने योग्य चबूतरे, और विभाजक के रूप में स्ट्रिंग का उपयोग करके, पुनरावृति में शामिल होता है। परिणामस्वरूप स्ट्रिंग बदले में धकेल दिया जाता है।

  • यदि हमारे ग्रह पर शेपस्क्रिप्ट का उपयोग किया जाता है, क्योंकि अजगर पृथ्वी पर निकटतम रिश्तेदार हैं, तो अन्य सभी अक्षर c दो पॉप x और y (सबसे ऊपरी), स्टैक से, और पायथन कोड का मूल्यांकन करने का प्रयास करते हैं x c y

    उदाहरण के लिए, वर्णों का अनुक्रम 23+मूल्यांकन करेगा 2+3, जबकि वर्णों का अनुक्रम "one"3*मूल्यांकन करेगा 'one'*3, और वर्णों का अनुक्रम 1''Aमूल्यांकन करेगा 1A''

    अंतिम स्थिति में, चूंकि परिणाम वैध पायथन नहीं है, इसलिए चेंजलिंग शिकायत करेगा कि उसका वर्तमान आकार अप्रमाणित है (सिंटैक्स त्रुटि), क्योंकि यह मान्य शेपस्क्रिप्ट नहीं है।

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

आकार बदल रहा है

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

सभी पात्र परिवर्तन के निम्नलिखित प्राकृतिक रूप हैं:

  • सभी पंक्तियों में वर्णों की संख्या समान होनी चाहिए।

  • सभी पंक्तियों में मुद्रण योग्य ASCII वर्णों का समावेश होना चाहिए, इसके बाद एक ही लाइनफीड।

  • लाइनों की संख्या प्रति लाइन मुद्रण योग्य वर्णों की संख्या से मेल खाना चाहिए।

उदाहरण के लिए, बाइट अनुक्रम ab\ncd\nएक पात्र चांगलिंग है।

शेपस्क्रिप्ट में शिफ्ट करने के अपने प्रयास में, चेंजलिंग निम्नलिखित परिवर्तन से गुजरती है:

  • प्रारंभ में, कोई स्रोत कोड नहीं है।

  • प्रत्येक पंक्ति के लिए निम्नलिखित होता है:

    • चांगलिंग का संचायक शून्य पर सेट है।

    • लाइन के प्रत्येक वर्ण c (अनुगामी लाइनफीड सहित), c का कोड बिंदु लाइनफीड का XORed है जो 2 से विभाजित संचयकर्ता के साथ है, और परिणामस्वरूप कोड बिंदु से मेल खाता यूनिकोड वर्ण स्रोत कोड से जुड़ा हुआ है।

      बाद में, सी के कोड बिंदु और एक स्थान के कोड बिंदु के बीच का अंतर (32) संचायक में जोड़ा जाता है।

यदि उपरोक्त में से कोई भी भाग विफल हो जाता है, तो चेंजलिंग शिकायत करेगा कि इसका वर्तमान आकार अप्रिय है।

सभी लाइनों के संसाधित होने के बाद, चेंजलिंग का परिवर्तन (उम्मीद के मुताबिक वैध) शेपस्क्रिप्ट पूरा हो गया है, और परिणामस्वरूप कोड निष्पादित किया गया है।

समाधान (आकृतिलेख)

"0"@"0"$"0"2*&"0"@+0?_'@1?"0"$_8>"1"*+@1?"0"+$""&'*!#

आकृतिलेख वास्तव में काफी प्रयोग करने योग्य निकला; यह भी primality परीक्षण ( सबूत) कर सकते हैं ) कर सकता है और इसलिए प्रोग्रामिंग भाषा की हमारी परिभाषा को संतुष्ट करता है।

मैंने GitHub पर ShapeScript को थोड़ा संशोधित सिंटैक्स और बेहतर I / O के साथ फिर से प्रकाशित किया है।

कोड निम्नलिखित करता है:

"0"@    Push "0" (A) and swap it with the input string (S).
"0"$    Split S at 0's.
"0"2*   Push "00".
&       Join the split S, using "00" as separator.
"0"@+   Prepend "0" to S.
        The input has been transformed into
        "0<run of 1's>000<run of 1's>0...0<run of 1's>0000".
0?_     Push a copy and compute its length (L).
'       Push a string that, when evaluated, does the following:
  @1?     Swap A on top of S, and push a copy of S.
  "0"$    Split the copy of S at 0's.
  _8>     Get the length of the resulting array and compare it with 8.
          If this returns True, there are more than eight chunks, so there are
          more then seven 0's. With two 0's surrounding each run of 1's and
          three extra 0's at the end, this means that there still are three or
          more runs of 1's in the string.
  "1"*    Push "1" if '>' returned True and "" if it returned False.
  +       Append "1" or "" to A.
  @1?     Swap S on top of A, and push a copy of A.
  "0"+    Append "0" to the copy of A.
  $       Split S at occurrences of A+"0".
  ""&     Flatten the resulting array of strings.
'       This removes all occurrences of "010" in the first iteration, all
        occurrences of "0110" in the second, etc., until there are less than
        three runs of 1's left in S. At this point, A is no longer updated,
        and the code inside the string becomes a noop.
*!      Repeat the code string L times and evaluate.
#       Drop S, leaving only A on the stack.

समाधान (चेंजलिंग)

"1+-.......................
""B1.......................
"" 2)+7....................
"" 2)=<....................
""( $86=...................
""B8=......................
""247......................
""]`b......................
""B1.......................
""%D1=.....................
""%500=....................
""%&74?....................
""%&#.2....................
""%[bdG....................
""%D1=.....................
""%<5?.....................
""%:6>.....................
""%&65?....................
""%&-%7>...................
""%D1=.....................
""%500=....................
""%&74?....................
""%&,)5>...................
""%&%,79...................
"" )$?/=...................
""),-9=....................
""# !......................

सभी चेंजलिंग कार्यक्रमों की तरह, इस कोड में एक अनुगामी लाइनफीड है।

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

इसके अलावा, हमें तीन छोटी बाधाओं को दूर करना होगा:

  • शेपस्क्रिप्ट कोड में लंबा स्ट्रिंग एक एकल टोकन है, और हम इसे एक पंक्ति में फिट नहीं कर पाएंगे।

    हम मात्रा (में इस स्ट्रिंग धक्का होगा '@', '1?'आदि) है, जो हम बाद में जोड़ देंगे।

  • के कोड बिंदु _बल्कि उच्च है, और धक्का '_'समस्याग्रस्त हो जाएगा।

    हालाँकि, हम स्वैप को पूर्ववत् करने के लिए '_@'सहजता से आगे बढ़ने में सक्षम होंगे '@'

आकृति परिवर्तन कोड हमारी चांग्लिंग उत्पन्न करेगा ऐसा दिखता है 1 :

"0""
"#@"
"#"0"$"
"#"0"2"
"#*&"0""
"#@+"
"#0?"
"#_@"
"#@"
"#'@'"
"#'1?'"
"#'"0'"
"#'"$'"
"#'_@'"
"#'@'"
"#'8'"
"#'>'"
"#'"1'"
"#'"*+'"
"#'@'"
"#'1?'"
"#'"0'"
"#'"+$'"
"#'""&'"
"#"+"77"
"#+*!*"
"#!#"

मैंने इस कनवर्टर के माध्यम से उपरोक्त शेपस्क्रिप्ट कोड को चलाकर चांगलिंग कोड पाया । 2

दुभाषिया (पायथन 3)

#!/usr/bin/env python3

import fileinput

def error(code):
  print("This shape is " + ["unpleasant", "unpurposed", "inadequate"][code - 1] + ".")
  exit(code)

def interpret(code):
  global stack
  stringing = 0
  for char in code:
    quote = (char == "'") + 2 * (char == '"')
    if quote or stringing:
      if not stringing:
        string = ""
        stringing = quote
      elif stringing == quote:
        stack.append(string)
        stringing = 0
      else:
        string += char
    elif char in "0123456789":
      stack.append(int(char))
    else:
      x = stack.pop()
      if char == '!':
        interpret(x)
      else:
        if char == '?':
          y = stack[~x]
        elif char == "_":
          y = len(x)
        else:
          y = stack.pop()
          if char == '@':
            stack.append(x)
          elif char == '$':
            y = y.split(x)
          elif char == '&':
            y = x.join(map(str, y))
          else:
            try:
              y = eval(repr(y) + char + repr(x))
            except SyntaxError:
              error(2)
        stack.append(y)

source = ""
lengths = []

for line in fileinput.input():
  if not line or sorted(line)[:2][-1] < " " or max(line) > "~":
    error(1)
  lengths.append(len(line))
  accumulator = 0
  for char in line:
    value = ord(char)
    try:
      source += chr(value ^ (accumulator >> 1))
    except:
      error(1)
    accumulator += value - 32

lengths.append(len(lengths) + 1)

if min(lengths) != max(lengths):
  error(1)

stack = ""

for line in fileinput.input("-"):
  stack += line

stack = [stack]

try:
  interpret(source)
except:
  error(3)

print("".join(map(str, stack)))

1 प्रत्येक पंक्ति को यादृच्छिक कचरा के साथ लाइनों की मात्रा में गद्देदार किया जाता है, और लाइनफ़ीड वास्तव में मौजूद नहीं हैं।
2 नीचे की ओर की संख्या चांगलिंग कोड में सबसे कम और उच्चतम कोड बिंदु दर्शाती है, जिसे 32 और 126 के बीच रहना चाहिए।


1
-1 एक्सोर / ट्रांसफॉर्मेशन के उपयोग के लिए। शेपस्क्रिप्ट रूपांतरण की चेंजिंग मुझे एन्क्रिप्शन की तरह लगती है।
मेगाटॉम

10
@MegaTom आप फिट दिखते हुए मतदान कर सकते हैं, लेकिन यह प्रश्न एन्क्रिप्शन पर निर्भर करता है क्योंकि यह एक कुंजी लेता है , एक निरंतर केवल पुलिस को ज्ञात होता है जो लुटेरों को एक महत्वपूर्ण नुकसान में डालता है। रूपांतरण एक गैर- परिवर्तित रूपांतरण है ।
डेनिस

1
शेपस्क्रिप्ट, 67 बाइट्स 0"#002?'+'&'0'$'0?2?-@2?>*+00'&!++'1'*'0'+@1?$0?''&@_2-2?*@+@"3*!@#:। मैंने इसके लिए एक चेंजलिंग खोजने पर छोड़ दिया है, हालांकि। यहां तक कि ज्यादातर बेकार बयानों के साथ बीच-बीच में, मैं नहीं किया है में 20 से अधिक बाइट्स प्राप्त करने में सक्षम हो गया।
Primo

2
@MegaTom मैं वास्तव में दिए गए समाधान से काफी निराश हूं। मैं 92.9% बेकार कोड की तुलना में काफी अधिक चतुर कुछ उम्मीद कर रहा था।
प्रिमो

2
@primo यह थोड़ा और अधिक थकाऊ था, लेकिन मुझे यह चेंजलिंग मिला जो पायथन 2 के साथ भी काम करता है। मुझे नहीं पता कि मेरा उत्तर कितना चतुर है, लेकिन एक पुलिस वाले को खामियों के साथ पोस्ट करने की मेरी योजना को विफल करने के लिए मिल गया था जो लगता है कि यह काम किया है।
डेनिस

30

घसीटना (सी ++ में लिखा गया), फटा! मार्टिन द्वारा

एडिट मार्टिन ने इसे क्रैक किया। उसका समाधान देखने के लिए, लिंक पर क्लिक करें। मेरा समाधान भी जोड़ा गया है।

रजिस्टर और स्टैक दोनों को संभालने में सक्षम होने के लिए फिक्स्ड कमांड को संपादित करें जैसा कि यह एक डीबगिंग कमांड है जिसे किसी समाधान में अनुमति नहीं है, यह दुभाषिया के पिछले संस्करण का उपयोग करके किसी को भी प्रभावित नहीं करना चाहिएprint-d

मैं अभी भी इसके लिए नया हूं, इसलिए यदि मेरे उत्तर या मेरे दुभाषिया में कुछ गड़बड़ है, तो कृपया मुझे बताएं। अगर कुछ स्पष्ट नहीं है तो कृपया स्पष्टीकरण मांगें।

मुझे नहीं लगता कि यह बहुत कठिन होगा, लेकिन उम्मीद है कि यह किसी प्रकार की चुनौती प्रदान करेगा। जो चीज काफी हद तक बेकार हो जाती है, वह केवल तभी छपेगी जब चीजें अपने उचित स्थान पर होंगी।

-> मूल बातें:

24 स्टैक हैं, हम उन्हें कॉल करते हैं stack1, ... stack24। ये ढेर एक सूची में रहते हैं। किसी भी कार्यक्रम की शुरुआत में, इन ढेर शून्य धक्का दिया है और वे उनके उचित स्थान में शुरू करते हैं, यानी ढेर मैं में ith सूची में स्थिति (ध्यान दें कि हम सूचकांक 1 से शुरू होगा सी के विपरीत, ++)। एक कार्यक्रम के दौरान, सूची के भीतर ढेर का क्रम बदल जाएगा।यह उन कारणों के लिए महत्वपूर्ण है जिन्हें मैं कमांड पर चर्चा करते समय समझाया जाएगा।

उपयोग के लिए 5 रजिस्टर उपलब्ध हैं। वे नाम हैं Alberto, Gertrude, Hans, Leopold,ShabbySam । इनमें से प्रत्येक एक कार्यक्रम की शुरुआत में शून्य पर सेट है।

इसलिए, किसी भी कार्यक्रम की शुरुआत में, 24 स्टैक होते हैं, प्रत्येक की संख्या स्टैक सूची में अपने सूचकांक से मेल खाती है। हर स्टैक में शीर्ष पर एक शून्य होता है। पांच रजिस्टरों में से प्रत्येक को शून्य से आरंभ किया गया है।

-> कमांड और सिंटैक्स :

13 कमांड (+1 डिबगिंग कमांड) हैं जो शफल में उपलब्ध हैं। वे इस प्रकार हैं

  • cinpushयह आदेश कोई तर्क नहीं लेता है। यह प्रश्न में वर्णित फैशन में कमांड लाइन इनपुट की प्रतीक्षा करता है (अन्य इनपुट अनिर्दिष्ट / अनिर्धारित परिणामों को जन्म देगा)। यह तब इनपुट स्ट्रिंग को पूर्णांक में विभाजित करता है, जैसे 101011100-> 1,1,3। प्राप्त प्रत्येक इनपुट के लिए, यह निम्न कार्य करता है: (1) मूल्य के आधार पर ढेर की सूची की अनुमति देता है। मान लें कि पूर्णांक मान को प्रश्न कहा जाता है । यदि a 10 से कम है तो यह क्रमपरिवर्तन u करता है । यदि a 9 और 30 के बीच है (गैर-विशिष्ट) तो यह क्रमपरिवर्तन d । अन्यथा यह क्रमपरिवर्तन आर(२) यह तब धक्का देता है aस्टैक पर जो सूची में पहले स्थान पर है। ध्यान दें कि मेरा मतलब नहीं हैstack1(हालांकि यह मामला है कि stack1सूची में पहली बार हो सकता है)। क्रमपरिवर्तन नीचे परिभाषित किए गए हैं। चूंकि cinpushउपयोगकर्ता इनपुट प्राप्त करने का एकमात्र तरीका है , इसे किसी भी समाधान में दिखाई देना चाहिए।
  • mov value registermovआदेश मूल रूप से चर काम है। यह valueकरने के लिए असाइन करता है registervalueकई रूप ले सकते हैं: यह (1) पूर्णांक हो सकता है, उदाहरण के लिए 47 (2) एक अलग रजिस्टर का नाम, उदाहरण के लिए Hans (3) एक स्टैक के सूचकांक के बाद 's', उदा।4s । ध्यान दें कि यह सूची में सूचकांक है, न कि स्टैक की संख्या। जैसे, संख्या 24 से अधिक नहीं होनी चाहिए।

    कुछ movउदाहरण:

    mov 4s Hans 
    mov Hans ShabbySam
    mov 9999 Gertrude
    
  • movfs index registerयह 'स्टैक से मूव' के लिए खड़ा है। यह movकमांड के समान है । यह मौजूद है ताकि आप एक रजिस्टर द्वारा अनुक्रमित ढेर तक पहुंच सकें। उदाहरण के लिए, यदि आप पहले हंस को 4 के बराबर सेट करते हैं ( mov 4 Hansतब) आप movfs Hans Gertrudeगर्ट्रूड को स्टैक के शीर्ष के बराबर सेट करने के लिए उपयोग कर सकते हैं । इस प्रकार का व्यवहार केवल उपयोग करने के लिए सुलभ नहीं है mov

  • inc register 1 से रजिस्टर मूल्य बढ़ाता है।
  • dec register 1 से रजिस्टर मूल्य घटता है।
  • compg value value registerयह 'अधिक से अधिक तुलना' के लिए खड़ा है। यह रजिस्टर को दो मानों से अधिक के बराबर सेट करता है। valueऊपर के रूप में एक पूर्णांक, एक रजिस्टर, या एक स्टैक इंडेक्स 's' द्वारा हो सकता है।
  • compl value value register ऊपर के समान 'कम तुलना करें', छोटे मूल्य को छोड़कर।
  • gte value1 value2 registerजाँचता है कि value1 >= value2तब बूलियन मान (1 या 0 के रूप में) डालता है register
  • POP!! indexindexस्टैक सूची में अनुक्रमित स्टैक के शीर्ष से चबूतरे ।
  • jmp labelलेबल पर बिना शर्त कूदता है label। लेबल के बारे में बात करने के लिए यह एक अच्छा समय है। एक लेबल 'बाद' शब्द है। इंटरप्रेटर लेबल के लिए प्री-पार्स करता है, इसलिए आप लेबल के साथ-साथ पीछे भी कूद सकते हैं।
  • jz value labellabelअगर valueशून्य है तो कूदता है।
  • jnz value labellabelअगर valueनॉनवेज है तो कूदता है ।

    लेबल और जंपिंग के उदाहरण:

    this_is_my_label:
         jmp this_is_my_label
    
    mov 10 Hans
    jnz Hans infinite_loop
    
    infinite_loop:
         jmp infinite_loop
    
  • "shuffle" permutationयहाँ फेरबदल आदेश है। यह आपको ढेर की सूची की अनुमति देता है। तीन वैध क्रमपरिवर्तन हैं जिनका उपयोग तर्कों , और l, के रूप में किया जा सकता है ।fb

  • print registerयह यानी की जाँच करता है कि क्या सभी के ढेर अपने शुरुआती स्थिति में हैं, ढेर मैं सूचकांक पर है मैं ढेर सूची में। यदि ऐसा है, तो यह मूल्य को registerएकात्मकता में छापता है । अन्यथा, यह एक गंदा त्रुटि प्रिंट करता है। जैसा कि आप देख सकते हैं, कुछ भी आउटपुट करने के लिए, स्टैक को सही स्थानों पर होना चाहिए।
  • done!यह प्रोग्राम को बिना किसी त्रुटि के छोड़ने के लिए कहता है। यदि कार्यक्रम के बिना समाप्त होता है done!, तो यह प्रत्येक स्टैक के शीर्ष पर स्थित कंसोल को प्रिंट करेगा, जिसके बाद स्टैक की संख्या होगी। स्टैक्स मुद्रित करने के क्रम में स्टैक सूची में दिखाई देने वाला क्रम है। यदि कोई स्टैक खाली है, तो उसे छोड़ दिया जाएगा। यह व्यवहार डीबगिंग उद्देश्यों के लिए है और इसका उपयोग समाधान में नहीं किया जा सकता है।
  • print-d valueयह दिए गए स्टैक, रजिस्टर या पूर्णांक के मान को प्रिंट करता है (स्टैक i तक पहुंचने के लिए , isतर्क के रूप में पास करें , जैसा कि ऊपर बताया गया है)। यह एक डिबगिंग टूल है और भाषा का हिस्सा नहीं है, क्योंकि यह एक समाधान में अनुमति नहीं है।

-> यहाँ दुभाषिया कोड है

सभी पार्सिंग मुख्य कार्य में होता है। यह वह जगह है जहाँ आप इसे विशिष्ट कमांड के लिए पार्सिंग पाएंगे।

#include<fstream>
#include<iostream>
#include<string>
#include<stack>
#include<cmath>

using namespace std;

class superStack: public stack<long> {
    private:
        int m_place;
    public:
        static int s_index;


        superStack() {
            m_place = s_index;
            s_index++;
        }

        int place() {
            return m_place;
        }
};
int superStack::s_index=1;

superStack  stack1,stack2,stack3,stack4,stack5,stack6,stack7,stack8,stack9,stack10,stack11, \
            stack12,stack13,stack14,stack15,stack16,stack17,stack18,stack19,stack20,stack21,stack22,stack23,stack24;


superStack* stackptrs[]=    { \
                        &stack1,&stack2,&stack3,&stack4,&stack5,&stack6,&stack7,&stack8,&stack9,&stack10,&stack11, \
                        &stack12,&stack13,&stack14,&stack15,&stack16,&stack17,&stack18,&stack19,&stack20,&stack21,&stack22,&stack23,&stack24 \
                        };


long Gertrude=0;
long Hans=0;
long Alberto=0;
long ShabbySam=0;
long Leopold=0;


void SWAP( int i, int j) {    // 0 < i,j < 25

    i--;
    j--;


    superStack* tempptr = stackptrs[i];
    stackptrs[i]=stackptrs[j];
    stackptrs[j] = tempptr;



}

void u() {
    int list[3][4] = {
                        {1,9,6,13},
                        {2,10,5,14},
                        {17,19,20,18},
                    };

    for(int i=0;i<3;i++) {
        for(int j=1;j<4;j++) {
            SWAP( list[i][0], list[i][j] );         
        }
    }
}
void d() {
    int list[3][4] = {
                        {3,11,8,15},
                        {4,12,7,16},
                        {22,24,23,21},
                    };

    for(int i=0;i<3;i++) {
        for(int j=1;j<4;j++) {
            SWAP( list[i][0], list[i][j] );         
        }
    }
}
void r() {
    int list[3][4] = {
                        {2,17,8,24},
                        {4,18,6,23},
                        {9,10,12,11},
                    };

    for(int i=0;i<3;i++) {
        for(int j=1;j<4;j++) {
            SWAP( list[i][0], list[i][j] );         
        }
    }
}
void l() {
    int list[3][4] = {
                        {1,19,7,22},
                        {3,20,5,21},
                        {14,13,15,16},
                    };

    for(int i=0;i<3;i++) {
        for(int j=1;j<4;j++) {
            SWAP( list[i][0], list[i][j] );         
        }
    }
}
void f() {
    int list[3][4] = {
                        {20,9,24,16},
                        {18,11,22,14},
                        {1,2,4,3},
                    };

    for(int i=0;i<3;i++) {
        for(int j=1;j<4;j++) {
            SWAP( list[i][0], list[i][j] );         
        }
    }
}
void b() {
    int list[3][4] = {
                        {19,10,23,15},
                        {17,12,21,13},
                        {5,6,8,7},
                    };

    for(int i=0;i<3;i++) {
        for(int j=1;j<4;j++) {
            SWAP( list[i][0], list[i][j] );         
        }
    }
}

void splitpush(string input) {
    long value=0;

    for(long i=0;i<input.size();i++) {

        if(input[i]=='1'){
            value++;
        }
        else if(input[i]=='0' && value!=0 ) {
            if(value<10) {
                u();
            }
            else if (value<30) {
                d();

            }
            else {
                r();
            }
            (*stackptrs[0]).push(value);
            value=0;

        }
        else {
            break;
        }

    }

}

long strToInt(string str) { // IF STRING HAS NON DIGITS, YOU WILL GET GARBAGE, BUT NO ERROR
    long j=str.size()-1;
    long value = 0;
    for(long i=0;i<str.size();i++) {
        long x = str[i]-48;

        value+=x*floor( pow(10,j) );
        j--;
    }
    return value;
}

bool isEmpty(superStack stk) {
    if( stk.size()>0){return false; }
    else {return true;}

}    

long getValue(string str) {
    if(str=="ShabbySam") {
        return ShabbySam;
    }
    else if(str=="Hans") {
        return Hans;
    }
    else if(str=="Gertrude") {
        return Gertrude;
    }
    else if(str=="Alberto") {
        return Alberto;
    }   
    else if(str=="Leopold") {
        return Leopold;
    }
    else if(str[ str.size()-1 ]=='s'){
        str.pop_back();

        long index = strToInt(str)-1;

        if( !isEmpty( (*stackptrs[index]) ) ) {
            return (*stackptrs[index]).top();
        }
        else {
            cerr<<"Bad Expression or Empty Stack";


        }   
    }
    else {
        return strToInt(str);
    }

}

void printUnary(long i) {
    while(i>0) {
        cout<<1;
        i--;
    }
}

int main(int argc, char**argv) {

    if(argc<2){std::cerr<<"No input file given"; return 1;}
    ifstream inf(argv[1]);
    if(!inf){std::cerr<<"File open failed";return 1;}

    for(int i=0;i<24;i++) { 
        (*stackptrs[i]).push(0);         // Pre push a zero on every stack
    }

    string labels[20];
    unsigned labelPoints[20];
    int index=0;



    string str;
    while(inf) { //  parse for labels
        inf>>str;
        //cout<<inf.tellg()<<" ";
        if(inf) {
            if(str[str.size()-1]==':') {
                str.pop_back();
                bool alreadyExists = false;
                for(int i=0; i<index;i++){
                    if(labels[i] == str ) { alreadyExists=true;}
                }
                if(!alreadyExists) {
                    labels[index]=str;
                    labelPoints[index]= inf.tellg();
                    index++;
                }
            }

        }

    }
    inf.clear();
    inf.seekg(0,inf.beg);

    while(inf) { // parse for other commands 
        inf>>str;

        if(inf) {


            if(str=="cinpush") {
                string input;
                cin>>input;
                splitpush(input);
            }

            else if(str=="mov") {
                inf>>str;
                long value = getValue(str);

                inf>>str;
                if(str=="Gertrude"){Gertrude=value;}
                else if(str=="Hans"){Hans=value;}
                else if(str=="ShabbySam"){ShabbySam=value;}
                else if(str=="Alberto"){Alberto=value;}
                else if(str=="Leopold"){Leopold=value;}
                else {cerr<<"Bad register name. ";}

            }

            else if(str=="movfs") {
                inf>>str;
                long index = getValue(str);
                if(!isEmpty( *stackptrs[index-1] )) {
                    inf>>str;
                    long value = (*stackptrs[index-1]).top();
                    if(str=="Gertrude"){Gertrude=value;}
                    else if(str=="Hans"){Hans=value;}
                    else if(str=="ShabbySam"){ShabbySam=value;}
                    else if(str=="Alberto"){Alberto=value;}
                    else if(str=="Leopold"){Leopold=value;}
                    else {cerr<<"Bad register name.";}
                }
                else {
                    cerr<<"Empty Stack";
                }



            }

            else if(str=="inc") {
                inf>>str;
                if(str=="Gertrude"){Gertrude++;}
                else if(str=="Hans"){Hans++;}
                else if(str=="ShabbySam"){ShabbySam++;}
                else if(str=="Alberto"){Alberto++;}
                else if(str=="Leopold"){Leopold++;}
                else {cerr<<"Bad register name. ";}
            }
            else if(str=="dec") {
                inf>>str;
                if(str=="Gertrude"){Gertrude--;}
                else if(str=="Hans"){Hans--;}
                else if(str=="ShabbySam"){ShabbySam--;}
                else if(str=="Alberto"){Alberto--;}
                else if(str=="Leopold"){Leopold--;}
                else {cerr<<"Bad register name. ";}
            }


            else if(str=="compg") {
                inf>>str;
                long value1 = getValue(str);
                inf>>str;
                long value2 = getValue(str);
                inf>>str;
                long larger;
                if(value1>value2){larger = value1;}
                else {larger = value2;}

                if(str=="Gertrude"){Gertrude=larger;}
                else if(str=="Hans"){Hans=larger;}
                else if(str=="ShabbySam"){ShabbySam=larger;}
                else if(str=="Alberto"){Alberto=larger;}
                else if(str=="Leopold"){Leopold=larger;}
                else {cerr<<"Bad register name. ";}

            }
            else if(str=="compl") {
                inf>>str;
                long value1 = getValue(str);
                inf>>str;
                long value2 = getValue(str);
                inf>>str;
                long larger; //LARGER IS REALLY SMALLER HERE
                if(value1>value2){larger = value2;}
                else {larger = value1;}

                if(str=="Gertrude"){Gertrude=larger;}
                else if(str=="Hans"){Hans=larger;}
                else if(str=="ShabbySam"){ShabbySam=larger;}
                else if(str=="Alberto"){Alberto=larger;}
                else if(str=="Leopold"){Leopold=larger;}
                else {cerr<<"Bad register name. ";}

            }

            else if(str=="gte") {
                inf>>str;
                long value1= getValue(str);
                inf>>str;
                long value2= getValue(str);
                inf>>str;
                bool torf = value1 >= value2;

                if(str=="Gertrude"){Gertrude=torf;}
                else if(str=="Hans"){Hans=torf;}
                else if(str=="ShabbySam"){ShabbySam=torf;}
                else if(str=="Alberto"){Alberto=torf;}
                else if(str=="Leopold"){Leopold=torf;}
                else {cerr<<"Bad register name. ";}

            }

            else if(str=="lte") {
                inf>>str;
                long value1= getValue(str);
                inf>>str;
                long value2= getValue(str);
                inf>>str;
                bool torf = value1 <= value2;

                if(str=="Gertrude"){Gertrude=torf;}
                else if(str=="Hans"){Hans=torf;}
                else if(str=="ShabbySam"){ShabbySam=torf;}
                else if(str=="Alberto"){Alberto=torf;}
                else if(str=="Leopold"){Leopold=torf;}
                else {cerr<<"Bad register name. ";}

            }

            else if(str=="POP!!") {
                inf>>str;
                long index = getValue(str);
                index--; //because we (C++ and this interpreter) index differently
                if(!isEmpty( *stackptrs[index] )) {
                    (*stackptrs[index]).pop();
                }
                else {cerr<<"Can't POP!! from empty stack";}

            }

            else if(str=="push"){cerr<<" You can't. ";}

            /*
            else if(str[str.size()-1]==':') {
                str.pop_back();
                bool alreadyExists = false;
                for(int i=0; i<index;i++){
                    if(labels[i] == str ) { alreadyExists=true;}
                }
                if(!alreadyExists) {
                    labels[index]=str;
                    labelPoints[index]= inf.tellg();
                    index++;
                }
            }*/

            else if(str=="jmp") {
                inf>>str;
                for(int i=0;i<index;i++) {
                    if( labels[i]==str) {
                        inf.seekg( labelPoints[i], ios::beg);
                    }
                }
            }
            else if(str=="jz") {
                inf>>str;
                long value = getValue(str);

                if(value==0) {
                    inf>>str;
                    for(int i=0;i<index;i++) {
                        if( labels[i]==str) {
                            inf.seekg( labelPoints[i], ios::beg);
                        }
                    }
                }
            }

            else if(str=="jnz") {
                inf>>str;
                long value = getValue(str);

                if(value!=0) {
                    inf>>str;
                    for(int i=0;i<index;i++) {
                        if( labels[i]==str) {
                            inf.seekg( labelPoints[i], ios::beg);
                        }
                    }
                }
            }

            else if(str== "\"shuffle\"") {
                inf>>str;
                if(str=="l"){ l(); }
                else if(str=="f"){ f(); }
                else if(str=="b"){ b(); }
                else {cerr<<"Bad shuffle parameter";}

            }

            else if(str=="print") {

                for(int i=0;i<24;i++) {

                    if( (i+1) != (*stackptrs[i]).place() ) {
                        cerr<< "Sorry, your stacks are in the wrong place! You can't print unless you put them back! Exiting. ";
                        return 1;
                    }

                }
                inf>>str;
                if(str=="Gertrude"){printUnary(Gertrude);}
                else if(str=="Hans"){printUnary(Hans);}
                else if(str=="ShabbySam"){printUnary(ShabbySam);}
                else if(str=="Alberto"){printUnary(Alberto);}
                else if(str=="Leopold"){printUnary(Leopold);}
                else {cerr<<"Bad register name. ";}


            }

            else if(str=="done!") {return 0;}

            else if(str=="print-d" ){
                inf>>str;
                long value = getValue(str);
                cout<<str;
              }
        }

    }







    /*for(int i=1;i<25;i++) {
        (*(stackptrs[i-1])).push(i);
    }

    u();d();r();l();f();b();
    */

    cout<<"\n";
    for(int i=1;i<25;i++) {
        if( (*(stackptrs[i-1])).size()>0 ) {
            cout<<(*(stackptrs[i-1])).top()<<" "<<(*(stackptrs[i-1])).place()<<"\n";
            (*(stackptrs[i-1])).pop();
        }
    }
    /*
    for (int i=0;i<index;i++) {
        cout<<labels[i]<<": "<<labelPoints[i]<<"\n";
    }*/

    return 1;
}

-> क्रमपरिवर्तन क्रम निम्नलिखित सूची में स्टैक सूची के तत्वों को अनुमति देता है:

मतलब कहाँ है

(ये दुभाषिया कोड में भी दिखाई देते हैं। यदि कोई विसंगति है, तो दुभाषिया सही है।)

-> सरल उदाहरण

ये दो सरल कार्यक्रम 24 से 1 तक (एकतरफा में) संख्या को बिना किसी व्हाट्सएप के प्रिंट करते हैं।

mov 24 Hans
start:
    print Hans
    dec Hans
    jnz Hans start
done!

या

mov 24 Hans start: print Hans dec Hans jnz Hans start done!

वे एक ही कार्यक्रम हैं।

स्पष्टीकरण और समाधान:

मार्टिन ने अपने उत्तर में भी अच्छी व्याख्या की है ।

जैसा कि मार्टिन को पता चला, यह भाषा पॉकेट क्यूब (उर्फ 2x2 रूबिक क्यूब) से प्रेरित थी। 24 ढेर 24 घन पर व्यक्तिगत वर्गों की तरह हैं। क्रमपरिवर्तन की अनुमति दी गई मूल चालें हैं: ऊपर, नीचे, दाएं, बाएं, सामने, पीछे।

यहां मुख्य संघर्ष यह है कि जब मूल्यों को धक्का दिया जाता है, तो केवल तीन चालों का उपयोग किया जाता है: ऊपर, नीचे, और सही। हालाँकि, आपके पास इन चालों तक पहुँच नहीं है जब स्टैक को "फेरबदल" किया जाता है। आपके पास केवल अन्य तीन चालें हैं।

जैसा कि यह पता चला है, तीन चालों के दोनों सेट वास्तव में पूरे समूह (यानी जनरेटर) हैं, इसलिए समस्या हल है। इसका मतलब है कि आप वास्तव में किसी भी 2x2 रूबिक के घन को केवल 3 चालों का उपयोग करके हल कर सकते हैं।

यह सब करने के लिए छोड़ दिया गया है यह पता लगाने के लिए कि अन्य तीन का उपयोग करके ऊपर, नीचे और दाएं चालें कैसे करें। इसके लिए, मैंने GAP नामक एक कंप्यूटर बीजगणित प्रणाली को नियोजित किया ।

क्रमपरिवर्तन को पूर्ववत करने के बाद, तीसरी सबसे बड़ी संख्या का पता लगाना काफी तुच्छ है।

cinpush
main:
    mov 1s ShabbySam
    POP!! 1
    jmp compare
    continue:
        gte 0 ShabbySam Leopold
        jnz Leopold end
        gte ShabbySam 9 Leopold
        jz Leopold uinverse
        gte ShabbySam 29 Leopold
        jz Leopold dinverse
        jnz Leopold rinverse
compare:
    gte ShabbySam Alberto Leopold
    jz Leopold skip
    mov Gertrude Hans
    mov Alberto Gertrude
    mov ShabbySam Alberto
    jmp continue
    skip:
        gte ShabbySam Gertrude Leopold
        jz Leopold skip_2
        mov Gertrude Hans
        mov ShabbySam Gertrude
        jmp continue
    skip_2:
        gte ShabbySam Hans Leopold
        jz Leopold continue
        mov ShabbySam Hans
        jmp continue
uinverse: 
    "shuffle" f
    "shuffle" f
    "shuffle" f
    "shuffle" l
    "shuffle" b
    "shuffle" l
    "shuffle" b
    "shuffle" b
    "shuffle" b
    "shuffle" l
    "shuffle" l
    "shuffle" l
    "shuffle" b
    "shuffle" b
    "shuffle" b
    "shuffle" l
    "shuffle" l
    "shuffle" l
    "shuffle" f
    jmp main
dinverse:
    "shuffle" f
    "shuffle" b
    "shuffle" l
    "shuffle" b
    "shuffle" b
    "shuffle" b
    "shuffle" f
    "shuffle" f
    "shuffle" f
    jmp main
rinverse: 
    "shuffle" b "shuffle" l "shuffle" f "shuffle" l "shuffle" b
    "shuffle" f "shuffle" f "shuffle" f "shuffle" b
    "shuffle" l "shuffle" l "shuffle" l
    "shuffle" b "shuffle" b "shuffle" b
    "shuffle" f "shuffle" f "shuffle" f
    "shuffle" l "shuffle" f "shuffle" l "shuffle" f
    "shuffle" l "shuffle" f "shuffle" f "shuffle" f
    "shuffle" l "shuffle" l "shuffle" l 
    "shuffle" f "shuffle" l "shuffle" l 
    "shuffle" f "shuffle" f "shuffle" f
    "shuffle" l "shuffle" l "shuffle" l
    "shuffle" l "shuffle" l "shuffle" l "shuffle" f
    "shuffle" l "shuffle" l "shuffle" l
    "shuffle" f "shuffle" f "shuffle" f
    "shuffle" l "shuffle" l "shuffle" l
    "shuffle" f "shuffle" f "shuffle" f
    "shuffle" l "shuffle" l "shuffle" l
    "shuffle" f "shuffle" f "shuffle" f
    "shuffle" l "shuffle" l "shuffle" l
    "shuffle" f "shuffle" f "shuffle" f
    "shuffle" l "shuffle" f "shuffle" l "shuffle" f "shuffle" l "shuffle" f
    "shuffle" l "shuffle" l "shuffle" l
    jmp main
end:
    print Hans
    done!

2
फटा। :) मैं वास्तव में भाषा से प्रभावित हूँ!
मार्टिन एंडर

वाह जो मुझे उम्मीद थी उससे कहीं तेज था। धन्यवाद, मुझे खुशी है कि यह लिखने के लिए यह पता लगाना जितना मजेदार था।
लियाम

मैं उत्सुक हूँ, क्या यह शालीनता से कठिन होता अगर मैंने रुबिक के क्यूब्स के बारे में कुछ स्पष्ट रूप से क्रमपरिवर्तन के नाम बदल दिए होते?
लियाम

वे निश्चित रूप से एक सुराग थे, लेकिन मुझे लगता है कि अगर उनके पास अलग-अलग नाम होते तो यह अधिक समय नहीं लगता ।
मार्टिन एंडर

हेह, ऐसा लगता है कि जीएपी तीन इनपुट क्रमपरिवर्तन को उलटने के बारे में विशेष रूप से चतुर नहीं था। ;)
मार्टिन एंडर

22

ब्रायन और चक , कार्डबोर्ड_बॉक्स द्वारा क्रैक किया गया

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

नायक

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

चूंकि स्रोत कोड एक मेमोरी टेप भी है, इसलिए कमांड को तकनीकी रूप से पूर्णांक मानों द्वारा परिभाषित किया जाता है, लेकिन वे उचित वर्णों के अनुरूप होते हैं। निम्नलिखित आदेश मौजूद हैं:

  • ,( 44): वर्तमान मेमोरी सेल में STDIN से एक बाइट पढ़ें। केवल ब्रायन ही ऐसा कर सकते हैं। यह कमांड चक के लिए नो-ऑप है।
  • .( 46): वर्तमान मेमोरी सेल, मॉडुलो 256, STDOUT को बाइट के रूप में लिखें। केवल चक ऐसा कर सकता है। यह कमांड ब्रायन के लिए नो-ऑप है।
  • +( 43): वर्तमान मेमोरी सेल में वृद्धि।
  • -( 45): वर्तमान मेमोरी सेल घटाएँ।
  • ?( 63): यदि वर्तमान मेमोरी सेल शून्य है, तो यह एक सेशन नहीं है। अन्यथा, अन्य कार्यक्रम पर हाथ नियंत्रण। जो प्रोग्राम उपयोग करता है उस पर टेप हेड ?रहेगा ?। दूसरे प्रोग्राम का टेप हेड पहले कमांड को निष्पादित करने से पहले एक सेल को दाईं ओर ले जाएगा (इसलिए परीक्षण के रूप में उपयोग किए जाने वाले सेल को स्वयं निष्पादित नहीं किया जाता है)।
  • <( 60): टेप हेड एक सेल को बाईं ओर ले जाएं। यह एक नो-ऑप है यदि टेप हेड पहले से ही टेप के बाएं छोर पर है।
  • >( 62): टेप हेड एक सेल को दाईं ओर ले जाएं।
  • {( 123): बार-बार टेप हेड को बाईं ओर तब तक घुमाएं जब तक कि वर्तमान सेल शून्य न हो या टेप का लेफ्ट एंड पहुंच न जाए।
  • }( 125): वर्तमान सेल शून्य होने तक टेप सिर को दाईं ओर ले जाएं।

कार्यक्रम समाप्त हो जाता है जब सक्रिय प्रोग्राम का निर्देश पॉइंटर उस बिंदु पर पहुंचता है जहां इसके दाईं ओर अधिक निर्देश नहीं होते हैं।

स्रोत कोड

स्रोत फ़ाइल को निम्नानुसार संसाधित किया गया है:

  • यदि फ़ाइल में स्ट्रिंग है ``` , तो फ़ाइल उस स्ट्रिंग की पहली घटना के आसपास दो भागों में विभाजित हो जाएगी। सभी प्रमुख और अनुगामी व्हाट्सएप छीन लिए गए हैं और पहला भाग ब्रायन के लिए स्रोत कोड और चक के लिए दूसरे भाग के रूप में उपयोग किया जाता है।
  • यदि फ़ाइल में यह स्ट्रिंग नहीं है, तो फ़ाइल की पहली पंक्ति को ब्रायन के स्रोत के रूप में और चक के लिए दूसरे भाग के रूप में उपयोग किया जाएगा (परिसीमन नई रेखा के अलावा, कोई व्हाट्सएप नहीं हटाया जाएगा)।
  • _दोनों कार्यक्रमों की सभी घटनाओं को NULL बाइट्स के साथ बदल दिया जाता है।
  • दो मेमोरी टेप परिणामी स्ट्रिंग के अनुरूप वर्ण कोड के साथ आरंभीकृत होते हैं।

एक उदाहरण के रूप में, निम्न स्रोत फ़ाइल

  abc
```
0_1
23

निम्नलिखित प्रारंभिक टेप प्राप्त करेंगे:

Brian: [97 98 99 0 0 0 0 ...]
Chuck: [48 0 49 10 50 51 0 0 0 0 ...]

दुभाषी

इंटरप्रेटर रूबी में लिखा है। इसमें दो कमांड-लाइन झंडे लगते हैं जिनका किसी भी समाधान से उपयोग नहीं किया जाना चाहिए (क्योंकि वे वास्तविक भाषा विनिर्देश का हिस्सा नहीं हैं):

  • -d: इस ध्वज के साथ, ब्रायन और चक दो और आदेशों को समझते हैं। !दोनों मेमोरी टेप के एक स्ट्रिंग प्रतिनिधित्व को प्रिंट करेगा, सक्रिय प्रोग्राम को पहले सूचीबद्ध किया ^जाएगा ( वर्तमान टेप प्रमुखों को चिह्नित करेगा)। @यह भी करेगा, लेकिन फिर कार्यक्रम को तुरंत समाप्त कर देगा। क्योंकि मैं आलसी हूं, न तो उन कामों में से यदि वे कार्यक्रम में अंतिम आदेश हैं, इसलिए यदि आप उन्हें वहां उपयोग करना चाहते हैं, तो उन्हें दोहराएं या उनके बाद नो-ऑप लिखें।
  • -D: यह क्रिया डिबग मोड है। यह !हर एक टिक के बाद उसी डिबग जानकारी को प्रिंट करेगा । @इस मोड में भी काम करता है।

यहाँ कोड है:

# coding: utf-8

class Instance
    attr_accessor :tape, :code, :ip

    OPERATORS = {
        '+'.ord  => :inc,
        '-'.ord  => :dec,
        '>'.ord  => :right,
        '<'.ord  => :left,
        '}'.ord  => :scan_right,
        '{'.ord  => :scan_left,
        '?'.ord  => :toggle,
        ','.ord  => :input,
        '.'.ord  => :output,
        '!'.ord  => :debug,
        '@'.ord  => :debug_terminate
    }

    OPERATORS.default = :nop

    def initialize(src)
        @code = src.chars.map(&:ord)
        @code = [0] if code.empty?

        @ip = 0
    end

    def tick
        result = :continue
        case OPERATORS[@code[@ip]]
        when :inc
            @tape.set(@tape.get + 1)
        when :dec
            @tape.set(@tape.get - 1)
        when :right
            @tape.move_right
        when :left
            @tape.move_left
        when :scan_right
            @tape.move_right while @tape.get != 0
        when :scan_left
            @tape.move_left while @tape.ip > 0 && @tape.get != 0
        when :toggle
            if @tape.get != 0
                @tape.move_right
                result = :toggle
            end
        when :input
            input
        when :output
            output
        when :debug
            result = :debug
        when :debug_terminate
            result = :debug_terminate
        end

        return :terminate if result != :toggle && @ip == @code.size - 1

        move_right if result != :toggle

        return result
    end

    def move_right
        @ip += 1
        if @ip >= @code.size
            @code << 0
        end
    end

    def move_right
        @ip += 1
        if @ip >= @code.size
            @code << 0
        end
    end

    def move_left
        @ip -= 1 if @ip > 0
    end

    def get
        @code[@ip]
    end

    def set value
        @code[@ip] = value
    end

    def input() end
    def output() end

    def to_s
        str = self.class.name + ": \n"
        ip = @ip
        @code.map{|i|(i%256).chr}.join.lines.map do |l|
            str << l.chomp << $/
            str << ' '*ip << "^\n" if 0 <= ip && ip < l.size
            ip -= l.size
        end
        str
    end
end

class Brian < Instance
    def input
        byte = STDIN.read(1)
        @tape.set(byte ? byte.ord : -1)
    end
end

class Chuck < Instance
    def output
        $> << (@tape.get % 256).chr
    end
end

class BrianChuck

    class ProgramError < Exception; end

    def self.run(src, debug_level=0)
        new(src, debug_level).run
    end

    def initialize(src, debug_level=false)
        @debug_level = debug_level

        src.gsub!('_',"\0")

        if src[/```/]
            brian, chuck = src.split('```', 2).map(&:strip)
        else
            brian, chuck = src.lines.map(&:chomp)
        end

        chuck ||= ""

        brian = Brian.new(brian)
        chuck = Chuck.new(chuck)

        brian.tape = chuck
        chuck.tape = brian

        @instances = [brian, chuck]
    end

    def run
        (puts @instances; puts) if @debug_level > 1

        loop do
            result = current.tick

            toggle if result == :toggle

            (puts @instances; puts) if @debug_level > 1 || @debug_level > 0 && (result == :debug || result == :debug_terminate)

            break if result == :terminate || @debug_level > 0 && result == :debug_terminate
        end
    end

    private

    def current
        @instances[0]
    end

    def toggle
        @instances.reverse!
    end
end

case ARGV[0]
when "-d"
    debug_level = 1
when "-D"
    debug_level = 2
else
    debug_level = 0
end

if debug_level > 0
    ARGV.shift
end

BrianChuck.run(ARGF.read, debug_level)

यहाँ समस्या का अपना (हस्तलिखित) समाधान है:

>}>}>
brace left: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
arrow left: >++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
brace left: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
arrow left: >++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
question mk: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>>>} Append a bunch of 1s as a dummy list element:
+>+>+>+>+>+>+>+>+>+
Append two 1s and some code to the list; the first is a marker for later; the latter will be the integer
1: >+
brace right: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
arrow left: >++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
question mk: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1: >+
brace right: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
arrow right: >++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
brace right: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
arrow left: >++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
question mk: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
_
{<<<<<<<<<{<{    Move back to the start
Read a character and subtract 48 to get actual 0 or 1
,------------------------------------------------
?   If 1 switch to Chuck otherwise continue
>}>}>>>>>>>>>}<<<<<<- Subtract 1 from the result to account for initial 1
?   If integer was positive switch to Chuck
@todo: process end
_
This code is run when reading 1:
}>}>>>>>>>>>}<<<<<<+ Move to the end of Chuck; skip one null cell; move to the end of the list
{<<<<<<<<<{<?   Move back to the code that resets this loop.
_
This code is run after finalising an integer:
change the code after the integer first
<<--<--<--}
Append two 1s and some code to the list; the first is a marker for later; the latter will be the integer
1: +
brace right: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
arrow left: >++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
question mk: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1: >+
brace right: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
arrow right: >++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
brace right: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
arrow left: >++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
question mk: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{<<<<<<<+<<{<{    Move back to the start; incrementing the list length
Read a character and subtract 48 to get actual 0 or 1
,------------------------------------------------
?   If 1 switch to Chuck otherwise continue
>}>}>>>>>>>>>}
Leave the resetting code, but remove the rest of the last list element:
<<<--<--<--
1: <-
question mk: <---------------------------------------------------------------
arrow left: <------------------------------------------------------------
brace right: <-----------------------------------------------------------------------------------------------------------------------------
1: <-
<{< Move back to the cell we reserved for the counter
<<<<<<-- decrement list size by two so we don't process the two largest elements
_

<{<<<<<<{<{<{<{<{>}>}>>>>>>> This is the beginning of the loop which decrements all list elements by 1
+ Add 1 to the running total
>>- Set marker of dummy list element to zero
_ Beginning of loop that is run for each list element
<{<<<<<<{<{<{<{<{>}>}>}>}+ set last marker back to 1
>>>>>>>>>> move to next marker
? Skip the next bit if we're not at the end of the list
<? Move back to the beginning of the loop
@ we should never get here
_
This is run when we're not at the end of the list
<<<- Set marker to 0 to remember current position
>>>>- Move to the current value and decrement it
? Move back to loop beginning if value is not zero yet
- Make element negative so it's skipped in the future
{<{<{>- Move to remaining list length and decrement it
? If it's nonzero switch to Chuck
>>>>>>>>->->->->->->->->->- Remove the dummy list to make some space for new code:
>}+ Fill in the marker in the list
{<<<<<<<<< Add some loop resetting code after the result:
brace left: +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
arrow left: >++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
question mk: >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
_
This loop adds a print command to Chuck's code while decrementing the result
>>>>>>>>}>>>>>}>>>>>} Move to the very end of Chuck's code and leave some space to seek the 1
print: ++++++++++++++++++++++++++++++++++++++++++++++
{<<<<<{<<<<<{<<<<<<<{<
- decrement the result
? if nonzero run loop again
At this point we just need to make Chuck seek for the 1 at the end of this code print it often enough
>>}>>>>>>>}>>>>>}
arrow right: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
<?1 Switch to Chuck which moves Brian's tape head onto the 1 and then prints it N times


```

_   Dummy cell to hold input
This code is run when reading a 1:
{<{<{<{ ensure we're at the start
}>}<? Skip 0 handling code and switch to Brian
_ This code is run after a 1 has been processed:
{<{<?

इस कोड को runnable है के रूप में है, क्योंकि सभी एनोटेशन कोई-ऑप्स का उपयोग करें और के द्वारा छोड़ दिया जाता है {और}

मूल विचार है:

  1. सूची में एक नया शून्य-तत्व जोड़ें (चक के टेप के अंत में) और सूची की लंबाई 1 से बढ़ाएं।
  2. जब हम पढ़ रहे हैं 1, उस तत्व को बढ़ाते हैं।
  3. जब हम पढ़ रहे होते हैं 0, कुछ सफाई करते हैं। यदि परिणामी पूर्णांक शून्य से अधिक था, तो 1 पर वापस जाएं।

    अब हमें चक के टेप के अंत में इनपुट संख्याओं की एक सूची मिल गई है और हम सूची की लंबाई जानते हैं।

  4. सूची की लंबाई से 2 घटाएं (इसलिए निम्नलिखित चरण दो सबसे बड़े तत्वों की उपेक्षा करते हैं), इसे कॉल करें N

  5. हालांकि N > 0, एक चल रहे कुल में वृद्धि और फिर सभी सूची तत्वों में वृद्धि। जब भी कोई लिस्ट एलिमेंट जीरो हिट करता है, डेक्रिमेंट N

    इस के अंत में, चल कुल, इनपुट की तीसरी सबसे बड़ी संख्या में शामिल होंगे M

  6. चक के टेप के अंत की Mप्रतियां लिखें .

  7. चक पर, 1ब्रायन के टेप पर खोज करें और फिर .अंत में उत्पन्न लोगों को निष्पादित करें ।

इसे खत्म करने के बाद मुझे एहसास हुआ कि मैं इसे कुछ जगहों पर काफी सरल बना सकता हूं। उदाहरण के लिए, उस काउंटर पर नज़र रखने और उन लोगों .को चक के टेप पर लिखने के बजाय, मैं अभी 1तुरंत एक सूची प्रिंट कर सकता था , इससे पहले कि मैं सभी सूची तत्वों को घटा दूं। हालाँकि, इस कोड में बदलाव करना काफी दर्द भरा है, क्योंकि यह सभी जगह अन्य परिवर्तनों का प्रचार करता है, इसलिए मैंने बदलाव करने की जहमत नहीं उठाई।

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

अगली समस्या यह है कि Nजब हम इसे संसाधित कर रहे हैं, तो हमें सूची में कमी करने के लिए छोड़ना होगा, और हमें उसी स्थान पर वापस जाना होगा जहां हम पहले थे। लेकिन {और }अभी पूरी सूची को छोड़ देगा।

इसलिए हमें चक पर गतिशील रूप से कुछ कोड लिखने की आवश्यकता है। वास्तव में, प्रत्येक सूची तत्व iका रूप है:

[1 <Code A> i <Code B>]

1एक मार्कर है जिसे हम यह इंगित करने के लिए शून्य पर सेट कर सकते हैं कि हमने सूची को संसाधित करना कहां छोड़ दिया है। इसका उद्देश्य पकड़ने के लिए है {या }जो कोड और कोड को पार करेगा i। हम इस मान का उपयोग यह जांचने के लिए भी करते हैं कि क्या हम प्रसंस्करण के दौरान सूची के अंत में हैं, इसलिए जब हम नहीं होते हैं, तो यह होगा 1और सशर्त ?चक पर नियंत्रण बदल देगा। Code Aउस स्थिति को संभालने और उसके अनुसार ब्रायन पर आईपी को स्थानांतरित करने के लिए उपयोग किया जाता है।

अब जब हम कमी करते हैं तो iहमें यह जांचना होगा कि क्या iपहले से ही शून्य है। हालांकि ऐसा नहीं है, ?फिर से नियंत्रण बदल जाएगा, इसलिए Code Bइसे संभालना है।



@cardboard_box अच्छा लगा!
mbomb007

15

HPR, Python 3 में लिखा गया है ( TheNumberOne द्वारा क्रैक किया गया )

एचपीआर (नाम का अर्थ है कुछ भी नहीं) पूर्णांकों की सूची प्रसंस्करण के लिए एक भाषा है। इसे न्यूनतम , अत्यंत सीमित और "कृत्रिम" प्रतिबंधों से मुक्त बनाया गया है । एचपीआर में प्रोग्रामिंग दर्दनाक है, इसलिए नहीं कि आपको दुभाषिया को आप पर चिल्लाने से रोकने के लिए एक पहेली को हल करना है, बल्कि इसलिए कि प्रोग्राम को कुछ भी उपयोगी बनाने के लिए कठिन है। मुझे नहीं पता कि एचपीआर किसी सूची के तीसरे सबसे बड़े तत्व की गणना करने की तुलना में काफी अधिक दिलचस्प है या नहीं।

भाषा विनिर्देशन

एक HPR प्रोग्राम एक वातावरण में चलाया जाता है , जो कि नॉन-नेटिव पूर्णांकों का एक अनियोजित डुप्लिकेट-मुक्त सेट है और नॉन-नेटिव पूर्णांकों की सूची है। प्रारंभ में, पर्यावरण में केवल इनपुट सूची होती है (दुभाषिया इसे आपके लिए पार्स करता है)। तीन कमांड और दो "कंट्रोल फ्लो" ऑपरेटर हैं जो पर्यावरण को संशोधित करते हैं:

  • *पर्यावरण में प्रत्येक गैर-रिक्त सूची के पहले तत्व को निकालता है, और इसे पर्यावरण में रखता है। खाली सूचियाँ प्रभावित नहीं होती हैं। उदाहरण के लिए, यह रूपांतरित होता है

    {4,1,[0,2],[1,3],[]} -> {4,1,0,[2],[3],[]}
    
  • -पर्यावरण में सभी संख्याओं को घटाता है, और फिर नकारात्मक तत्वों को हटाता है। उदाहरण के लिए, यह रूपांतरित होता है

    {4,2,0,[0,2],[4,4,4]} -> {3,1,[0,2],[4,4,4]}
    
  • $पर्यावरण में हर सूची को बाईं ओर एक कदम घुमाता है। उदाहरण के लिए, यह रूपांतरित होता है

    {4,1,[0,2],[3,4,1]} -> {4,1,[2,0],[4,1,3]}
    
  • !(A)(B), जहां Aऔर Bकार्यक्रम हैं, मूल रूप से एक whileलूप है। यह "कार्रवाई" करता है Aजब तक कि "परीक्षण" Bएक खाली वातावरण में परिणाम नहीं देगा। यह एक अनंत लूप का उत्पादन कर सकता है।
  • #(A)(B), जहां Aऔर Bकार्यक्रम हैं, वर्तमान परिवेश में लागू होते हैं Aऔर Bपरिणामों के सममित अंतर को लेते हैं।

आदेशों को बाएं से दाएं निष्पादित किया जाता है। अंत में, पर्यावरण का आकार एकात्मक में मुद्रित होता है।

दुभाषी

इस दुभाषिया में डीबग कमांड की सुविधा है ?, जो पर्यावरण को संशोधित किए बिना प्रिंट करता है। यह कार्य के किसी भी समाधान में प्रकट नहीं होना चाहिए। सिवाय किसी भी वर्ण को *-$!#()?अनदेखा किया जाता है, इसलिए आप सीधे कोड में टिप्पणी लिख सकते हैं। अंत में, दुभाषिया मुहावरे !(A)(#(A)())को "प्रदर्शन के रूप में दिखाता है Aजब तक कि परिणाम नहीं बदलता है", और इसे अतिरिक्त गति के लिए अनुकूलित करता है (अंतिम परीक्षण के मामले पर एक घंटे के भीतर समाप्त करने के लिए मुझे अपना समाधान प्राप्त करने के लिए इसकी आवश्यकता थी)।

import sys

def parse(prog):
    "Parse a prefix of a string into an AST. Return it and the remaining input."
    ret = []
    while prog:
        if prog[0] in "#!":
            sub1, prog1 = parse(prog[2:])
            sub2, prog2 = parse(prog1[1:])
            ret += [prog[0],sub1,sub2]
            prog = prog2
        elif prog[0] == ')':
            prog = prog[1:]
            break
        else:
            ret += [prog[0]]
            prog = prog[1:]
    return ret, prog

def intp(ast, L_env, N_env):
    "Interpret the AST on an environment, return the resulting environment."
    ptr = 0
    while ptr < len(ast):
        cmd = ast[ptr]
        if cmd == '*':
            N_env = N_env | set(L[0] for L in L_env if L)
            L_env = set(L[1:] for L in L_env)
            ptr += 1
        elif cmd == '-':
            N_env = set(N-1 for N in N_env if N>0)
            ptr += 1
        elif cmd == '$':
            L_env = set(L[1:]+L[:1] for L in L_env)
            ptr += 1
        elif cmd == '!':
            # Speed optimization
            cond = ast[ptr+2]
            if cond == ['#', ast[ptr+1], []]:
                L_next, N_next = intp(ast[ptr+1], L_env, N_env)
                while L_next != L_env or N_next != N_env:
                    L_env, N_env = L_next, N_next
                    L_next, N_next = intp(ast[ptr+1], L_env, N_env)
            else:
                while True:
                    L_test, N_test = intp(cond, L_env, N_env)
                    if not L_test and not N_test:
                        break
                    L_env, N_env = intp(ast[ptr+1], L_env, N_env)
            ptr += 3
        elif cmd == '#':
            L_env1, N_env1 = intp(ast[ptr+1], L_env, N_env)
            L_env2, N_env2 = intp(ast[ptr+2], L_env, N_env)
            L_env = L_env1 ^ L_env2
            N_env = N_env1 ^ N_env2
            ptr += 3
        elif cmd == '?':
            print(L_env | N_env)
            ptr += 1
        else:
            ptr += 1
    return L_env, N_env

def main(p, L):
    "Run the program on the input, return the output."
    # Parse the input list
    L = ''.join(c for c in L if c in "01")
    while "00" in L:
        L = L.replace("00","0")
    L = [-2] + [i for i in range(len(L)-1) if L[i:i+2] == "10"]
    L = tuple(b-a-1 for (a,b) in zip(L, L[1:]))
    # Parse the program
    ast = parse(p)[0]
    L_env, N_env = intp(ast, set([L]), set())
    return '1'*(len(L_env) + len(N_env))

if __name__ == "__main__":
    filename = sys.argv[1]
    f = open(filename, 'r')
    prog = f.read()
    f.close()
    L = input()
    print(main(prog, L))

मेरा समाधान

मेरा संदर्भ समाधान 484 बाइट्स लंबा है, इसलिए TheNumberOne के 3271-बाइट प्रोग्राम की तुलना में काफी कम है। यह सबसे अधिक संभावना है क्योंकि परिष्कृत और भयानक मैक्रो सिस्टम TheNumberOne एचपीआर में प्रोग्रामिंग के लिए विकसित किया गया है। हमारे दोनों कार्यक्रमों में मुख्य विचार समान है:

  1. सूची के अधिकतम तत्व का उत्पादन करने का तरीका जानें।
  2. अधिकतम तत्व को निकालने के लिए, सूची को घुमाएं जब तक कि पहला तत्व अधिकतम के बराबर न हो जाए, तब इसे पॉप करें।
  3. अधिकतम दो बार निकालें, फिर नया अधिकतम तत्व प्रिंट करें।

हालांकि, जहां तक ​​मैं बता सकता हूं, सटीक कार्यान्वयन विवरण काफी अलग हैं। यहाँ मेरा समाधान है:

!($)(!(-)(#(-)())#(!(-#(!(*)(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)())))(#(-#(!(*)(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)())))())#(-)(#(!(-)(#(-)()))()))(*)#(!(-)(#(-)()))())*!(-)(#(-)())!($)(!(-)(#(-)())#(!(-#(!(*)(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)())))(#(-#(!(*)(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)())))())#(-)(#(!(-)(#(-)()))()))(*)#(!(-)(#(-)()))())*!(-)(#(-)())!(-#(!(*)(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)())))(#(-#(!(*)(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)())))())-#(!(-)(#(-)()))()

और यहाँ टिप्पणी की गई पायथन कार्यक्रम जो इसे पैदा करता है (यहां कुछ भी नहीं फैंसी, सभी पुनरावृत्ति से छुटकारा पाने के लिए बस मूल स्ट्रिंग हेरफेर):

# No numbers in the environment
no_nums = "#(-)()"
# No non-empty lists in the environment
no_lists = "#(*)()"
# Remove all numbers from the environment
del_nums = "!(-)(" + no_nums + ")"
# Remove all lists from the environment
del_lists = "#(" + del_nums + ")()"
# Splat the list to the environment:
#  pop the list until it's empty and delete the empty list,
#  then take symmetric difference with all numbers removed
splat = "#(!(*)(" + no_lists + ")" + del_lists + ")(" + del_nums + ")"
# Put into the environment all numbers up to list maximum:
#  decrement and splat until a fixed point is reached.
#  Without the speed optimization, this is very slow if the list elements are large.
splat_upto = "!(-" + splat + ")(#(-" + splat + ")())"
# Copy maximum element to environment:
#  take all elements up to maximum,
#  then take symmetric difference of decrement and list deletion
copy_max = splat_upto + "#(-)(" + del_lists + ")"
# Delete maximum element from list:
#  rotate until first element is maximal, then pop and delete it
del_max = "!($)(" + del_nums + "#(" + copy_max + ")(*)" + del_lists + ")*" + del_nums
# Full program:
#  remove the maximum twice, then produce all numbers up to maximum,
#  then decrement and remove lists. The environment will contain exactly
#  the integers from 0 to third largest - 1, and their number is printed.
main = del_max + del_max + splat_upto + "-" + del_lists
print(main)


@ TheNumberOne ने मेरा समाधान जोड़ा।
ज़र्गब

12

TKDYNS (ड्रैगन को मारने के लिए, आपको एक तलवार चाहिए) - मार्टिन बर्टनर द्वारा फटा

संपादित करें: मैंने अपना समाधान और स्पष्टीकरण मुख्य पोस्ट के नीचे जोड़ा है।

पृष्ठभूमि

इस भाषा में, आप एक बहादुर योद्धा को नियंत्रित करते हैं, जिसे एक भयानक अजगर को मारने का काम सौंपा गया है। ड्रैगन एक भूमिगत भूलभुलैया में रहता है, जो खतरों और खतरों से भरा है, और अब तक, कोई भी इसे मैप करने और जीवित रहने में सक्षम नहीं है। इसका मतलब है कि आपको पिच अंधेरे में ड्रैगन के लिए अपना रास्ता नेविगेट करना चाहिए, लेकिन आपको मार्गदर्शन करने के लिए अंतर्ज्ञान और बहादुरी के साथ कुछ भी नहीं करना चाहिए।

...

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

कुछ और जानकारी

ड्रैगन की खोह 10x10 ग्रिड का रूप ले लेती है। ग्रिड में कुछ आसन्न बिंदुओं के बीच, एक संकीर्ण मार्ग है; दूसरों के बीच, एक गहरी खाई और निश्चित मृत्यु है। 4x4 ग्रिड के लिए एक उदाहरण लेआउट निम्नानुसार हो सकता है:

 0---1   2---3
     |   |   |
 4---5---6   7
 |           |
 8   9--10  11
     |       |
12--13--14--15

आप जानते हैं कि हमेशा एक बिंदु से किसी अन्य बिंदु तक पहुंचने का एक तरीका है, लेकिन इससे अधिक कोई बात आपके सामने नहीं आई है।

ड्रैगन को सफलतापूर्वक पराजित करने के लिए, आपको सबसे पहले कुछ वस्तुओं को इकट्ठा करने की आवश्यकता है, जिन्हें आप एक साथ जोड़कर एक जादुई ड्रैगन-स्लेयिंग ब्लेड बना पाएंगे। आसानी से, इस हथियार के सभी टुकड़े ड्रैगन की खोह के चारों ओर बिखरे हुए हैं। आपको बस उन्हें इकट्ठा करना है।

मोड़ यह है कि हथियार के प्रत्येक टुकड़े को booby- फंस गया है। हर बार एक एकत्र होने के बाद, वॉकवे का लेआउट बदल जाता है। पहले सुरक्षित रास्तों से अब निश्चित मृत्यु हो सकती है, और इसके विपरीत।

आदेश

केवल 5 वैध आदेश हैं।

  • < - बाईं ओर एक कदम उठाएं

  • > - दाईं ओर एक कदम रखें

  • ^ - एक कदम ऊपर की ओर ले जाएं

  • v - एक कदम नीचे की ओर लें

  • c- ऐसी कोई भी वस्तु लीजिए जो आपके वर्तमान स्थान पर आस-पास पड़ी हो। यदि आइटम मौजूद थे, तो खोह का लेआउट बदल जाता है। ऊपर की पंक्तियों में गिने गए पदों के साथ, अपनी स्थिति को मोडुलो ले लो। 10. दुभाषिया में हार्ड-कोड किए गए 10 लेआउट हैं, और लेआउट उसी के अनुरूप बदलता है। उदाहरण के लिए, यदि आप 13 वें स्थान पर हैं, तो लेआउट में परिवर्तन होता हैlayouts[3]

वे इंटरपरेटर में दिखाई देने वाले लेआउट निम्न तरीके से पूर्णांक में एन्कोड किए गए हैं:

  • खाली लेआउट शून्य पर एन्कोडेड है।

  • लेआउट में प्रत्येक किनारे के लिए, xदो पदों के छोटे होने दें जो इसमें सम्मिलित हों।

    • यदि चरण क्षैतिज है, 2^(2*x)तो एन्कोडिंग में जोड़ें (यह पावर-इन है, एक्सओआर नहीं)

    • यदि चरण लंबवत है, 2^(2*x + 1)तो एन्कोडिंग में जोड़ें ।

निष्पादन प्रवाह

दुभाषिया कमांड-लाइन तर्क के रूप में स्रोत फ़ाइल के नाम से चलाया जाता है।

जब दुभाषिया चलाया जाता है, तो यह उपयोगकर्ता को एक खोज प्रदान करने के लिए संकेत देगा। यह इनपुट प्रश्न में वर्णित फॉर्म में होना चाहिए, और हथियार के घटकों की खोह में स्थानों को निर्धारित करता है। विशेष रूप से, प्रत्येक इनपुट पूर्णांक को modulo 100 लिया जाता है, और खोह में संबंधित स्थान पर रखा जाता है।

प्रत्येक स्रोत कार्यक्रम में कई लाइनें शामिल हैं, प्रत्येक पंक्ति में उपरोक्त 5 मान्य वर्णों के कुछ अनुक्रम शामिल हैं। ये पंक्तियाँ आपके minions को दर्शाती हैं। आप, योद्धा, सुरक्षित होने के लिए ज्ञात कार्यों के अनुक्रम का ट्रैक रखते हैं। शुरू में, आपको खोह के बारे में कुछ नहीं पता है, इसलिए यह क्रम खाली है। प्रत्येक मिनियन को बदले में, निम्न स्थिति से शुरू किया जाता है: 0

  • मिनियन को निर्देश दिया जाता है कि सभी ज्ञात-से-सुरक्षित क्रियाओं को निष्पादित करें, इसके बाद कोड की अपनी लाइन में कार्रवाई की जाएगी।

    • यदि किसी भी बिंदु पर मिनियन की मृत्यु हो जाती है, तो आपको इसके बारे में सूचित किया जाता है, और लायर अपने प्रारंभिक कॉन्फ़िगरेशन में रीसेट हो जाता है। सभी आइटम बदल दिए जाते हैं, और वॉकवे अपने शुरुआती स्थानों पर लौट आते हैं।

    • यदि, इसके बजाय, मिनियन जीवित रहता है, तो आप इसे वैसे भी वाष्पीकृत करते हैं - यह केवल एक मिनियन है, आखिरकार। पहले की तरह, यह खोह को अपनी प्रारंभिक स्थिति में रीसेट करता है, लेकिन इस बार, आप क्रियाओं को मिनियन लाइन ऑफ़ कोड से ज्ञात-से-सुरक्षित क्रियाओं के अनुक्रम में जोड़ते हैं।

एक बार सभी minions समाप्त हो जाने के बाद, आप, योद्धा, उन सभी क्रियाओं को करते हैं जो सुरक्षित होने के लिए जानी जाती हैं, फिर से स्थिति से शुरू होती हैं। 0. दो संभावित परिणाम हैं:

  • आप हथियार के सभी टुकड़ों को इकट्ठा करते हैं - इस मामले में, आप सफलतापूर्वक ड्रैगन को मारते हैं, और एक रोमांचक जीत संदेश आउटपुट है। यह जीत संदेश अन्य वर्णों के बीच में होगा n, जहां nइनपुट के रूप में प्रदान की जाने वाली तीसरी सबसे बड़ी संख्या है।

  • आप हथियार के कुछ टुकड़ों को इकट्ठा करने में विफल रहे हैं - इस मामले में, ड्रैगन पर रहता है, और आप अपनी खोज में विफल रहे हैं।

दुभाषिया कोड (पायथन 2)

import collections
import copy
import sys

size = 10
layouts = [108705550239329248440770931020110627243913363144548922111951,108386637020100924277694952798729434993885646706222210602969,133885860318189115027934177821170081234850573770998325845482,102397795295522647918061101991513921833376565032742993744791,131948019244359669407266662537098175265242405785636894694611,127512068876349726396523358265982765442984953916545984706958,106817519055019354200334114020150263381328246524221867629943,33472343358375525802921815863230485208221126168622186265959,133909781123963725874096031069972704024813281938330035579187,132244654022332695610020359820518831299843076834682749020986]

class Interpreter(object):

    def __init__(self, source_file):
        self.source_filename = source_file
        self.layout = layouts[0]
        self.position = 0
        self.ingredients = []
        self.quest_items = {}
        self.attempts = collections.deque()

        self.safe_position = 0
        self.safe_ingredients = []
        self.safe_quest_items = {}
        self.safe_layout = layouts[0]

    def get_input(self):
        s = raw_input("Which quest would you like to embark on today?")
        ind = s.find('00')
        s = s[:ind]
        items = map(len, s.split('0'))
        for item in items:
            if item not in self.safe_quest_items:
                self.safe_quest_items[item] = 1
            else:
                self.safe_quest_items[item] += 1

    def parse_attempts(self):
        with open(self.source_filename, 'r') as source:
            for line in source:
                self.attempts.append(line.strip())

    def enc(self, x, y):
        x, y = min(x, y), max(x, y)
        if x < 0:
            return 0
        if y == x + 1:
            return 1 << (2*x)
        elif y == x + size:
            return 1 << (2*x + 1)
        else:
            return 0

    def exec_command(self, char):
        if char == '<':
            if self.enc(self.position, self.position-1) & self.layout:
                self.position -= 1
            else:
                return False
        elif char == '>':
            if self.enc(self.position, self.position+1) & self.layout:
                self.position += 1
            else:
                return False
        elif char == '^':
            if self.enc(self.position, self.position-size) & self.layout:
                self.position -= size
            else:
                return False
        elif char == 'v':
            if self.enc(self.position, self.position+size) & self.layout:
                self.position += size
            else:
                return False
        elif char == 'c':
            for item in xrange(self.position, 10**6, size*size):
                if item in self.quest_items:
                    self.ingredients += ([item] * self.quest_items.pop(item))
                    self.ingredients.sort()
                    self.layout = layouts[self.position % 10]
        else:
            raise ValueError

        return True

    def run_minion(self):
        minion = self.attempts.popleft()
        self.position = self.safe_position
        self.ingredients = copy.copy(self.safe_ingredients)
        self.quest_items = copy.copy(self.safe_quest_items)
        self.layout = self.safe_layout
        dead = False

        for cmd in minion:
            if not self.exec_command(cmd):
                dead = True

        if not dead:
            self.safe_position = self.position
            self.safe_ingredients = copy.copy(self.ingredients)
            self.safe_quest_items = copy.copy(self.quest_items)
            self.safe_layout = self.layout

    def process_minions(self):
        while self.attempts:
            self.run_minion()

    def final_run(self):
        if len(self.safe_quest_items) == 0:
            print "You killed the dragon" + "!!1" * self.safe_ingredients[-3]
        else:
            print "The dragon lives on. Better luck next time..."

    def interpret(self):
        self.get_input()
        self.parse_attempts()
        self.process_minions()
        self.final_run()

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print "Wrong number of arguments"
    else:
        test = Interpreter(sys.argv[1])
        test.interpret()

बेस्ट ऑफ लक, वीर योद्धा।

मेरा समाधान और स्पष्टीकरण

यहाँ एक पायथन स्क्रिप्ट है जो समस्या को हल करने के लिए स्रोत कोड उत्पन्न करती है। रुचि के लिए, मार्टिन का अंतिम स्रोत कोड मेरी स्क्रिप्ट द्वारा निर्मित कोड से लगभग 5 गुना छोटा है। दूसरी ओर, कोड उत्पन्न करने के लिए मेरी स्क्रिप्ट मार्टिन के गणितज्ञ कार्यक्रम से लगभग 15 गुना छोटी है ...

size = 10
layouts = [108705550239329248440770931020110627243913363144548922111951,108386637020100924277694952798729434993885646706222210602969,133885860318189115027934177821170081234850573770998325845482,102397795295522647918061101991513921833376565032742993744791,131948019244359669407266662537098175265242405785636894694611,127512068876349726396523358265982765442984953916545984706958,106817519055019354200334114020150263381328246524221867629943,33472343358375525802921815863230485208221126168622186265959,133909781123963725874096031069972704024813281938330035579187,132244654022332695610020359820518831299843076834682749020986]

def enc(edge):
    x,y = min(edge), max(edge)
    if x < 0:
        return 0
    if y == x + 1:
        return 1 << (2*x)
    elif y == x + size:
        return 1 << (2*x + 1)

def path(x, y, tree):
    stack = [(x,'')]
    while stack[-1][0] != y:
        vertex, path = stack.pop()
        if (enc((vertex, vertex+1))&tree) and ((not path) or path[-1] != '<'):
            stack.append((vertex+1, path+'>'))
        if (enc((vertex, vertex-1))&tree) and ((not path) or path[-1] != '>'):
            stack.append((vertex-1, path+'<'))
        if (enc((vertex, vertex+size))&tree) and ((not path) or path[-1] != '^'):
            stack.append((vertex+size, path+'v'))
        if (enc((vertex, vertex-size))&tree) and ((not path) or path[-1] != 'v'):
            stack.append((vertex-size, path+'^'))
    return stack[-1][1]

def reverse(path):
    rev = ''
    for i in xrange(len(path)-1, -1 ,-1):
        if path[i] == '<':
            rev += '>'
        if path[i] == '>':
            rev += '<'
        if path[i] == 'v':
            rev += '^'
        if path[i] == '^':
            rev += 'v'
    return rev

def assert_at(x, tree):
    path_ul = path(x, 0, tree)
    path_dr = path(x, size*size - 1, tree)
    return path_ul + reverse(path_ul) + path_dr + reverse(path_dr)

def safe_path(x, y, tree):
    return assert_at(x, tree) + path(x, y, tree)

with open('source.txt', 'w') as f:
    for x in xrange(size*size - 1):
        for tree in layouts:
            f.write(safe_path(x, x+1, tree) + 'c\n')

बुनियादी संरचना

यह 990 लाइनों के स्रोत कोड उत्पन्न करता है, जो 10. के समूहों में आते हैं। पहली 10 लाइनों में सभी निर्देश होते हैं जो स्थिति से स्थिति 0तक एक मिनियन को स्थानांतरित करने का प्रयास करते हैं 1, और फिर एक आइटम इकट्ठा करते हैं - प्रत्येक संभव लेआउट के लिए एक सेट। अगली 10 पंक्तियों में सभी निर्देश हैं जो स्थिति से स्थिति 1तक एक मिनियन को स्थानांतरित करने का प्रयास करते हैं 2, और फिर एक आइटम एकत्र करते हैं। और इसी तरह ... इन रास्तों की गणना की जाती हैpath स्क्रिप्ट में फ़ंक्शन के - यह सिर्फ एक सरल गहराई-पहली खोज करता है।

यदि हम यह सुनिश्चित कर सकते हैं कि 10 के प्रत्येक समूह में, ठीक एक मिनट में सफल होता है, तो हमने समस्या को हल कर दिया है।

दृष्टिकोण के साथ मुद्दा

यह हमेशा मामला है कि ठीक 10 के समूह से एक मिनियन सफल नहीं हो सकता है - उदाहरण के लिए, एक मिनियन स्थिति से प्राप्त करने के लिए तैयार किया गया है 0स्थिति के लिए 1गलती से स्थिति से आगे बढ़ में सफल हो सकता है 1स्थिति के लिए2 (लेआउट में समानता के कारण), और कहा कि संभावित रूप से विफलता के कारण, मिसकैरेज का प्रचार होगा।

इसे कैसे जोड़ेंगे

जो फिक्स मैंने इस्तेमाल किया वह इस प्रकार था:

प्रत्येक मिनियन के nलिए n+1, जो स्थिति से प्राप्त करने की कोशिश कर रहा है , पहले उसे स्थिति nसे स्थिति 0(शीर्ष-बाएं कोने) और फिर से वापस, फिर स्थिति nसे स्थिति 99(नीचे-दाएं कोने) तक और फिर से वापस करें। इन निर्देशों को केवल स्थिति से सुरक्षित रूप से किया जा सकता है n- कोई भी अन्य प्रारंभिक स्थिति और मिनियन किनारे से चलेगा।

इसलिए ये अतिरिक्त निर्देश मिनियंस को गलती से कहीं जाने से रोकते हैं, जो वे करने के लिए नहीं हैं, और यह सुनिश्चित करता है कि 10 के प्रत्येक समूह से बिल्कुल एक मिनियन सफल हो। ध्यान दें कि यह जरूरी नहीं है कि जिस मंत्री से आप यह अपेक्षा करते हैं - यह ऐसा हो सकता है कि जिस मंत्री का मानना ​​है कि वह लेआउट 0 में है वह तब भी सफल होता है, जब हम वास्तव में लेआउट 7 में होते हैं - लेकिन किसी भी मामले में, हमारे पास तथ्य यह है कि अब बदली हुई स्थिति का मतलब है कि समूह के अन्य सभी मंत्री जरूरी रूप से मर जाएंगे। इन अतिरिक्त चरणों की गणना assert_atफ़ंक्शन द्वारा की जाती है , और safe_pathफ़ंक्शन एक पथ देता है जो साधारण पथ के साथ इन अतिरिक्त चरणों का संयोजन है।


1
फटा। यह अच्छा मज़ा था, लेकिन मुझे लगता है कि यह "आपकी प्रोग्रामिंग भाषा को केवल इस एक कार्य को हल करना है" नियम के साथ एक मुद्दा लाता है, क्योंकि आपकी पहेली को क्रैक करने से वास्तव में उस प्रोग्रामिंग कार्य को हल करने के लिए कुछ भी नहीं था। ;)
मार्टिन एंडर

मैंने यह उत्तर मुख्य रूप से बनाया क्योंकि मैंने देखा कि यह मुद्दा मौजूद था - और किसी को इसके स्थान पर वास्तव में कठिन कम्प्यूटेशनल समस्या का उपयोग करने से रोकने से कुछ भी नहीं लगता है। 'नो क्रिप्टोकरंसी' पर प्रतिबंध मनमाने ढंग से लगता है ...
सैम कैपलमैन-लेस

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

ब्याज के लिए मेरा समाधान जोड़ा गया। ब्याज के लिए भी, मैंने मूल रूप से एक 1000x1000 ग्रिड के साथ पहेली को डिजाइन किया था, लेकिन लेआउट के न होने के हितों में जिन्हें ~ 600000-अंकीय संख्याओं के लिए एन्कोड किया गया था, मैंने छोटे आकार के लिए चुना था।
सैम कैपलमैन-लेस

8

Firetype, मार्टिन Büner द्वारा क्रैक किया गया

BF और CJam का वास्तव में अजीब मिश्रण। और किसको क्या पता! यकीन है कि यह एक आसान होगा, लेकिन यह वैसे भी मजेदार था। FYI करें, नाम अंतिम काल्पनिक प्रकार -0 से वर्मिलियन फायर का जिक्र है ।

नोट : कृपया मुझे इस विवरण में किसी भी अस्पष्टता के लिए क्षमा करें। मैं सबसे अच्छा लेखक नहीं हूँ ...: हे

मार्टिन ने इसे वास्तव में जल्दी से फटा! यह समस्या को हल करने का मेरा मूल कार्यक्रम था:

_
,
^
~
+
|
|
-
%
+
_
+
=











`
~
+
|
%

_
=

\
@
-
-
!
<
>
>
>

_
+
.
<
-
`
~
~
+
|
|
-
#
%

वाक्य - विन्यास

एक Firetype स्क्रिप्ट मूल रूप से लाइनों की एक सूची है। प्रत्येक पंक्ति का पहला वर्ण चलने के लिए कमांड है। खाली लाइनें मूल रूप से एनओपी हैं।

शब्दार्थ

आपके पास एक पूर्णांक और एक सूचक है (बीएफ सोचो)। आप सरणी पर बाएँ और दाएँ या "पुश" तत्वों को स्थानांतरित कर सकते हैं।

धक्का

जब आप किसी तत्व को "पुश" करते हैं और आप सरणी के अंत में होते हैं, तो एक अतिरिक्त तत्व को अंत में जोड़ा जाएगा। यदि आप अंत में नहीं हैं, तो अगला तत्व समाप्त हो जाएगा। भले ही, सूचक हमेशा बढ़ जाएगा।

आदेश

_

सरणी पर एक शून्य पुश करें।

+

वर्तमान सूचक पर तत्व बढ़ाएँ।

-

वर्तमान पॉइंटर पर तत्व को घटाएं।

*

वर्तमान सूचक पर डबल तत्व।

/

वर्तमान पॉइंटर पर तत्व को रोकें।

%

तत्व को वर्तमान पॉइंटर पर ले जाएं और आगे कूदें कि कई लाइनें, और पॉइंटर को बाईं ओर ले जाएं। यदि मान ऋणात्मक है, तो इसके बजाय पीछे की ओर कूदें।

=

तत्व को वर्तमान पॉइंटर पर ले जाएं और उस लाइन पर जाएं। 1. उदाहरण के लिए, यदि वर्तमान तत्व है 0, तो यह लाइन पर जाएगा 1। यह पॉइंटर को बाईं ओर भी ले जाता है।

,

मानक इनपुट से एक चरित्र पढ़ें और उसके ASCII मूल्य को धक्का दें।

^

तत्व को वर्तमान सूचक पर ले जाएं, इसे एक वर्ण के लिए ASCII मान के रूप में व्याख्या करें, और इसे एक पूर्णांक में परिवर्तित करें। उदाहरण के लिए, यदि वर्तमान मान 49 (ASCII मान 1) है, तो वर्तमान पॉइंटर का तत्व पूर्णांक पर सेट हो जाएगा 1

.

स्क्रीन पर वर्तमान संख्या लिखें।

!

तत्व को वर्तमान सूचक पर ले जाएं और अगली पंक्ति को कई बार दोहराएं। इसके अलावा पॉइंटर को बाईं ओर ले जाता है।

<

पॉइंटर को बाईं ओर ले जाएं। यदि आप पहले से ही शुरुआत में हैं, तो एक त्रुटि है।

>

पॉइंटर को दाईं ओर ले जाएं। यदि आप पहले से ही अंत में हैं, तो एक त्रुटि है।

~

यदि वर्तमान तत्व नॉनजरो है, तो इसे बदल दें 0; अन्यथा, इसके साथ बदलें 1

|

वर्तमान तत्व को स्क्वायर करें।

@

वर्तमान तत्व को सरणी की लंबाई पर सेट करें।

`

वर्तमान तत्व को डुप्लिकेट करें।

\

पॉइंटर पर और उससे पहले तत्वों को क्रमबद्ध करें।

#

वर्तमान तत्व को हटा दें।

दुभाषी

जीथब में भी उपलब्ध है ।

#!/usr/bin/env python

# The FireType interpreter.
# Runs under Python 2 and 3.
import sys

class Array(object):
    def __init__(self):
        self.array = []
        self.ptr = 0

    def push_zero(self):
        if self.ptr == len(self.array):
            self.array.append(0)
        else:
            self.array[self.ptr] = 0
        self.ptr += 1

    def left(self):
        self.ptr -= 1
        assert self.ptr >= 0 and self.array, 'pointer underflow (at %d)' % i

    def right(self):
        self.ptr += 1
        assert self.ptr <= len(self.array), 'pointer overflow (at %d)' % i

    def sort(self):
        lhs = self.array[:self.ptr-1]
        rhs = self.array[self.ptr-1:]
        lhs.sort()
        lhs.reverse()
        self.array = lhs + rhs

    def __call__(self, *args):
        args = list(args)
        assert self.array, 'out-of-bounds (at %d)' % i
        if not args:
            return self.array[self.ptr-1]
        self.array[self.ptr-1] = args.pop()
        assert not args

    def __len__(self):
        return len(self.array)

    def __str__(self):
        return 'Array(array=%s, ptr=%s)' % (self.array, self.ptr)

    def __repr__(self):
        return 'Array(array=%r, ptr=%r)' % (self.array, self.ptr)

def execute(lines):
    global i, array
    i = 0
    array = Array()
    rep = 0
    while i < len(lines):
        line = lines[i]
        if not line:
            i += 1
            continue
        line = line[0]
        if line == '_':
            array.push_zero()
        elif line == '+':
            array(array() + 1)
        elif line == '-':
            array(array() - 1)
        elif line == '*':
            array(array() * 2)
        elif line == '/':
            array(int(array() / 2))
        elif line == '%':
            i += array()
            array.left()
        elif line == '=':
            i = array()-1
            array.left()
        elif line == ',':
            array.push_zero()
            array(ord(sys.stdin.read(1)))
        elif line == '.':
            sys.stdout.write(str(array()))
        elif line == '!':
            rep = array()
            array.left()
            i += 1
        elif line == '<':
            array.left()
        elif line == '>':
            array.right()
        elif line == '^':
            array(int(chr(array())))
        elif line == '~':
            array(int(not array()))
        elif line == '|':
            array(array() ** 2)
        elif line == '@':
            array(len(array))
        elif line == '`':
            top = array()
            array.push_zero()
            array(top)
        elif line == '\\':
            array.sort()
        elif line == '#':
            array(-array())

        if rep:
            rep -= 1
        else:
            i += 1

def main(args):
    try:
        _, path = args
    except ValueError:
        sys.exit('usage: %s <file to run, - for stdin>')

    if path == '-':
        data = sys.stdin.read()
    else:
        with open(path) as f:
            data = f.read()

    try:
        execute(data.split('\n'))
    except:
        print('ERROR!')
        print('Array was %r' % array)
        print('Re-raising error...')
        raise

if __name__ == '__main__':
    main(sys.argv)

मुझे लगता है कि सरणी के निचले हिस्से के लिए अभिकल्पना छोटी गाड़ी है। चूँकि आप self.ptr-1पहुँच के लिए उपयोग कर रहे हैं , आपको शायद जाँच self.ptr>0नहीं करनी चाहिए >=0। (यह किसी भी वैध कार्यक्रमों को रद्द नहीं करना चाहिए लेकिन हो सकता है कुछ कार्यक्रम बनाने के काम गलती से जो नहीं करना चाहिए।)
मार्टिन Ender

एक और बात: कोड कहता है =कि मान सेट करता है array() - 1, दस्तावेज कहता है +1?
मार्टिन एंडर

फटा। (यह मानते हुए कि दुभाषिया प्रामाणिक है, विवरण नहीं।)
मार्टिन एंडर

@ मार्टिनबटनर डांग, जितना मैंने सोचा था उससे भी तेज था! : OI ने आपके द्वारा उल्लिखित डॉक्टर मुद्दों को निर्धारित किया।
kirbyfan64sos

7

एसीसी !! (सुरक्षित)

यह बेक है ...

यहाँ छवि विवरण दर्ज करें

... और उम्मीद है कि निश्चित रूप से अधिक खामी साबित होगी।

मैंने पहले ही Acc पढ़ा ! कल्पना। कैसा है Acc !! विभिन्न?

में एसीसी !! लूप से बाहर निकलने पर लूप वैरिएबल स्कोप के दायरे से बाहर चला जाता है। आप केवल लूप के अंदर उनका उपयोग कर सकते हैं। बाहर, आपको "नाम परिभाषित नहीं है" त्रुटि मिलेगी। इस बदलाव के अलावा, भाषाएं समान हैं।

बयान

कमांड लाइन द्वारा पार्स लाइन हैं। आदेश के तीन प्रकार हैं:

  1. Count <var> while <cond>

<var>जब तक 0 से गिना जाता है<cond>C ++ के बराबर, नॉनज़रो है, हैfor(int <var>=0; <cond>; <var>++) । लूप काउंटर कोई एकल लोअरकेस अक्षर हो सकता है। शर्त किसी भी अभिव्यक्ति हो सकती है, जरूरी नहीं कि लूप चर को शामिल किया जाए। स्थिति की वैल्यू 0 हो जाने पर लूप रुक जाता है।

लूप्स के लिए K & R- शैली घुंघराले ब्रेसिज़ की आवश्यकता होती है (विशेष रूप से, स्ट्रॉस्ट्रुप संस्करण ))

Count i while i-5 {
 ...
}

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

  1. Write <charcode>

दिए गए ASCII / यूनिकोड मान के साथ एकल वर्ण को स्टडआउट करने के लिए आउटपुट देता है। चारकोल कोई भी अभिव्यक्ति हो सकती है।

  1. अभिव्यक्ति

स्वयं द्वारा खड़ी किसी भी अभिव्यक्ति का मूल्यांकन किया जाता है और उसे वापस संचायक (जो कि सुलभ है _) को सौंपा जाता है । इस प्रकार, उदाहरण के लिए, 3एक बयान है जो संचायक को 3 पर सेट करता है; _ + 1संचायक को बढ़ाता है; और _ * Nएक चरित्र को पढ़ता है और संचयकर्ता को उसके चारकोड द्वारा गुणा करता है।

नोट: संचायक एकमात्र चर है जिसे सीधे सौंपा जा सकता है; लूप चर और Nगणना में इस्तेमाल किया जा सकता है लेकिन संशोधित नहीं।

संचायक शुरू में 0 होता है।

भाव

संचयकर्ता के लिए एक अभिव्यक्ति में पूर्णांक शाब्दिक, लूप चर ( a-z) शामिल हो सकते हैं _, और विशेष मूल्य N, जो एक चरित्र को पढ़ता है और हर बार इसका उपयोग करते समय इसके चारकोड का मूल्यांकन करता है। नोट: इसका मतलब है कि आप प्रत्येक चरित्र को पढ़ने के लिए केवल एक शॉट प्राप्त करते हैं; अगली बार जब आप उपयोग करेंगेN करेंगे, तो आप अगले को पढ़ेंगे।

ऑपरेटर हैं:

  • +, इसके अलावा
  • -, घटाव; एकतरफा नकार
  • *, गुणन
  • /, पूर्णांक विभाजन
  • %, मोडुलो
  • ^, प्रतिपादक

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

व्हॉट्सएप और टिप्पणियां

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

# एकल-पंक्ति टिप्पणी शुरू करता है।

इनपुट आउटपुट

एसीसी !! इनपुट के रूप में वर्णों की एक पंक्ति की अपेक्षा करता है। प्रत्येक इनपुट चरित्र को अनुक्रम में पुनर्प्राप्त किया जा सकता है और इसके चारकोड का उपयोग करके संसाधित किया जा सकता है N। पंक्ति के अंतिम वर्ण को पढ़ने की कोशिश करने से त्रुटि होती है। एक चरित्र का उत्पादन उसके चारकोड को पारित करके किया जा सकता हैWrite बयान ।

दुभाषिया

दुभाषिया (पायथन 3 में लिखा हुआ) Acc का अनुवाद करता है !! पायथन में कोड और execइसे एस।

import re, sys

def main():
    if len(sys.argv) != 2:
        print("Please supply a filename on the command line.", file=sys.stderr)
        return
    codeFile = sys.argv[1]
    with open(codeFile) as f:
        code = f.readlines()
    code = translate(code)
    exec(code, {"inputStream": (ord(char) for char in input())})

def translate(accCode):
    indent = 0
    loopVars = []
    pyCode = ["_ = 0"]
    for lineNum, line in enumerate(accCode):
        if "#" in line:
            # Strip comments
            line = line[:line.index("#")]
        line = line.strip()
        if not line:
            continue
        lineNum += 1
        if line == "}":
            if indent:
                loopVar = loopVars.pop()
                pyCode.append(" "*indent + loopVar + " += 1")
                indent -= 1
                pyCode.append(" "*indent + "del " + loopVar)
            else:
                raise SyntaxError("Line %d: unmatched }" % lineNum)
        else:
            m = re.fullmatch(r"Count ([a-z]) while (.+) \{", line)
            if m:
                expression = validateExpression(m.group(2))
                if expression:
                    loopVar = m.group(1)
                    pyCode.append(" "*indent + loopVar + " = 0")
                    pyCode.append(" "*indent + "while " + expression + ":")
                    indent += 1
                    loopVars.append(loopVar)
                else:
                    raise SyntaxError("Line %d: invalid expression " % lineNum
                                      + m.group(2))
            else:
                m = re.fullmatch(r"Write (.+)", line)
                if m:
                    expression = validateExpression(m.group(1))
                    if expression:
                        pyCode.append(" "*indent
                                      + "print(chr(%s), end='')" % expression)
                    else:
                        raise SyntaxError("Line %d: invalid expression "
                                          % lineNum
                                          + m.group(1))
                else:
                    expression = validateExpression(line)
                    if expression:
                        pyCode.append(" "*indent + "_ = " + expression)
                    else:
                        raise SyntaxError("Line %d: invalid statement "
                                          % lineNum
                                          + line)
    return "\n".join(pyCode)

def validateExpression(expr):
    "Translates expr to Python expression or returns None if invalid."
    expr = expr.strip()
    if re.search(r"[^ 0-9a-z_N()*/%^+-]", expr):
        # Expression contains invalid characters
        return None
    elif re.search(r"[a-zN_]\w+", expr):
        # Expression contains multiple letters or underscores in a row
        return None
    else:
        # Not going to check validity of all identifiers or nesting of parens--
        # let the Python code throw an error if problems arise there
        # Replace short operators with their Python versions
        expr = expr.replace("^", "**")
        expr = expr.replace("/", "//")
        # Replace N with a call to get the next input character
        expr = expr.replace("N", "inputStream.send(None)")
        return expr

if __name__ == "__main__":
    main()

उपाय

मूल Acc का पतन !लूप चर था जो उनके छोरों के बाहर सुलभ होना जारी था। इसने संचायक की बचत प्रतियों की अनुमति दी, जिसने समाधान को बहुत आसान बना दिया।

यहाँ, इस लूप होल के बिना (सॉरी), हमारे पास सामान संचित करने के लिए केवल संचायक है। कार्य को हल करने के लिए, हालांकि, हमें चार मनमाने ढंग से बड़े मूल्यों को संग्रहीत करने की आवश्यकता है। 1 समाधान: अपने बिट्स को इंटरलेव करें और परिणामी संयोजन संख्या को संचयकर्ता में संग्रहीत करें। उदाहरण के लिए, 6437 का एक संचायक मान निम्नलिखित डेटा को संग्रहीत करेगा (एकल-बिट ध्वज के रूप में निम्नतम-ऑर्डर बिट का उपयोग करके):

1100100100101  Binary representation of accumulator
321032103210F  Key

The flag is 1 and the four numbers are
Number 0: 010 = 2
Number 1: 001 = 1
Number 2: 100 = 4
Number 3: 110 = 6

हम संचायक को 2 की उपयुक्त शक्ति से विभाजित करके किसी भी संख्या के किसी भी बिट तक पहुंच सकते हैं, mod 2. यह व्यक्तिगत बिट्स को स्थापित करने या फ़्लर्ट करने की अनुमति देता है।

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

सबसे कठिन हिस्सा (और मेरे पास पहले अवतार में वैश्विक लूप चर था) यह जानने के लिए कि क्या उन्हें सूंघना है, दो नंबरों की तुलना कर रहे हैं। दो बिट्स की तुलना करने के लिए, हम एक सत्य तालिका को गणितीय अभिव्यक्ति में बदल सकते हैं; Acc के लिए मेरी सफलता !!एक तुलना एल्गोरिथ्म खोज रहा था जो निम्न-क्रम से उच्च-क्रम बिट्स तक आगे बढ़ा, क्योंकि वैश्विक चर के बिना बाएं से दाएं की संख्या के बिट्स पर लूप करने का कोई तरीका नहीं है। संचायक का निम्नतम-ऑर्डर बिट एक ध्वज को संग्रहीत करता है जो संकेत देता है कि वर्तमान में विचाराधीन दो संख्याओं को स्वैप करना है या नहीं।

मुझे संदेह है कि Acc !! ट्यूरिंग-पूर्ण है, लेकिन मुझे यकीन नहीं है कि मैं इसे साबित करने की परेशानी में जाना चाहता हूं।

यहाँ टिप्पणियों के साथ मेरा समाधान है:

# Read and process numbers until the double 0

Count y while N-48 {
    # Read unary number and store it (as binary) in number 0
    # The above loop header consumed the first 1, so we need to add 1 to number 0

    _ + 2

    # Increment number 0 for each 1 in input until next 0

    Count z while N-48 {
        # In this context, the flag indicates a need to carry; set it to 1
        _ - _%2 + 1

        # While carry flag is set, increment the next bit in line
        Count i while _%2 {
            # Set carry flag to 1 if i'th bit is 1, 0 if it's 0
            # Set i'th bit to 1 if it was 0, 0 if it was 1
            _ - _%2 + _/2^(i*4+1)%2 + (-1)^(_/2^(i*4+1)%2)*2^(i*4+1)
        }
    }

    # Bubble number 0 upwards

    Count n while n-3 {
        # The flag (rightmost bit of accumulator) needs to become 1 if we want to swap
        # numbers (n) and (n+1) and 0 if we don't
        # Iterate over bit-groups of accumulator, RTL
        Count i while _/2^(i*4+1) {
            # Adjust the flag as follows:
            # _/2^(i*4+n+1)%4 is the current bit of number (n+1) followed by the current
            # bit of number (n), a value between 0 and 3
            # - If this quantity is 1 (01), number (n) is bigger so far; set flag to 1
            # - If this quantity is 2 (10), number (n+1) is bigger so far; set flag to 0
            # - If this quantity is 0 (00) or 3 (11), the two bits are the same; keep
            #   current value of flag
            _ + (_/2^(i*4+n+1)%4%3 + 1)/2*(_/2^(i*4+n+1)%4%3%2 - _%2)
        }

        # Now swap the two if the flag is 1
        Count i while (_%2)*(_/2^(i*4+1)) {
            # _/2^(i*4+n+1)%2 is the current bit of number (n)
            # _/2^(i*4+n+2)%2 is the current bit of number (n+1)
            _ - (_/2^(i*4+n+1)%2)*2^(i*4+n+1) - (_/2^(i*4+n+2)%2)*2^(i*4+n+2) + (_/2^(i*4+n+2)%2)*2^(i*4+n+1) + (_/2^(i*4+n+1)%2)*2^(i*4+n+2)
        }
    }

    # Discard number 0, setting it to all zeros for the next iteration
    Count i while _/2^(i*4+1) {
        _ - _/2^(i*4+1)%2*2^(i*4+1)
    }
}

# Once the loop is over, all input has been read and the result is in number 1
# Divide by 2 to get rid of flag bit

_ / 2

# Zero out numbers 2 and 3

Count i while _/2^(i*4) {
    _ - _/2^(i*4+2)%2*2^(i*4+2)
}

Count i while _/2^(i*4) {
    _ - _/2^(i*4+3)%2*2^(i*4+3)
}

# Move bits of number 1 down to their final locations

Count i while _/2^i {
    _ - _/2^(i*4+1)%2*2^(i*4+1) + _/2^(i*4+1)%2*2^i
}

# _ now contains the correct answer in decimal; to output in unary:

Count z while z-_ {
    Write 49
}

1 प्रश्न युक्ति के अनुसार, केवल 1 मिलियन तक के मूल्यों का समर्थन किया जाना चाहिए। मुझे खुशी है कि आसान समाधान के लिए किसी ने भी इसका फायदा नहीं उठाया - हालांकि मैं पूरी तरह से निश्चित नहीं हूं कि आप तुलना कैसे करेंगे।


LOL @ बिल द कैट पिक्चर
एक स्पेगेटो

7

पिकोफ़क (सुरक्षित)

Picofuck के समान है Smallfuck । यह एक बाइनरी टेप पर संचालित होता है जो दाईं ओर अनबाउंड होता है, बाईं ओर बाध्य होता है। इसकी निम्न आज्ञाएँ हैं:

  • > पॉइंटर को सही से घुमाएं

  • <पॉइंटर छोड़ दिया। यदि सूचक टेप से गिर जाता है, तो प्रोग्राम समाप्त हो जाता है।

  • * पॉइंटर पर थोड़ा पलटें

  • (यदि सूचक पर बिट है 0, तो अगले पर जाएं)

  • )कुछ न करें - पिकोफक में कोष्ठक ifब्लॉक हैं, whileलूप नहीं ।

  • .एक ascii के रूप में सूचक पर बिट stdout को लिखने 0या 1

  • ,स्टड से पढ़ें जब तक हम एक 0या मुठभेड़ नहीं करते हैं 1, और इसे सूचक में बिट में संग्रहीत करें।

पिकोफक कोड लपेटता है - एक बार कार्यक्रम के अंत तक पहुंचने के बाद, यह शुरुआत से जारी है।

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

दुभाषिया

पायथन 2.7 में लिखा गया है

उपयोग: python picofuck.py <source_file>

import sys

def interpret(code):
    # Ensure parentheses match and are not nested.
    in_if_block = False
    for c in code:
        if c == '(':
            if in_if_block:
                print "NESTED IFS DETECTED!!!!!"
                return
            in_if_block = True
        elif c == ')':
            if not in_if_block:
                print "Unmatched parenthesis"
                return
            in_if_block = False
    if in_if_block:
        print "Unmatched parenthesis"
        return


    code_ptr = 0
    array = [0]
    ptr = 0

    while 1:
        command = code[code_ptr]
        if command == '<':
            if ptr == 0:
                break
            ptr -= 1
        elif command == '>':
            ptr += 1
            if ptr == len(array):
                array.append(0)
        elif command == '*':
            array[ptr] = 1-array[ptr]
        elif command == '(':
            if array[ptr] == 0:
                while code[code_ptr] != ')':
                    code_ptr = (code_ptr + 1) % len(code)
        elif command == ',':
            while True:
                c = sys.stdin.read(1)
                if c in ['0','1']:
                    array[ptr] = int(c)
                    break
        elif command == '.':
            sys.stdout.write(str(array[ptr]))
        code_ptr = (code_ptr+1)%len(code)

if __name__ == "__main__":
    with open(sys.argv[1]) as source_file:
        code = source_file.read()
    interpret(code)

उपाय

निम्नलिखित अजगर 2.7 कार्यक्रम मेरे समाधान को आउटपुट करता है जो यहां पाया जा सकता है

मैं इस पोस्ट को बाद में और अधिक गहन विवरण के साथ संपादित कर सकता हूं कि यह कैसे काम करता है, लेकिन यह पता चलता है कि पिकोफक ट्यूरिंग-पूर्ण है।

states = {
    "SETUP":(
        "*>",
        "GET_NUMBER",
        "GET_NUMBER"
    ),

    "GET_NUMBER":(
        ",",
        "CHANGE_A",
        "PREPARE_PRINT_C"
    ),

    "GET_DIGIT":(
        ",",
        "CHANGE_A",
        "GOT_DIGIT"
    ),

    "GOT_DIGIT":(
        ">>>>",
        "GO_BACK",
        "GO_BACK"
    ),

    "CHANGE_A":(
        ">",
        "CHANGE_B",
        "SET_A"
    ),

    "SET_A":(
        "*>>>>",
        "GET_DIGIT",
        "GET_DIGIT"
    ),

    "CHANGE_B":(
        ">",
        "CHANGE_C",
        "SET_B"
    ),

    "SET_B":(
        "*>>>",
        "GET_DIGIT",
        "GET_DIGIT"
    ),

    "CHANGE_C":(
        ">",
        "CONTINUE_GET_NUMBER",
        "SET_C"
    ),

    "SET_C":(
        "*>>",
        "GET_DIGIT",
        "GET_DIGIT"
    ),

    "CONTINUE_GET_NUMBER":(
        ">>",
        "GET_DIGIT",
        "GET_DIGIT"
    ),

    "GO_BACK":(
        "<<<<<",
        "FINISH_GO_BACK",
        "GO_BACK"
    ),

    "FINISH_GO_BACK":(
        ">",
        "GET_NUMBER",
        "GET_NUMBER"
    ),

    "PREPARE_PRINT_C":(
        ">>>",
        "PRINT_C",
        "PRINT_C"
    ),

    "PRINT_C":(
        ".>>>>>",
        "PRINT_C",
        "TERMINATE"
    ),

    "TERMINATE":(
        "<",
        "TERMINATE",
        "TERMINATE"
    ),
}

def states_to_nanofuck(states,start_state):
    state_list = list(states)
    state_list.remove(start_state)
    state_list.insert(0,start_state)

    states_by_index = []
    for i,state in enumerate(state_list):
        commands, next1, next0 = states[state]
        states_by_index.append((commands,state_list.index(next1),state_list.index(next0)))


    # setup first state
    fragments = ['*(*>>>>>*<<<<<)>>>>>']

    # reset states that don't match
    for index in range(len(states_by_index)):
        for bool in range(2):
            # at state_0_0
            state_dist = index*3 + bool
            # move state to curstate
            fragments.append('>'*state_dist)
            fragments.append('(*')
            fragments.append(  '<'*state_dist)
            fragments.append(  '<<*>>')
            fragments.append(  '>'*state_dist)
            fragments.append(')')
            fragments.append('<'*state_dist)

            # go to arr
            fragments.append('<<<')

            if bool == 0:
                #flip arr
                fragments.append('*')

            # compute match = arr & curstate
            fragments.append('(>)(>*<)<(<)>')

            if bool == 0:
                #flip arr
                fragments.append('*')

            # reset curstate
            fragments.append('>(*)')

            # move match to matchstate, go back to state_0_0
            matchstate_dist = index*3 + 2
            fragments.append('>(*>')
            fragments.append(  '>'*matchstate_dist)
            fragments.append(  '*')
            fragments.append(  '<'*matchstate_dist)
            fragments.append('<)>')

    #fragments.append('|')

    # do the commands of the matching state
    for index,state in enumerate(states_by_index):
        for bool in range(2):
            # at state_0_0
            matchstate_dist = index*3 + 2
            # move matchstate to curstate
            fragments.append('>'*matchstate_dist)
            fragments.append('(*')
            fragments.append(  '<'*matchstate_dist)
            fragments.append(  '<<*>>')
            fragments.append(  '>'*matchstate_dist)
            fragments.append(')')
            fragments.append('<'*matchstate_dist)

            # if curstate, reset curstate
            fragments.append('<<(*')

            # go to arr
            fragments.append('<')

            # do commands
            commands,next1,next0 = state
            for c in commands:
                if c in '<>':
                    fragments.append(c*(3*len(states_by_index)+5))
                else:
                    fragments.append(c)

            # go to state_0_0
            fragments.append('>>>')

            # set next states
            for dist in [next0*3, next1*3+1]:
                fragments.append('>'*dist)
                fragments.append('*')
                fragments.append('<'*dist)

            # go to curstate
            fragments.append('<<')

            # end if
            fragments.append(')')

            # go to state_0_0
            fragments.append('>>')


    # go back to setup and set it
    fragments.append('<<<<<*')

    code = ''.join(fragments)

    return code



print states_to_nanofuck(states, "SETUP")

2
लगभग 2 साल इंतजार करता है क्या यह बाद में है?
कैलक्यूलेटरफ्लीन

सिर्फ FYI करें, आपके द्वारा प्रदान किया गया लिंक अब मृत हो गया है। '
कॉनर ओ'ब्रायन

लिंक को डाउनलोड की आवश्यकता है और मैं बहुत आलसी हूं। कृपया ठीक करें।
कैलकुलेटर

@CalculatorFeline यह 13KB है, इसे डाउनलोड के रूप में संभालना बहुत आसान है।
mbomb007

7

PQRS - सुरक्षित! / समाधान प्रदान किया गया

मूल बातें

सभी निहित निर्देशों में चार मेमोरी एड्रेस ऑपरेंड हैं:

P₀ Q₀ R₀ S₀
P₁ Q₁ R₁ S₁
...
Pᵥ₋₁ Qᵥ₋₁ Rᵥ₋₁ Sᵥ₋₁

vचौकड़ी में स्मृति का आकार कहां है।

Pᵢ, Qᵢ, Rᵢ, Sᵢ(उदाहरण के लिए 16, 32 या 64 बिट्स) जो हम शब्दों के रूप में करने के लिए संदर्भित करेंगे पर हस्ताक्षर किए जिसमें आपकी मशीन का देशी आकार में पूर्णांकों कर रहे हैं।

प्रत्येक चौकड़ी के लिए i, अंतर्निहित ऑपरेशन, []अप्रत्यक्ष रूप से दर्शाते हुए, है:

if (([Pᵢ] ← [Qᵢ] − [Rᵢ]) ≤ 0) go to Sᵢ else go to Pᵢ₊₁

ध्यान दें कि Subleq PQRS का सबसेट है ।

Subleq पूर्ण सिद्ध हुआ है, इसलिए PQRS भी पूर्ण होना चाहिए!

कार्यक्रम की संरचना

PQRS एक प्रारंभिक हेडर को निम्नानुसार परिभाषित करता है:

H₀ H₁ H₂ H₃ H₄ H₅ H₆ H₇

H₀ H₁ H₂ H₃ हमेशा पहला निर्देश है P₀ Q₀ R₀ S₀ । लोड समय पर परिभाषित H₀करने की H₃आवश्यकता है।

PQRS में अल्पविकसित I / O है, लेकिन चुनौती के लिए पर्याप्त है।

H₄ H₅: कार्यक्रम की शुरुआत में, यह H₅मानक इनपुट से अधिकतम ASCII वर्णों में पढ़ता है और H₄बाद में सूचकांक में शब्दों के रूप में बचाता है । H₄तथा H₅ लोड समय पर परिभाषित करने की आवश्यकता है। पढ़ने के बाद, H₅पढ़े गए अक्षरों की संख्या (और सहेजे गए शब्द) पर सेट हो जाएगा।

H₆ H₇: कार्यक्रम समाप्ति पर, इंडेक्स पर शुरू H₆, यह सभी बाइट्स को अंकित करता है, जिसमें H₇शब्दों को मानक आउटपुट में ASCII वर्णों के रूप में शामिल किया गया है । H₆और H₇कार्यक्रम समाप्त होने से पहले इसे परिभाषित करने की आवश्यकता है। '\0'आउटपुट में नल बाइट्स को छोड़ दिया जाएगा।

समाप्ति

समाप्ति Sᵢसीमा से बाहर निकल i < 0कर या प्राप्त की जाती है i ≥ v

ट्रिक्स

चौकड़ी को Pᵢ Qᵢ Rᵢ Sᵢसंरेखित या अनुक्रमिक नहीं होना चाहिए, उप-चतुर्थक अंतराल पर शाखाओं की अनुमति है।

पीक्यूआरएस में अप्रत्यक्ष रूप से है, इसलिए सुबल के विपरीत, सबरूटीन्स को लागू करने के लिए पर्याप्त लचीलापन है।

कोड स्व-संशोधित हो सकता है!

दुभाषिया

दुभाषिया सी में लिखा है:

#include <stdlib.h>
#include <stdio.h>

// The "architecture"
enum {P, Q, R, S, START_OF_INPUT, LENGTH_OF_INPUT, START_OF_OUTPUT, LENGTH_OF_OUTPUT};
const int NEXT = S + 1;

// Recommend optimized!
#define OPTIMIZED

#ifdef PER_SPECS
// This may not work on all OSes and architectures - just too much memory needed!
const int K = 1002000200;
#else // OPTIMIZED
// This provides enough space to run the test cases with challenge-optimized.pqrs
const int K = 5200;
#endif

int main(int argc, char *argv[])
{
    int i, *M;
    char *p;
    FILE *program;

    // Allocate enough memory
    M = calloc(K, sizeof(int));

    // Load the program
    for (i = 0, program = fopen(argv[1], "r"); i < K && !feof(program); i++)
        if (!fscanf(program, "%d", M + i))
            break;
    fclose(program);

    // Read in the input
    for (i = 0; i < M[LENGTH_OF_INPUT] && !feof(stdin); i++)
    {
        int c = fgetc(stdin);
        if (c != EOF)
            M[M[START_OF_INPUT] + i] = c;
        else
            break;
    }
    M[LENGTH_OF_INPUT] = i;

    // Execute until terminated
    for (i = 0; i >= 0 && i < K; )
        i = (M[M[P + i]] = M[M[Q + i]] - M[M[R + i]]) <= 0? M[S + i]: i + NEXT;

    // Write the output
    for (i = 0, p = (char *)(M + M[START_OF_OUTPUT]); i < M[LENGTH_OF_OUTPUT] * sizeof(int); i++)
        // Ignore '\0'
        if (p[i])
            fputc(p[i], stdout);

    // Done
    free(M);

    return 0;
}

उपयोग करने के लिए, ऊपर pqrs.c के रूप में सहेजें फिर संकलित करें:

gcc -o pqrs pqrs.c

नमूना कार्यक्रम

40 पात्रों तक इकोस इनपुट, 'PQRS-' द्वारा पूर्व में।

8 8 8 -1 14 40 9 45 0 80 81 82 83 45

चलाने के लिए, ऊपर के रूप में सहेजें echo.pqrs, फिर:

$ ./prqs echo.pqrs
greetings[enter]
[ctrl-D]
PQRS-greetings

परीक्षण मामलों को चलाना:

$ ./pqrs challenge-optimized.pqrs < test-1.txt
1

$ ./pqrs challenge-optimized.pqrs < test-2.txt
11111111111111111

$ ./pqrs challenge-optimized.pqrs < test-3.txt
[lots of ones!]

$ ./pqrs challenge-optimized.pqrs < test-3.txt | wc
0       1     773

सभी परीक्षण मामले बहुत तेज़ी से चलते हैं, उदाहरण के लिए <500 ms।

चुनौती

PQRS को स्थिर माना जा सकता है, इसलिए चुनौती 2015-10-31 13:00 से शुरू होती है और UTC में 2015-11-08 13:00 तक समाप्त होती है।

सौभाग्य!

उपाय

भाषा "बेबी" में उपयोग किए जाने वाले समान है - दुनिया की पहली संग्रहीत प्रोग्राम इलेक्ट्रॉनिक डिजिटल मशीन। उस पृष्ठ पर (CRT!) मेमोरी के 32 शब्दों से कम में पूर्णांक का उच्चतम कारक खोजने का एक कार्यक्रम है!

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

पीक्यूआरएस में सीधे कोड करना बहुत मुश्किल है , मशीन भाषा लिखने के लिए, शायद माइक्रोकोड भी। इसके बजाय एक तरह की असेंबली भाषा में लिखना आसान होता है, फिर इसे "कंपाइल" करें। परीक्षण मामलों को चलाने के लिए अनुकूलित समाधान के लिए नीचे विधानसभा भाषा दी गई है:

; ANNOTATED PQRS ASSEMBLER CODE
; MINIMAL SIZED BUFFERS TO RUN THE TEST CASES

;OFFSET   LABEL       P-OP        Q-OP        R-OP        S-OP
0                     TEMP        ZERO        ZERO        L1

; INPUT AND OUTPUT LOCATIONS AND SIZES
4                     INPUT       4000        
6         L0:         OUTPUT      1000        

; GET CURRENT INPUT
8         L1:         TEMP        INPUT       ASCII_ZERO  L2
12                    SUM         SUM         INC         IGNORE
16                    L1+1        L1+1        INC         IGNORE
20                    TEMP        ZERO        ZERO        L1

; CHECK IF END OF NUMBERS
24        L2:         NUMBERS     SUM         ZERO        L3

; ADVANCE TO NEXT NUMBER
28                    L2          L2          INC         IGNORE

; ADVANCE COUNT
32                    COUNT       COUNT       INC         IGNORE
36                    L1+1        L1+1        INC         IGNORE

; CLEAR SUM AND GO BACK
40                    SUM         ZERO        ZERO        L1

; SORT NUMBERS                
44        L3:         P           NUMBERS     ZERO        LA
48        L4:         Q           NUMBERS+1   ZERO        L9

; COMPARE                
52                    TEMP        Q           P           L8

; SWAP IF OUT OF ORDER
56                    L5+1        L3+1        ZERO        IGNORE
60                    L6          L3+1        ZERO        IGNORE
64                    L6+1        L4+1        ZERO        IGNORE
68                    L7          L4+1        ZERO        IGNORE
72        L5:         TEMP        P           ZERO        IGNORE
76        L6:         P           Q           ZERO        IGNORE
80        L7:         Q           TEMP        ZERO        IGNORE

; INCREMENT INNER INDEX
84        L8:         L4+1        L4+1        INC         IGNORE
88                    TEMP        ZERO        ZERO        L3

; INCREMENT OUTER INDEX AND RESET INNER INDEX
92        L9:         L3+1        L3+1        INC         IGNORE
96                    L4+1        L3+1        INC         IGNORE
100                   TEMP        ZERO        ZERO        L3

; OUTPUT THIRD LARGEST NUMBER
104                   L0+1        NUMBERS+2   ZERO        IGNORE
108       LA:         TEMP        NUMBERS+2   ZERO        EXIT
112       LB:         OUTPUT      ASCII_ONE   ZERO        IGNORE
116                   LB          LB          INC         IGNORE
120                   NUMBERS+2   NUMBERS+2   DEC         EXIT
124                   TEMP        ZERO        ZERO        LA

; SAFETY LOOP – JUST IN CASE IGNORE DOESN'T WORK AS PLANNED!
128       IGNORE:     TEMP        ZERO        ZERO        IGNORE

; CONSTANTS
132       ZERO:        0
133       INC:        -1
134       DEC:         1
135       ASCII_ZERO: 48
136       ASCII_ONE:  49

; VARIABLES
137       TEMP:       [1]
138       SUM:        [1]
139       COUNT:      [1]
140       P:          [1]
141       Q:          [1]

; WORKING SPACE
142       NUMBERS:    [10]

; I/O SPACE
152       INPUT:      [4000]
4152      OUTPUT:     [1000]
5152

यह इनपुट को पार्स करता है, यूनरी को बाइनरी में परिवर्तित करता है, फिर घटते क्रम में मूल्यों के साथ संख्याओं पर एक बुलबुला छंटनी करता है, फिर अंत में बाइनरी को यूनरी में परिवर्तित करके तीसरे सबसे बड़े मूल्य को आउटपुट करता है।

ध्यान दें कि INC(वेतन वृद्धि) नकारात्मक है और (वेतन वृद्धि) DECसकारात्मक है! यह कहाँ उपयोग कर रहा है L#या L#+1के रूप में P-या Q-OPबढ़ाने, decrementing, अदला-बदली, आदि कोडांतरक हाथ करने के लिए संकलित किया गया था: रों, क्या हो रहा है कि यह संकेत अपडेट कर रहा है है PQRS ऑफसेट के साथ लेबल प्रतिस्थापन। नीचे PQRS अनुकूलित समाधान है:

137 132 132 8
152 4000
4152 1000
137 152 135 24
138 138 133 128
9 9 133 128
137 132 132 8
142 138 132 44
24 24 133 128
139 139 133 128
9 9 133 128
138 132 132 8
140 142 132 108
141 143 132 92
137 141 140 84
73 45 132 128
76 45 132 128
77 49 132 128
80 49 132 128
137 140 132 128
140 141 132 128
141 137 132 128
49 49 133 128
137 132 132 44
45 45 133 128
49 45 133 128
137 132 132 44
7 144 132 128
137 144 132 -1
4152 136 132 128
112 112 133 128
144 144 134 -1
137 132 132 108
137 132 132 128
0
-1
1
48
49

challenge-optimized.pqrsपरीक्षण मामलों को चलाने के लिए ऊपर दिए गए कोड को सहेजा जा सकता है ।

पूर्णता के लिए, यहाँ प्रति चश्मा स्रोत हैं:

; ANNOTATED PQRS ASSEMBLER CODE
; FULL SIZED BUFFERS TO RUN ACCORDING TO SPECS

;OFFSET   LABEL       P-OP        Q-OP        R-OP        S-OP
0                     TEMP        ZERO        ZERO        L1

; INPUT AND OUTPUT LOCATIONS AND SIZES
4                     INPUT       10^9        
6         L0:         OUTPUT      10^6        

; GET CURRENT INPUT
8         L1:         TEMP        INPUT       ASCII_ZERO  L2
12                    SUM         SUM         INC         IGNORE
16                    L1+1        L1+1        INC         IGNORE
20                    TEMP        ZERO        ZERO        L1

; CHECK IF END OF NUMBERS
24        L2:         NUMBERS     SUM         ZERO        L3

; ADVANCE TO NEXT NUMBER
28                    L2          L2          INC         IGNORE

; ADVANCE COUNT
32                    COUNT       COUNT       INC         IGNORE
36                    L1+1        L1+1        INC         IGNORE

; CLEAR SUM AND GO BACK
40                    SUM         ZERO        ZERO        L1

; SORT NUMBERS                
44        L3:         P           NUMBERS     ZERO        LA
48        L4:         Q           NUMBERS+1   ZERO        L9

; COMPARE                
52                    TEMP        Q           P           L8

; SWAP IF OUT OF ORDER
56                    L5+1        L3+1        ZERO        IGNORE
60                    L6          L3+1        ZERO        IGNORE
64                    L6+1        L4+1        ZERO        IGNORE
68                    L7          L4+1        ZERO        IGNORE
72        L5:         TEMP        P           ZERO        IGNORE
76        L6:         P           Q           ZERO        IGNORE
80        L7:         Q           TEMP        ZERO        IGNORE

; INCREMENT INNER INDEX
84        L8:         L4+1        L4+1        INC         IGNORE
88                    TEMP        ZERO        ZERO        L3

; INCREMENT OUTER INDEX AND RESET INNER INDEX
92        L9:         L3+1        L3+1        INC         IGNORE
96                    L4+1        L3+1        INC         IGNORE
100                   TEMP        ZERO        ZERO        L3

; OUTPUT THIRD LARGEST NUMBER
104                   L0+1        NUMBERS+2   ZERO        IGNORE
108       LA:         TEMP        NUMBERS+2   ZERO        EXIT
112       LB:         OUTPUT      ASCII_ONE   ZERO        IGNORE
116                   LB          LB          INC         IGNORE
120                   NUMBERS+2   NUMBERS+2   DEC         EXIT
124                   TEMP        ZERO        ZERO        LA

; SAFETY LOOP – JUST IN CASE IGNORE DOESN'T WORK AS PLANNED!
128       IGNORE:     TEMP        ZERO        ZERO        IGNORE

; CONSTANTS
132       ZERO:        0
133       INC:        -1
134       DEC:         1
135       ASCII_ZERO: 48
136       ASCII_ONE:  49

; VARIABLES
137       TEMP:       [1]
138       SUM:        [1]
139       COUNT:      [1]
140       P:          [1]
141       Q:          [1]

; WORKING SPACE
142       NUMBERS:    [10^6]

; I/O SPACE
1000142   INPUT:      [10^9]
1001000142 OUTPUT:    [10^6]
1002000142

और समाधान:

137 132 132 8
1000142 1000000000
1001000142 1000000
137 1000142 135 24
138 138 133 128
9 9 133 128
137 132 132 8
142 138 132 44
24 24 133 128
139 139 133 128
9 9 133 128
138 132 132 8
140 142 132 108
141 143 132 92
137 141 140 84
73 45 132 128
76 45 132 128
77 49 132 128
80 49 132 128
137 140 132 128
140 141 132 128
141 137 132 128
49 49 133 128
137 132 132 44
45 45 133 128
49 45 133 128
137 132 132 44
7 144 132 128
137 144 132 -1
1001000142 136 132 128
112 112 133 128
144 144 134 -1
137 132 132 108
137 132 132 128
0
-1
1
48
49

इसके बाद के संस्करण चलाने के लिए आपको बाहर टिप्पणी करने की आवश्यकता होगी #define OPTIMIZEDऔर जोड़ने #define PER_SPECSमें pqrs.cऔर पुनः संकलित करें।

यह एक बड़ी चुनौती थी - वास्तव में मानसिक कसरत का आनंद लिया! मुझे मेरे पुराने 6502 कोडांतरक दिनों में वापस ले गया ...

यदि मैं "वास्तविक" प्रोग्रामिंग भाषा के रूप में PQRS को लागू करने के लिए था , तो मैं शायद प्रत्यक्ष और दोगुनी अप्रत्यक्ष पहुंच के लिए अतिरिक्त साधनों को जोड़ूंगा, साथ ही अप्रत्यक्ष पहुंच के साथ-साथ स्थिति सापेक्ष और स्थिति पूर्ण, दोनों शाखाओं के लिए अप्रत्यक्ष पहुंच विकल्पों के साथ!


3
आपके पास पोस्टिंग से पहले तैयार समाधान होना चाहिए।
feersum

1
हां, घोल तैयार है। मैं समझता हूं कि कुछ संदेह है क्योंकि भाषा वास्तव में काम करने के लिए काफी कठिन है। उन लोगों के लिए जो एक चुपके पूर्वावलोकन चाहते हैं, मैं इसे आपको भेज सकता हूं, बशर्ते आप चुनौती के अंत से पहले इसका खुलासा नहीं करने का वादा करते हैं!

6

जस्ता, फटा! @Zgarb द्वारा

GitHub पर भी उपलब्ध है

आपको डार्ट 1.12 और पब चाहिए। pub getकेवल एक निर्भरता, एक पार्सिंग लाइब्रेरी को डाउनलोड करने के लिए चलाएं ।

यहाँ यह उम्मीद करने के लिए 30 मिनट से अधिक समय तक रहता है! : हे

भाषा

जस्ता पुनर्परिभाषित ऑपरेटरों के आसपास उन्मुख है। आप आसानी से भाषा में सभी ऑपरेटरों को फिर से परिभाषित कर सकते हैं!

एक विशिष्ट जस्ता कार्यक्रम की संरचना इस प्रकार है:

let
<operator overrides>
in <expression>

केवल दो डेटा प्रकार हैं: पूर्णांक और सेट। सेट शाब्दिक जैसी कोई चीज नहीं होती है, और खाली सेट को रोक दिया जाता है।

भाव

जिंक में निम्नलिखित मान्य अभिव्यक्ति हैं:

शाब्दिक

जिंक सभी सामान्य पूर्णांक शाब्दिक, जैसे 1और -2

चर

जस्ता में चर (अधिकांश भाषाओं की तरह) हैं। उन्हें संदर्भित करने के लिए, बस नाम का उपयोग करें। फिर से ज्यादातर भाषाओं की तरह!

हालांकि, एक विशेष चर है जिसे Sपायथ की तरह व्यवहार किया जाता है Q। जब आप पहली बार इसका उपयोग करते हैं, तो यह मानक इनपुट से एक पंक्ति में पढ़ेगा और इसे संख्याओं के एक सेट के रूप में व्याख्या करेगा। उदाहरण के लिए, इनपुट लाइन 1234231सेट में बदल जाएगी {1, 2, 3, 4, 3, 2, 1}

महत्वपूर्ण लेख!!! कुछ मामलों में, एक ऑपरेटर ओवरराइड के अंत में एक शाब्दिक गलत तरीके से पार्स किया जाता है, इसलिए आपको इसे कोष्ठक के साथ घेरना होगा।

बाइनरी ऑपरेशन

निम्नलिखित बाइनरी ऑपरेशन समर्थित हैं:

  • इसके अलावा के माध्यम से +: 1+1
  • घटाव के माध्यम से -: 1-1
  • के माध्यम से गुणा *: 2*2
  • प्रभाग के माध्यम से /: 4/2
  • साथ समानता =: 3=3

साथ ही, निम्न यूनिरी ऑपरेशन भी समर्थित है:

  • लंबाई के साथ #: #x

वरीयता हमेशा सही-सहयोगी होती है। इसे ओवरराइड करने के लिए आप कोष्ठक का उपयोग कर सकते हैं।

केवल समानता और लंबाई सेट पर काम करती है। जब आप पूर्णांक की लंबाई प्राप्त करने की कोशिश करते हैं, तो आपको इसके स्ट्रिंग प्रतिनिधित्व में अंकों की संख्या मिल जाएगी।

समझ स्थापित करें

सेट में हेरफेर करने के लिए, जिंक ने समझ पैदा की है। वे इस तरह दिखते हैं:

{<variable>:<set><clause>}

एक खंड या तो एक खंड या एक प्रकार का खंड होता है।

जब एक खंड जैसा दिखता है ^<expression>। कैरट के बाद की अभिव्यक्ति के परिणामस्वरूप पूर्णांक होना चाहिए। जब क्लॉज का उपयोग सेट में केवल उन तत्वों को ले जाएगा जिनके expressionलिए गैर-शून्य है। अभिव्यक्ति के भीतर, चर _सेट में वर्तमान सूचकांक पर सेट किया जाएगा। यह लगभग इस अजगर के बराबर है:

[<variable> for _, <variable> in enumerate(<set>) when <expression> != 0]

एक तरह का क्लॉज , जो दिखता है $<expression>, के मान से उतरते हुए सेट को सॉर्ट करता है <expression>। यह इस पायथन के बराबर है:

sorted(<set>, key=lambda <variable>: <expression>)[::-1]

यहाँ कुछ व्यापक उदाहरण हैं:

  • सेट के तत्वों को ही लें sजो समान 5:

    {x:s^x=5}
    
  • sयदि इसके तत्व चुकते हैं तो मूल्य द्वारा सेट को क्रमबद्ध करें :

    {x:s$x*x}
    

ओवरराइड

ऑपरेटर ओवरराइड आपको ऑपरेटरों को फिर से परिभाषित करने की अनुमति देता है। वे इस तरह दिखते हैं:

<operator>=<operator>

या:

<variable><operator><variable>=<expression>

पहले मामले में, आप एक ऑपरेटर को दूसरे ऑपरेटर के बराबर परिभाषित कर सकते हैं। उदाहरण के लिए, मैं +वास्तव में इसके माध्यम से घटा सकता हूं :

+=-

जब आप ऐसा करते हैं, तो आप एक ऑपरेटर को एक जादू ऑपरेटर होने के लिए फिर से परिभाषित कर सकते हैं । दो मैजिक ऑपरेटर हैं:

  • joinएक सेट और पूर्णांक लेता है और सेट की सामग्री को जोड़ता है। उदाहरण के लिए, पूर्णांक के {1, 2, 3}साथ जुड़ने 4से परिणाम होगा 14243

  • cutएक सेट और पूर्णांक भी लेता है और पूर्णांक की प्रत्येक घटना पर सेट को विभाजित करेगा। का उपयोग कर cutरहा है {1, 3, 9, 4, 3, 2}और 3बनाएगा {{1}, {9, 4}, {2}}... लेकिन किसी भी एकल-तत्व सेट को चपटा किया जाता है, इसलिए परिणाम वास्तव में होगा {1, {9, 4}, 2}

यहाँ एक उदाहरण दिया गया है जो +ऑपरेटर को फिर से परिभाषित करता है join:

+=join

बाद के मामले के लिए, आप किसी ऑपरेटर को दिए गए एक्सप्रेशन को फिर से परिभाषित कर सकते हैं। एक उदाहरण के रूप में, यह मान जोड़ने के लिए प्लस ऑपरेशन को परिभाषित करता है और फिर 1 जोड़ता है:

x+y=1+:x+:y

लेकिन क्या है +:? आप :बिलियन वर्जन को हमेशा इस्तेमाल करने के लिए कोलन को ऑपरेटर से जोड़ सकते हैं । इस उदाहरण में निर्मित का उपयोग करता है +के माध्यम से +:संख्याओं को एक साथ जोड़ने के लिए है, तो यह एक 1 कहते हैं (याद रखें, सब कुछ ठीक-साहचर्य है)।

लंबाई ऑपरेटर को ओवरराइड करने से ऐसा लगता है:

#x=<expression>

ध्यान दें कि लगभग सभी अंतर्निहित ऑपरेशन (समानता को छोड़कर) सेट की लंबाई निर्धारित करने के लिए इस लंबाई के ऑपरेटर का उपयोग करेंगे। यदि आप इसे परिभाषित करते हैं:

#x=1

जिंक का हर हिस्सा जो सेट पर काम करता है, =केवल उस सेट के पहले तत्व पर काम करता है जो इसे दिया गया था।

एकाधिक ओवरराइड

आप कई ऑपरेटरों को कॉमा से अलग करके ओवरराइड कर सकते हैं:

let
+=-,
*=/
in 1+2*3

मुद्रण

आप सीधे जिंक में कुछ भी नहीं छाप सकते। निम्नलिखित अभिव्यक्ति का परिणाम inमुद्रित किया जाएगा। एक सेट के मूल्यों को विभाजक के साथ समवर्ती किया जाएगा। उदाहरण के लिए, इसे लें:

let
...
in expr

यदि exprसेट है {1, 3, {2, 4}}, 1324तो कार्यक्रम पूरा होने के बाद स्क्रीन पर प्रिंट किया जाएगा।

यह सब एक साथ डालें

यहां एक सरल जस्ता कार्यक्रम है जो जोड़ने के लिए प्रकट होता है 2+2लेकिन परिणाम 5 का कारण बनता है:

let
x+y=1+:x+:y
in 1+2

दुभाषी

यह इस प्रकार है bin/zinc.dart:

import 'package:parsers/parsers.dart';
import 'dart:io';

// An error.
class Error implements Exception {
  String cause;
  Error(this.cause);
  String toString() => 'error in Zinc script: $cause';
}


// AST.
class Node {
  Obj interpret(ZincInterpreter interp) => null;
}

// Identifier.
class Id extends Node {
  final String id;
  Id(this.id);
  String toString() => 'Id($id)';
  Obj interpret(ZincInterpreter interp) => interp.getv(id);
}

// Integer literal.
class IntLiteral extends Node {
  final int value;
  IntLiteral(this.value);
  String toString() => 'IntLiteral($value)';
  Obj interpret(ZincInterpreter interp) => new IntObj(value);
}

// Any kind of operator.
class Anyop extends Node {
  void set(ZincInterpreter interp, OpFuncType func) {}
}

// Operator.
class Op extends Anyop {
  final String op;
  final bool orig;
  Op(this.op, [this.orig = false]);
  String toString() => 'Op($op, $orig)';
  OpFuncType get(ZincInterpreter interp) =>
    this.orig ? interp.op0[op] : interp.op1[op];
  void set(ZincInterpreter interp, OpFuncType func) { interp.op1[op] = func; }
}

// Unary operator (len).
class Lenop extends Anyop {
  final bool orig;
  Lenop([this.orig = false]);
  String toString() => 'Lenop($orig)';
  OpFuncType get(ZincInterpreter interp) =>
    this.orig ? interp.op0['#'] : interp.op1['#'];
  void set(ZincInterpreter interp, OpFuncType func) { interp.op1['#'] = func; }
}

// Magic operator.
class Magicop extends Anyop {
  final String op;
  Magicop(this.op);
  String toString() => 'Magicop($op)';
  Obj interpret_with(ZincInterpreter interp, Obj x, Obj y) {
    if (op == 'cut') {
      if (y is! IntObj) { throw new Error('cannot cut int with non-int'); }
      if (x is IntObj) {
        return new SetObj(x.value.toString().split(y.value.toString()).map(
          int.parse));
      } else {
        assert(x is SetObj);
        List<List<Obj>> res = [[]];
        for (Obj obj in x.vals(interp)) {
          if (obj == y) { res.add([]); }
          else { res.last.add(obj); }
        }
        return new SetObj(new List.from(res.map((l) =>
          l.length == 1 ? l[0] : new SetObj(l))));
      }
    } else if (op == 'join') {
      if (x is! SetObj) { throw new Error('can only join set'); }
      if (y is! IntObj) { throw new Error('can only join set with int'); }
      String res = '';
      for (Obj obj in x.vals(interp)) {
        if (obj is! IntObj) { throw new Error('joining set must contain ints'); }
        res += obj.value.toString();
      }
      return new IntObj(int.parse(res));
    }
  }
}

// Unary operator (len) expression.
class Len extends Node {
  final Lenop op;
  final Node value;
  Len(this.op, this.value);
  String toString() => 'Len($op, $value)';
  Obj interpret(ZincInterpreter interp) =>
    op.get(interp)(interp, value.interpret(interp), null);
}

// Binary operator expression.
class Binop extends Node {
  final Node lhs, rhs;
  final Op op;
  Binop(this.lhs, this.op, this.rhs);
  String toString() => 'Binop($lhs, $op, $rhs)';
  Obj interpret(ZincInterpreter interp) =>
    op.get(interp)(interp, lhs.interpret(interp), rhs.interpret(interp));
}

// Clause.
enum ClauseKind { Where, Sort }
class Clause extends Node {
  final ClauseKind kind;
  final Node expr;
  Clause(this.kind, this.expr);
  String toString() => 'Clause($kind, $expr)';
  Obj interpret_with(ZincInterpreter interp, SetObj set, Id id) {
    List<Obj> res = [];
    List<Obj> values = set.vals(interp);
    switch (kind) {
    case ClauseKind.Where:
      for (int i=0; i<values.length; i++) {
        Obj obj = values[i];
        interp.push_scope();
        interp.setv(id.id, obj);
        interp.setv('_', new IntObj(i));
        Obj x = expr.interpret(interp);
        interp.pop_scope();
        if (x is IntObj) {
          if (x.value != 0) { res.add(obj); }
        } else { throw new Error('where clause condition must be an integer'); }
      }
      break;
    case ClauseKind.Sort:
      res = values;
      res.sort((x, y) {
        interp.push_scope();
        interp.setv(id.id, x);
        Obj x_by = expr.interpret(interp);
        interp.setv(id.id, y);
        Obj y_by = expr.interpret(interp);
        interp.pop_scope();
        if (x_by is IntObj && y_by is IntObj) {
          return x_by.value.compareTo(y_by.value);
        } else { throw new Error('sort clause result must be an integer'); }
      });
      break;
    }
    return new SetObj(new List.from(res.reversed));
  }
}

// Set comprehension.
class SetComp extends Node {
  final Id id;
  final Node set;
  final Clause clause;
  SetComp(this.id, this.set, this.clause);
  String toString() => 'SetComp($id, $set, $clause)';
  Obj interpret(ZincInterpreter interp) {
    Obj setobj = set.interpret(interp);
    if (setobj is SetObj) {
      return clause.interpret_with(interp, setobj, id);
    } else { throw new Error('set comprehension rhs must be set type'); }
  }
}

// Operator rewrite.
class OpRewrite extends Node {
  final Anyop op;
  final Node value;
  final Id lid, rid; // Can be null!
  OpRewrite(this.op, this.value, [this.lid, this.rid]);
  String toString() => 'OpRewrite($lid, $op, $rid, $value)';
  Obj interpret(ZincInterpreter interp) {
    if (lid != null) {
      // Not bare.
      op.set(interp, (interp,x,y) {
        interp.push_scope();
        interp.setv(lid.id, x);
        if (rid == null) { assert(y == null); }
        else { interp.setv(rid.id, y); }
        Obj res = value.interpret(interp);
        interp.pop_scope();
        return res;
      });
    } else {
      // Bare.
      if (value is Magicop) {
        op.set(interp, (interp,x,y) => value.interpret_with(interp, x, y));
      } else {
        op.set(interp, (interp,x,y) => (value as Anyop).get(interp)(x, y));
      }
    }
    return null;
  }
}

class Program extends Node {
  final List<OpRewrite> rws;
  final Node expr;
  Program(this.rws, this.expr);
  String toString() => 'Program($rws, $expr)';
  Obj interpret(ZincInterpreter interp) {
    rws.forEach((n) => n.interpret(interp));
    return expr.interpret(interp);
  }
}


// Runtime objects.
typedef Obj OpFuncType(ZincInterpreter interp, Obj x, Obj y);

class Obj {}

class IntObj extends Obj {
  final int value;
  IntObj(this.value);
  String toString() => 'IntObj($value)';
  bool operator==(Obj rhs) => rhs is IntObj && value == rhs.value;
  String dump() => value.toString();
}

class SetObj extends Obj {
  final List<Obj> values;
  SetObj(this.values) {
    if (values.length == 0) { throw new Error('set cannot be empty'); }
  }
  String toString() => 'SetObj($values)';
  bool operator==(Obj rhs) => rhs is SetObj && values == rhs.values;
  String dump() => values.map((x) => x.dump()).reduce((x,y) => x+y);
  List<Obj> vals(ZincInterpreter interp) {
    Obj lenobj = interp.op1['#'](interp, this, null);
    int len;
    if (lenobj is! IntObj) { throw new Error('# operator must return an int'); }
    len = lenobj.value;
    if (len < 0) { throw new Error('result of # operator must be positive'); }
    return new List<Obj>.from(values.getRange(0, len));
  }
}


// Parser.
class ZincParser extends LanguageParsers {
  ZincParser(): super(reservedNames: ['let', 'in', 'join', 'cut']);
  get start => prog().between(spaces, eof);
  get comma => char(',') < spaces;
  get lp => symbol('(');
  get rp => symbol(')');
  get lb => symbol('{');
  get rb => symbol('}');
  get colon => symbol(':');
  get plus => symbol('+');
  get minus => symbol('-');
  get star => symbol('*');
  get slash => symbol('/');
  get eq => symbol('=');
  get len => symbol('#');
  get in_ => char(':');
  get where => char('^');
  get sort => char('\$');

  prog() => reserved['let'] + oprw().sepBy(comma) + reserved['in'] + expr() ^
            (_1,o,_2,x) => new Program(o,x);
  oprw() => oprw1() | oprw2() | oprw3();
  oprw1() => (basicop() | lenop()) + eq + (magicop() | op()) ^
             (o,_,r) => new OpRewrite(o,r);
  oprw2() => (id() + op() + id()).list + eq + expr() ^
             (l,_,x) => new OpRewrite(l[1], x, l[0], l[2]);
  oprw3() => lenop() + id() + eq + expr() ^ (o,a,_,x) => new OpRewrite(o, x, a);
  magicop() => (reserved['join'] | reserved['cut']) ^ (s) => new Magicop(s);
  basicop() => (plus | minus | star | slash | eq) ^ (op) => new Op(op);
  op() => (basicop() + colon ^ (op,_) => new Op(op.op, true)) | basicop();
  lenop() => (len + colon ^ (_1,_2) => new Lenop(true)) |
             len ^ (_) => new Lenop();
  expr() => setcomp() | unop() | binop() | prim();
  setcomp() => lb + id() + in_ + rec(expr) + clause() + rb ^
               (_1,i,_2,x,c,_3) => new SetComp(i,x,c);
  clausekind() => (where ^ (_) => ClauseKind.Where) |
                  (sort  ^ (_) => ClauseKind.Sort);
  clause() => clausekind() + rec(expr) ^ (k,x) => new Clause(k,x);
  unop() => lenop() + rec(expr) ^ (o,x) => new Len(o,x);
  binop() => prim() + op() + rec(expr) ^ (l,o,r) => new Binop(l,o,r);
  prim() => id() | intlit() | parens(rec(expr));
  id() => identifier ^ (i) => new Id(i);
  intlit() => intLiteral ^ (i) => new IntLiteral(i);
}


// Interpreter.
class ZincInterpreter {
  Map<String, OpFuncType> op0, op1;
  List<Map<String, Obj>> scopes;
  ZincInterpreter() {
    var beInt = (v) {
      if (v is IntObj) { return v.value; }
      else { throw new Error('argument to binary operator must be integer'); }
    };
    op0 = {
      '+': (_,x,y) => new IntObj(beInt(x)+beInt(y)),
      '-': (_,x,y) => new IntObj(beInt(x)-beInt(y)),
      '*': (_,x,y) => new IntObj(beInt(x)*beInt(y)),
      '/': (_,x,y) => new IntObj(beInt(x)/beInt(y)),
      '=': (_,x,y) => new IntObj(x == y ? 1 : 0),
      '#': (i,x,_2) =>
        new IntObj(x is IntObj ? x.value.toString().length : x.values.length)
    };
    op1 = new Map<String, OpFuncType>.from(op0);
    scopes = [{}];
  }

  void push_scope() { scopes.add({}); }
  void pop_scope() { scopes.removeLast(); }
  void setv(String name, Obj value) { scopes[scopes.length-1][name] = value; }
  Obj getv(String name) {
    for (var scope in scopes.reversed) {
      if (scope[name] != null) { return scope[name]; }
    }
    if (name == 'S') {
      var input = stdin.readLineSync() ?? '';
      var list = new List.from(input.codeUnits.map((c) =>
        new IntObj(int.parse(new String.fromCharCodes([c])))));
      setv('S', new SetObj(list));
      return getv('S');
    } else throw new Error('undefined variable $name');
  }
}


void main(List<String> args) {
  if (args.length != 1) {
    print('usage: ${Platform.script.toFilePath()} <file to run>');
    return;
  }
  var file = new File(args[0]);
  if (!file.existsSync()) {
    print('cannot open ${args[0]}');
    return;
  }
  Program root = new ZincParser().start.parse(file.readAsStringSync());
  ZincInterpreter interp = new ZincInterpreter();
  var res = root.interpret(interp);
  print(res.dump());
}

और यह इस प्रकार है pubspec.yaml:

name: zinc
dependencies:
  parsers: any

इरादा समाधान

let
#x=((x=S)*(-2))+#:x,
/=cut
in {y:{x:S/0$#:x}^_=2}

1
क्या मैं सही ढंग से समझता हूं कि सेट का आदेश दिया गया है और डुप्लिकेट हो सकते हैं, इसलिए वे मूल रूप से सूचियां हैं? भी, अगर मैं joinएक मिश्रित सेट पसंद करता हूं, तो {1,{3,2}}क्या कोई त्रुटि होगी? मैं अभी डार्ट स्थापित नहीं कर सकता, इसलिए मैं खुद की जांच नहीं कर सकता।
जर्ब

@Zgarb हाँ, सेट इस मामले में मूल रूप से सूचियाँ हैं। मिश्रित सेटों में शामिल होना एक त्रुटि होना चाहिए , लेकिन दुभाषिया वास्तव में एटीएम को क्रैश कर देता है ...
kirbyfan64sos

मैं दुभाषिया कैसे चलाऊँ? अगर मैं बस कोशिश करता dart bin/zinc.dart test.zncहूं तो मुझे एक सिंटैक्स त्रुटि मिलती है: 'file:///D:/Development/languages/zinc/bin/zinc.dart': error: line 323 pos 41: unexpected token '?'...var input = stdin.readLineSync() ?? '';
मार्टिन एंडर


1
@ ज़र्बर्ग याद रखें, जब कल्पना में, मैंने कहा था कि समानता को छोड़कर सभी अंतर्निहित ऑपरेशन लंबाई ऑपरेटर का उपयोग करते हैं? -2+#:Sजब यह दिया जाता है तो मैं इसे फिर से शुरू करता हूं S, जो दो ट्रेलिंग शून्य को काट देता है। यही कारण है कि मैं उम्मीद कर रहा था कि यह हल हो जाएगा। और ^सेट को उलटने वाला नहीं है ... वह एक बग था ...
kirbyfan64sos

5

कम्पास सूप ( कार्डबोर्ड बॉक्स से फटा )

दुभाषिया: C ++

कम्पास सूप एक ट्यूरिंग मशीन की तरह है जिसमें एक अनंत 2-आयामी टेप है। मुख्य पकड़ यह है कि निर्देश मेमोरी और डेटा मेमोरी एक ही स्थान पर हैं, और प्रोग्राम का आउटपुट उस स्थान की संपूर्ण सामग्री है।

यहाँ छवि विवरण दर्ज करें

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

एक प्रोग्राम पाठ का 2-आयामी ब्लॉक है। कार्यक्रम का स्थान पूरे स्रोत कोड के साथ शुरू होता है, जिसमें पहला वर्ण (0,0) होता है। कार्यक्रम का बाकी स्थान अनंत है और इसे अशक्त वर्ण (ASCII 0) से आरंभ किया गया है।

दो पॉइंटर्स हैं जो प्रोग्राम स्पेस में घूम सकते हैं:

  • निष्पादन सूचक में एक स्थान और एक दिशा (उत्तर, दक्षिण, पूर्व या पश्चिम) है। प्रत्येक टिक, निष्पादन सूचक के तहत निर्देश निष्पादित किया जाता है, फिर निष्पादन सूचक अपने वर्तमान दिशा में चलता है। निष्पादन पॉइंटर पूर्व (पॉज़िटिव x), !वर्ण के स्थान पर या (0,0) चलना शुरू कर देता है यदि वह मौजूद नहीं है।
  • डेटा पॉइंटर का केवल एक स्थान होता है। यह निर्देश के साथ ले जाया जाता है x, X, y, और Y@यदि यह मौजूद नहीं है, तो यह चरित्र के स्थान पर या (0,0) पर शुरू होता है।

इनपुट

>यदि यह मौजूद नहीं है, तो स्टड की सामग्री को प्रोग्राम के स्थान पर , या चरित्र के स्थान पर (0,0) में प्रिंट किया जाता है।

उत्पादन

प्रोग्राम समाप्त हो जाता है जब निष्पादन सूचक सीमा से बाहर अनियमित रूप से चलता है। आउटपुट उस समय प्रोग्राम स्पेस की संपूर्ण सामग्री है। इसे stdout और 'result.txt' पर भेजा जाता है।

अनुदेश

  • n - निष्पादन सूचक उत्तर (नकारात्मक y) को पुनर्निर्देशित करता है
  • e - निष्पादन सूचक पूर्व (सकारात्मक x) को पुनर्निर्देशित करता है
  • s - निष्पादन सूचक दक्षिण (सकारात्मक y) को पुनर्निर्देशित करता है
  • w - निष्पादन सूचक पश्चिम (नकारात्मक x) को पुनर्निर्देशित करता है
  • y - डेटा पॉइंटर नॉर्थ (नेगेटिव वाई) को स्थानांतरित करता है
  • X - डेटा पॉइंटर ईस्ट (पॉजिटिव x) ले जाता है
  • Y - डेटा पॉइंटर साउथ (पॉज़िटिव y) को स्थानांतरित करता है
  • x - डेटा पॉइंटर वेस्ट (नेगेटिव x) को स्थानांतरित करता है
  • p- डेटा पॉइंटर पर निष्पादन पॉइंटर द्वारा सामना किया गया अगला चरित्र लिखता है। उस चरित्र को एक निर्देश के रूप में निष्पादित नहीं किया गया है।
  • j- डेटा पॉइंटर के तहत चरित्र के खिलाफ निष्पादन सूचक द्वारा सामना किए गए अगले चरित्र की जांच करता है। उस चरित्र को एक निर्देश के रूप में निष्पादित नहीं किया गया है। यदि वे समान हैं, तो निष्पादन सूचक अगले वर्ण पर कूदता है।
  • c - डेटा पॉइंटर पर अशक्त वर्ण लिखता है।
  • * - विराम बिंदु - बस दुभाषिया को तोड़ने का कारण बनता है।

अन्य सभी पात्रों को निष्पादन सूचक द्वारा अनदेखा किया जाता है।

दुभाषिया

दुभाषिया स्रोत फ़ाइल को स्टड पर एक तर्क और इनपुट के रूप में लेता है। इसमें एक स्टेपेबल डिबगर है, जिसे आप कोड में ब्रेकपॉइंट इंस्ट्रक्शन के साथ इनवोक कर सकते हैं ( *)। जब टूट जाता है, तो निष्पादन सूचक ASCII 178 (गहरा छायांकित ब्लॉक) और डेटा सूचक ASCII 177 (हल्का छायांकित ब्लॉक) के रूप में दिखाया जाता है।

#include <stdio.h>
#include <iostream>
#include <fstream>
#include <string>
#include <stdio.h>

// Compass Soup programming language interpreter
// created by Brian MacIntosh (BMacZero)
// for https://codegolf.stackexchange.com/questions/61804/create-a-programming-language-that-only-appears-to-be-unusable
//
// 31 October 2015

struct Point
{
    int x, y;
    Point(int ix, int iy) { x = ix; y = iy; };
    bool operator==(const Point &other) const
    {
        return other.x == x && other.y == y;
    }
    bool operator!=(const Point &other) const
    {
        return other.x != x || other.y != y;
    }
};

struct Bounds
{
    int xMin, xMax, yMin, yMax;
    Bounds(int xmin, int ymin, int xmax, int ymax)
    {
        xMin = xmin; yMin = ymin; xMax = xmax; yMax = ymax;
    }
    bool contains(Point pt)
    {
        return pt.x >= xMin && pt.x <= xMax && pt.y >= yMin && pt.y <= yMax;
    }
    int getWidth() { return xMax - xMin + 1; }
    int getHeight() { return yMax - yMin + 1; }
    bool operator==(const Bounds &other) const
    {
        return other.xMin == xMin && other.xMax == xMax && other.yMin == yMin && other.yMax == yMax;
    }
    bool operator!=(const Bounds &other) const
    {
        return other.xMin != xMin || other.xMax != xMax || other.yMin != yMin || other.yMax != yMax;
    }
};

int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }

Bounds hull(Point a, Bounds b)
{
    return Bounds(min(a.x, b.xMin), min(a.y, b.yMin), max(a.x, b.xMax), max(a.y, b.yMax));
}

Bounds hull(Bounds a, Bounds b)
{
    return Bounds(min(a.xMin, b.xMin), min(a.yMin, b.yMin), max(a.xMax, b.xMax), max(a.yMax, b.yMax));
}

Bounds programBounds(0,0,0,0);
char** programSpace;

Point execPtr(0,0);
Point execPtrDir(1,0);
Point dataPtr(0,0);
Point stdInPos(0,0);

bool breakpointHit = false;
char breakOn = 0;

/// reads the character from the specified position
char read(Point pt)
{
    if (programBounds.contains(pt))
        return programSpace[pt.x - programBounds.xMin][pt.y - programBounds.yMin];
    else
        return 0;
}

/// read the character at the data pointer
char readData()
{
    return read(dataPtr);
}

/// read the character at the execution pointer
char readProgram()
{
    return read(execPtr);
}

/// gets the bounds of the actual content of the program space
Bounds getTightBounds(bool debug)
{
    Bounds tight(0,0,0,0);
    for (int x = programBounds.xMin; x <= programBounds.xMax; x++)
    {
        for (int y = programBounds.yMin; y <= programBounds.yMax; y++)
        {
            if (read(Point(x, y)) != 0)
            {
                tight = hull(Point(x, y), tight);
            }
        }
    }
    if (debug)
    {
        tight = hull(dataPtr, tight);
        tight = hull(execPtr, tight);
    }
    return tight;
}

/// ensure that the program space encompasses the specified rectangle
void fitProgramSpace(Bounds bounds)
{
    Bounds newBounds = hull(bounds, programBounds);

    if (newBounds == programBounds) return;

    // allocate new space
    char** newSpace = new char*[newBounds.getWidth()];

    // copy content
    for (int x = 0; x < newBounds.getWidth(); x++)
    {
        newSpace[x] = new char[newBounds.getHeight()];
        for (int y = 0; y < newBounds.getHeight(); y++)
        {
            Point newWorldPos(x + newBounds.xMin, y + newBounds.yMin);
            newSpace[x][y] = read(newWorldPos);
        }
    }

    // destroy old space
    for (int x = 0; x < programBounds.getWidth(); x++)
    {
        delete[] programSpace[x];
    }
    delete[] programSpace;

    programSpace = newSpace;
    programBounds = newBounds;
}

/// outputs the current program space to a file
void outputToStream(std::ostream &stream, bool debug)
{
    Bounds tight = getTightBounds(debug);
    for (int y = tight.yMin; y <= tight.yMax; y++)
    {
        for (int x = tight.xMin; x <= tight.xMax; x++)
        {
            char at = read(Point(x, y));
            if (debug && x == execPtr.x && y == execPtr.y)
                stream << (char)178;
            else if (debug && x == dataPtr.x && y == dataPtr.y)
                stream << (char)177;
            else if (at == 0)
                stream << ' ';
            else
                stream << at;
        }
        stream << std::endl;
    }
}

/// writes a character at the specified position
void write(Point pt, char ch)
{
    fitProgramSpace(hull(pt, programBounds));
    programSpace[pt.x - programBounds.xMin][pt.y - programBounds.yMin] = ch;
}

/// writes a character at the data pointer
void write(char ch)
{
    write(dataPtr, ch);
}

/// writes a line of text horizontally, starting at the specified position
void writeLine(Point loc, std::string str, bool isSource)
{
    fitProgramSpace(Bounds(loc.x, loc.y, loc.x + str.size(), loc.y));
    for (unsigned int x = 0; x < str.size(); x++)
    {
        programSpace[x + loc.x][loc.y] = str[x];

        // record locations of things
        if (isSource)
        {
            switch (str[x])
            {
            case '>':
                stdInPos = Point(loc.x + x, loc.y);
                break;
            case '!':
                execPtr = Point(loc.x + x, loc.y);
                break;
            case '@':
                dataPtr = Point(loc.x + x, loc.y);
                break;
            }
        }
    }
}

void advanceExecPtr()
{
    execPtr.x += execPtrDir.x;
    execPtr.y += execPtrDir.y;
}

void breakpoint()
{
    breakpointHit = true;
    outputToStream(std::cout, true);
    std::cout << "[Return]: step | [Space+Return]: continue | [<char>+Return]: continue to <char>" << std::endl;
    while (true)
    {
        std::string input;
        std::getline(std::cin, input);
        if (input.size() == 0)
        {
            break;
        }
        else if (input.size() == 1)
        {
            if (input[0] == ' ')
            {
                breakpointHit = false;
                break;
            }
            else
            {
                breakOn = input[0];
                breakpointHit = false;
                break;
            }
        }
    }
}

int main(int argc, char** argv)
{
    if (argc != 2)
    {
        printf("Usage: CompassSoup <source-file>");
        return 1;
    }

    // open source file
    std::ifstream sourceIn(argv[1]);

    if (!sourceIn.is_open())
    {
        printf("Error reading source file.");
        return 1;
    }

    programSpace = new char*[1];
    programSpace[0] = new char[1];
    programSpace[0][0] = 0;

    // read starting configuration
    std::string line;
    int currentLine = 0;
    while (std::getline(sourceIn, line))
    {
        writeLine(Point(0, currentLine), line, true);
        currentLine++;
    }

    sourceIn.close();

    // take stdin
    std::string input;
    std::cout << ">";
    std::cin >> input;
    std::cin.ignore();
    writeLine(stdInPos, input, false);

    // execute
    while (programBounds.contains(execPtr))
    {
        if (execPtrDir.x == 0 && execPtrDir.y == 0)
        {
            printf("Implementation error: execPtr is stuck.");
            break;
        }

        advanceExecPtr();

        char command = readProgram();

        // breakpoint control code
        if (breakpointHit || (breakOn != 0 && command == breakOn))
        {
            breakOn = 0;
            breakpoint();
        }

        switch (command)
        {
        case 'n':
            execPtrDir = Point(0,-1);
            break;
        case 'e':
            execPtrDir = Point(1,0);
            break;
        case 's':
            execPtrDir = Point(0,1);
            break;
        case 'w':
            execPtrDir = Point(-1,0);
            break;
        case 'x':
            dataPtr.x--;
            break;
        case 'X':
            dataPtr.x++;
            break;
        case 'y':
            dataPtr.y--;
            break;
        case 'Y':
            dataPtr.y++;
            break;
        case 'p':
            advanceExecPtr();
            write(readProgram());
            break;
        case 'j':
            advanceExecPtr();
            if (readData() == readProgram())
            {
                advanceExecPtr();
            }
            break;
        case 'c':
            write(0);
            break;
        case '*':
            breakpoint();
            break;
        }
    }

    std::ofstream outputFile("result.txt");
    outputToStream(outputFile, false);
    outputToStream(std::cout, false);
    outputFile.close();
}

उदाहरण

नमस्ते दुनिया

Hello, World!

बिल्ली

>

समानता: एक शून्य ('0') द्वारा समाप्त वर्णों की एक स्ट्रिंग को स्वीकार करता है। आउटपुट yesकी पहली पंक्ति पर आउटपुट यदि इनपुट में 1s की संख्या विषम है, तो आउटपुट |

|>
!--eXj1s-c-eXj0s-c-exj|s-pyXpeXps
   c   |   c   |   |   |
  cn0j-w---n1j-w   n---w

टिप्स

आपको एक अच्छे टेक्स्ट एडिटर का उपयोग करना चाहिए और 'इन्सर्ट' कुंजी की कार्यक्षमता का विवेकपूर्ण उपयोग करना चाहिए, और एक साथ कई पंक्तियों पर टेक्स्ट जोड़ने या हटाने के लिए 'Alt-Drag' का उपयोग करना चाहिए।

उपाय

यहाँ मेरा समाधान है। यह कार्डबोर्ड_बॉक्स जितना अच्छा नहीं है क्योंकि मुझे सोर्स कोड को खुद ही डिलीट करना था। मैं यह भी उम्मीद कर रहा था कि मुझे सभी कोड हटाने और केवल उत्तर छोड़ने का एक तरीका मिल सकता है, लेकिन मैं नहीं कर सका।

मेरा दृष्टिकोण अलग- 1अलग लाइनों पर अलग- अलग अनुक्रमों को विभाजित करना था , फिर उन्हें तब तक सॉर्ट करें 1जब तक कि वे एक 1और हिट न हो जाएं , और अंत में इनपुट के बाद तीसरी पंक्ति को छोड़कर सब कुछ मिटा दें।

  • #A#रीड -एस के निचले-दाएं को बड़ा ब्लॉक 1और उन्हें 0पढ़े जाने तक विभाजन की अंतिम पंक्ति में कॉपी करता है।
  • #B#एक सेकंड के लिए जाँच करता है 0और उत्तर #D#में एक है। अन्यथा, पिछले एक के बाद #C#एक नई विभाजन रेखा शुरू |करता है, और वापस चला जाता है #A#
  • पर और ऊपर ब्लॉक #F#गुरुत्वाकर्षण कोड है। यह 1पहली पंक्ति के अंतिम तक चलता है और इसे हिट होने तक 1या ऊपर ले जाता है -। यदि वह ऐसा नहीं कर सकता है, तो वह पंक्ति को +पहले ही लगाकर समाप्त कर देता है ।
  • #G#सभी अनावश्यक विभाजन #H#को मिटा रहा है , और स्टड और कोष्ठक के बीच सभी कोड मिटा रहा है।

कोड:

 s-----------------------w
 s-c-w  s-c-w  s---w    e+-
 eXj)nc-eXj)nc-exj(ncyj(nn
(n-----------------------------------------w                      ))
(  #H#                             s---w   |                      ))
(                                  exj+ncyxn                      ))
(                                  |                              ))
(                      s---w   s-c-+w                             ))
(                      exj+ncy-eXj1nn                             ))
(                      |                                          ))
(         s---w    s-c-+w    s+pxw                                ))
(         eyj-n-YY-eXj1nn    |  sn1jX--w           e----s         ))
(         |                  Y  x     e+---s e---s ns1jyw         ))
(      ej+n------s           j  |     nn+jYw-n+jxw-Yw   |         ))
(      Y   ec----s      e---s|  |                       1         ))
(      c   ns1jX-wYcYYY-n-jyww  |                       p         ))
(      ns+jxw      #G#       e--s                       Y         ))
(       e---n                   |               s------w|         ))
(                               |               |   ej-nn         ))
(             s--w              e----s   exc----eyj1n---n         ))
(#A#          p e+---s   s---w       |#F#|                        ))
(e----se---s  1 ||   |   exj|n----p+YeXj1ns                       ))
(ns-jXwn-jyw--w-nn1jXw   c #D#       n----w                       ))
( |        |         |   |                                        ))
( |        n---------+---+-------------|pw            s---w s---w ))
( |                  |   |     exp)XYs   |            eyj-nYeXj0ns)
( |         s---ws---+w  n-----+-----+---+------------+----------w))
( |         |   ||   ||  e--yp)n     e---+--s         |           )
( |     e-c-exj|neYj|nn  |     #C#       |  |         p           ))
( |     |                |     s---w s---+w s---w s---+w          ))
( |     |          #B#  e+s    |   | |   || |   | |   ||          ))
(!ep-Yj0n-c----------Xj0nne----exj|n-eYj|nn exj|n-eYj|nn          ))
(-@
 |>


डारन, इतने करीब! जब मैं आज रात घर आऊंगा तो अपना समाधान साझा करूंगा।
बीएमएसी

मुझे काम करने के लिए समता कार्यक्रम नहीं मिल सकता है। क्या शुरुआत में डिबग इंस्ट्रक्शन होना चाहिए? यदि मैं इसके माध्यम से कदम उठाता हूं तो अनंत लूप में फंस जाता है, कोई भी विचार जो मैं गलत कर रहा हूं?
feersum

ऐसा लगता है cकि शुरुआत में एक अतिरिक्त था जो वहाँ नहीं होना चाहिए था। मैंने ठीक कर दिया। समस्या के लिए मेरा समाधान भी जोड़ा।
बीएमएसी

4

एसीसी! , पपीरी द्वारा क्रैक्डीड

इस भाषा में एक लूपिंग संरचना, मूल पूर्णांक गणित, वर्ण I / O और एक संचयकर्ता (इस प्रकार नाम) है। सिर्फ एक संचायक। इस प्रकार, नाम।

बयान

कमांड लाइन द्वारा पार्स लाइन हैं। आदेश के तीन प्रकार हैं:

  1. Count <var> while <cond>

<var>0 से गिना जाता <cond>है, जब तक कि गैर-शैली है, सी-स्टाइल के बराबर हैfor(<var>=0; <cond>; <var>++) । लूप काउंटर कोई एकल लोअरकेस अक्षर हो सकता है। हालत किसी भी अभिव्यक्ति हो सकती है, जरूरी नहीं कि लूप चर को शामिल किया जाए। स्थिति की वैल्यू 0 हो जाने पर लूप रुक जाता है।

लूप्स के लिए K & R- शैली घुंघराले ब्रेसिज़ की आवश्यकता होती है (विशेष रूप से, स्ट्रॉस्ट्रुप संस्करण ))

Count i while i-5 {
 ...
}
  1. Write <charcode>

दिए गए ASCII / यूनिकोड मान के साथ एकल वर्ण को स्टडआउट करने के लिए आउटपुट देता है। चारकोल कोई भी अभिव्यक्ति हो सकती है।

  1. अभिव्यक्ति

स्वयं द्वारा खड़ी किसी भी अभिव्यक्ति का मूल्यांकन किया जाता है और उसे वापस संचायक (जो कि सुलभ है _) को सौंपा जाता है । इस प्रकार, उदाहरण के लिए, 3एक बयान है जो संचायक को 3 पर सेट करता है; _ + 1संचायक को बढ़ाता है; और _ * Nएक चरित्र को पढ़ता है और संचयकर्ता को उसके चारकोड द्वारा गुणा करता है।

नोट: संचायक एकमात्र चर है जिसे सीधे सौंपा जा सकता है; लूप चर और Nगणना में इस्तेमाल किया जा सकता है लेकिन संशोधित नहीं।

संचायक शुरू में 0 होता है।

भाव

संचयकर्ता के लिए एक अभिव्यक्ति में पूर्णांक शाब्दिक, लूप चर ( a-z) शामिल हो सकते हैं _, और विशेष मूल्य N, जो एक चरित्र को पढ़ता है और हर बार इसका उपयोग करते समय इसके चारकोड का मूल्यांकन करता है। नोट: इसका मतलब है कि आप प्रत्येक चरित्र को पढ़ने के लिए केवल एक शॉट प्राप्त करते हैं; अगली बार जब आप उपयोग करेंगेN करेंगे, तो आप अगले को पढ़ेंगे।

ऑपरेटर हैं:

  • +, इसके अलावा
  • -, घटाव; एकतरफा नकार
  • *, गुणन
  • /, पूर्णांक विभाजन
  • %, मोडुलो
  • ^, प्रतिपादक

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

व्हॉट्सएप और टिप्पणियां

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

# एकल-पंक्ति टिप्पणी शुरू करता है।

इनपुट आउटपुट

एसीसी! इनपुट के रूप में वर्णों की एक पंक्ति की अपेक्षा करता है। प्रत्येक इनपुट चरित्र को अनुक्रम में पुनर्प्राप्त किया जा सकता है और इसके चारकोड का उपयोग करके संसाधित किया जा सकता है N। पंक्ति के अंतिम वर्ण को पढ़ने की कोशिश करने से त्रुटि होती है। एक चरित्र Writeबयान करने के लिए अपने चारकोड पारित करके उत्पादन किया जा सकता है ।

दुभाषिया

दुभाषिया (पायथन 3 में लिखा हुआ) Acc का अनुवाद करता है ! पायथन में कोड और execइसे एस।

import re, sys

def main():
    if len(sys.argv) != 2:
        print("Please supply a filename on the command line.", file=sys.stderr)
        return
    codeFile = sys.argv[1]
    with open(codeFile) as f:
        code = f.readlines()
    code = translate(code)
    exec(code, {"inputStream": (ord(char) for char in input())})

def translate(accCode):
    indent = 0
    loopVars = []
    pyCode = ["_ = 0"]
    for lineNum, line in enumerate(accCode):
        if "#" in line:
            # Strip comments
            line = line[:line.index("#")]
        line = line.strip()
        if not line:
            continue
        lineNum += 1
        if line == "}":
            if indent:
                loopVar = loopVars.pop()
                if loopVar is not None:
                    pyCode.append(" "*indent + loopVar + " += 1")
                indent -= 1
            else:
                raise SyntaxError("Line %d: unmatched }" % lineNum)
        else:
            m = re.fullmatch(r"Count ([a-z]) while (.+) \{", line)
            if m:
                expression = validateExpression(m.group(2))
                if expression:
                    loopVar = m.group(1)
                    pyCode.append(" "*indent + loopVar + " = 0")
                    pyCode.append(" "*indent + "while " + expression + ":")
                    indent += 1
                    loopVars.append(loopVar)
                else:
                    raise SyntaxError("Line %d: invalid expression " % lineNum
                                      + m.group(2))
            else:
                m = re.fullmatch(r"Write (.+)", line)
                if m:
                    expression = validateExpression(m.group(1))
                    if expression:
                        pyCode.append(" "*indent
                                      + "print(chr(%s), end='')" % expression)
                    else:
                        raise SyntaxError("Line %d: invalid expression "
                                          % lineNum
                                          + m.group(1))
                else:
                    expression = validateExpression(line)
                    if expression:
                        pyCode.append(" "*indent + "_ = " + expression)
                    else:
                        raise SyntaxError("Line %d: invalid statement "
                                          % lineNum
                                          + line)
    return "\n".join(pyCode)

def validateExpression(expr):
    "Translates expr to Python expression or returns None if invalid."
    expr = expr.strip()
    if re.search(r"[^ 0-9a-z_N()*/%^+-]", expr):
        # Expression contains invalid characters
        return None
    elif re.search(r"[a-zN_]\w+", expr):
        # Expression contains multiple letters or underscores in a row
        return None
    else:
        # Not going to check validity of all identifiers or nesting of parens--
        # let the Python code throw an error if problems arise there
        # Replace short operators with their Python versions
        expr = expr.replace("^", "**")
        expr = expr.replace("/", "//")
        # Replace N with a call to get the next input character
        expr = expr.replace("N", "inputStream.send(None)")
        return expr

if __name__ == "__main__":
    main()


3

GoToTape (सुरक्षित)

(पूर्व में Simp-plex के रूप में जाना जाता है।)

यह भाषा सरल है। मुख्य प्रवाह नियंत्रण गोटो है, नियंत्रण का सबसे प्राकृतिक और उपयोगी रूप।

भाषा विनिर्देशन

डेटा को एक टेप पर और एक संचायक में संग्रहीत किया जाता है। यह पूरी तरह से अहस्ताक्षरित एकीकृत के साथ काम करता है। प्रत्येक वर्ण आज्ञा है। निम्नलिखित सभी आदेश हैं:

  • पत्र: a- zगोटो बयान, करने के लिए जा रहे हैं A- Z, क्रमशः।
  • :: ASCII मान के लिए संचायक को इनपुट से चार पर सेट करें।
  • ~: संचायक में ASCII मान के लिए चार आउटपुट।
  • &: संचयकर्ता से एक घटाएँ यदि यह 1 या अधिक है, अन्यथा एक को जोड़ें।
  • |: संचायक में एक जोड़ें।
  • <: डेटा पॉइंटर को 0 पर सेट करें।
  • +: डेटा पॉइंटर पर डेटा सेल में वृद्धि; सूचक +1 को स्थानांतरित करें।
  • -: डेटा पॉइंटर पर डेटा सेल से एक को घटाएं यदि यह सकारात्मक है; सूचक +1 को स्थानांतरित करें।
  • [...]: एन कोड चलाएं जहां n डेटा सूचक पर टेप पर संख्या है (नेस्टेड नहीं किया जा सकता है)।
  • /: संचायक 0 है तो अगला निर्देश छोड़ें।

दुभाषिया (C ++)

#include <iostream>
#include <memory.h>
#include <fstream>
#include <iostream>
#include <string>
#include <sstream>
using namespace std;

int serch(char* str,char ch){
    for(int i = 0;str[i];i++){
        if(str[i]==ch)
            return i;
    }
    return -1;
}

void runCode(char* code){
    int i = 0;
    char c;
    unsigned int* tape;
    tape = new unsigned int[1000003];
    memset(tape,0,1000003*sizeof(int));
    unsigned int p=0;
    unsigned int a=0;
    unsigned int n;
    unsigned int s;

    while(c=code[i]){
        if('A'<=c && c<='Z');
        if('a'<=c && c<='z')i=serch(code, c+'A'-'a');
        if(':'==c)a=cin.get();
        if('+'==c)tape[p++]++;
        if('-'==c)tape[p++] += tape[p]?-1:0;
        if('|'==c)a++;
        if('&'==c)a=a?a-1:1;
        if('<'==c)p=0;
        if('['==c){if(tape[p]){n=tape[p];s=i;}else i+=serch(code+i,']');};
        if(']'==c)i=--n?i:s;
        if('~'==c)cout<<(char)a;
        if('/'==c)i+=a?0:1;
        if('$'==c)p=a;
        i++;
    }
    delete[](tape);
}

int main(int argc, char* argv[]) {
    if(argc == 2){

        ifstream sorceFile (argv[1]);
        string code(static_cast<stringstream const&>(stringstream() << sorceFile.rdbuf()).str());
        runCode((char*)code.c_str());
    }else
        cout << "Code file must be included as a command-line argument \n";
    return 0;
}

मज़े करो!

उपाय

A:+&&&&&&&&&&/gbG&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&/a<aB<[|]C[&]-[|]/c<[|]D[&]-[|]/d<[|]+E[&]|||||||||||||||||||||||||||||||||||||||||||||||||~X&/x-[|]/e


2
आपका C ++ कोडिंग मुझे मार रहा है! क्या कोई ऐसा कारण है जिसके callocबजाय आपने new charलूप करते समय एक सी-शैली लिखी, सी-स्टाइल मेमोरी मैनेजमेंट का उपयोग किया, हमें कोड बदलने और हर बार 20 आईपीएस का उपयोग करने के दौरान सी ++ फ़ाइल को फिर से संकलित करने के लिए इस्तेमाल किया switch? मैं शिकायत नहीं कर रहा हूँ, लेकिन अभी मेरी आँखों से खून आ रहा है ...: O
kirbyfan64sos

3
मैंने दुभाषिया को मांस को पकाने के लिए धब्बा तय किया है।
मेगाटॉम

@ kirbyfan64sos कोड खराब है। मैंने इसे जल्दी से एक साथ रखा, और हो सकता है कि मैंने भी ऐसा न किया हो। इनपुट के रूप में कोड लेने के लिए मुख्य फ़ंक्शन को बदला जा सकता है। वास्तव में मुझे लगता है कि मैं अब ऐसा करूंगा ...
मेगाटॉम

1
प्रश्न कहता है कि दुभाषियों को कार्यक्रम के लिए कमांड लाइन पर एक फ़ाइल नाम लेना चाहिए
डेनिस

एक फ़ाइल को स्ट्रिंग में पढ़ने के कुछ छोटे तरीके यहां दिए गए हैं । फिर कॉल str.c_str()करने के लिए a char*
फर्सम

0

यह एक बुरा विचार था क्योंकि लगभग सभी गूढ़ भाषाएं अपठनीय लगती हैं (जेली को देखें)।
लेकिन यहाँ जाता है:

पाइलॉन्गॉल्फ 2 बीटा 6

ढेर के लिए धक्का

स्टैक को पुश करना अन्य भाषाओं में अलग तरह से कार्य करता है।
कोड 78धक्का देता है 7और 8स्टैक में, हालांकि पाइलॉन्गॉल्फ में यह धक्का देता है 78
पाइलॉन्गॉल्फ 2 में यह टॉगल करने योग्य है Ü

आदेश

) Print the stack.
Ü Toggle the method Pylongolf2 uses for pushing to stack.
a The useless command, removes and adds the selected item in the same place.
c Ask for input.
n Convert string to a number.
" Toggle string mode for pushing text to the stack.
s Convert a number to a string. ╨ Encode the selected item (it must be a string).
_ Duplicate the selected item next to itself.
b Swap places between the selected item and the one before.
d Set the selected item to the last one.
m Move the selected item to the end of the stack.
@ Select an item. (Number required after this command as an argument).
w Wait a specified amount of time (the time is taken from the stack).
= Compare the selected item to the one before. (WARNING. THIS DELETES THE 2 ITEMS AND PLACES A true OR A false) (V2 beta)
~ Print the stack nicely. (V2 beta)
² Square a number. (V3 beta)
| Split a string to an array by the character after |. (V4 beta)
♀ Pop the array. (the contents are left in the stack) (V4 beta)
> Begin a while statement. (V5 beta)
< Loop back to the beginning of the while statement. (V5 beta)
! Break out of the while statements. (V5 beta)
? An if statement, does nothing if the selected item is a `true` boolean. (V6 beta)
¿ If an if statement is `false`, the interpreter skips everything to this character. (V6 beta)

स्ट्रिंग संकेतन और एक स्ट्रिंग से एक Regex पैटर्न को हटाना

+ प्रतीक तार को समेटता है।
आप स्ट्रिंग से रेगेक्स पैटर्न के बाद वर्णों को हटाने के लिए - प्रतीक का उपयोग करने में सक्षम हैं:

c╨2"[^a-zA-Z]"-~

यह कोड इनपुट लेता है और सभी पैटर्न को हटाकर सभी गैर-वर्णमाला वर्णों को हटा देता है [^a-zA-Z]
चयनित आइटम regex और संपादित करने के लिए स्ट्रिंग होने से पहले एक होना चाहिए।

यदि विवरण

यदि कथन =करने के लिए, चयनित आइटम और उसके बाद की तुलना करने के लिए एक डालें ।
यह या तो एक जगह है trueया एक falseजगह है।
कमांड ?इस बूलियन की जाँच करता है।
यदि यह है trueतो यह कुछ नहीं करता है और दुभाषिया चलता है।
यदि यह है falseतो दुभाषिया निकटतम ¿चरित्र को छोड़ देता है ।

जीथुब पृष्ठ से लिया गया।

पाइलॉन्गॉल्फ 2 (जावा) के लिए दुभाषिया:

package org.midnightas.pylongolf2;

import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Random;
import java.util.Scanner;

public class Pylongolf {

    public static final void main(String[] args) throws Exception {
        String content = new String(Files.readAllBytes(Paths.get(new File(args[0]).toURI()))) + " ";
        boolean fullreadMode = true;
        List<Object> stack = new ArrayList<Object>();
        List<Integer> whileStatements = new ArrayList<Integer>();
        HashMap<String, Object> vars = new HashMap<String, Object>();
        int ifStatements = 0;
        Scanner scanner = new Scanner(new UnclosableDecorator(System.in));
        int selectedIndex = 0;
        for (int cl = 0; cl < content.length(); cl++) {
            char c = content.charAt(cl);
            if (isNumber(c)) {
                if (!fullreadMode) {
                    stack.add(Double.parseDouble(c + ""));
                } else {
                    String number = "";
                    for (int cl0 = cl; cl0 < content.length(); cl0++) {
                        if (isNumber(content.charAt(cl0))) {
                            number += content.charAt(cl0);
                        } else {
                            cl = cl0 - 1;
                            stack.add(Double.parseDouble(number));
                            break;
                        }
                    }
                }
            } else if (c == ')') {
                System.out.println(Arrays.toString(stack.toArray()));
            } else if (c == 'Ü') {
                fullreadMode = !fullreadMode;
            } else if (c == '+') {
                if (stack.get(selectedIndex) instanceof Object[]) {
                    Object[] obj = (Object[]) stack.remove(selectedIndex);
                    Double dbl = new Double(0d);
                    for (Object o : obj) {
                        dbl += (Double) o;
                    }
                    stack.add(selectedIndex, dbl);
                } else {
                    Object obj0 = stack.remove(selectedIndex);
                    Object obj1 = stack.remove(selectedIndex);
                    if (obj0 instanceof Number && obj1 instanceof Number)
                        stack.add(((Number) obj0).doubleValue() + ((Number) obj1).doubleValue());
                    else if (obj0 instanceof String) {
                        stack.add(obj0.toString() + obj1.toString());
                    }
                }
            } else if (c == '-') {
                Object obj0 = stack.remove(selectedIndex);
                Object obj1 = stack.remove(selectedIndex);
                if (obj0 instanceof Number && obj1 instanceof Number)
                    stack.add(((Number) obj0).doubleValue() - ((Number) obj1).doubleValue());
                else if (obj0 instanceof String && obj1 instanceof String) {
                    stack.add(obj0.toString().replaceAll(obj1.toString(), ""));
                }
            } else if (c == '*') {
                Object obj0 = stack.remove(selectedIndex);
                Object obj1 = stack.remove(selectedIndex);
                if (obj0 instanceof Number && obj1 instanceof Number)
                    stack.add(((Number) obj0).doubleValue() * ((Number) obj1).doubleValue());
            } else if (c == '/') {
                Object obj0 = stack.remove(selectedIndex);
                Object obj1 = stack.remove(selectedIndex);
                if (obj0 instanceof Number && obj1 instanceof Number)
                    stack.add(((Number) obj0).doubleValue() / ((Number) obj1).doubleValue());
            } else if (c == 'a') {
                stack.add(selectedIndex, stack.remove(selectedIndex));
            } else if (c == 'c') {
                stack.add(scanner.nextLine());
            } else if (c == 'n') {
                if (stack.get(selectedIndex) instanceof String) {
                    stack.add(selectedIndex, Double.parseDouble(stack.remove(selectedIndex).toString()));
                } else if (stack.get(selectedIndex) instanceof Object[]) {
                    Object[] oldArray = (Object[]) stack.remove(selectedIndex);
                    Object[] newArray = new Object[oldArray.length];
                    for (int i = 0; i < oldArray.length; i++) {
                        newArray[i] = Double.parseDouble(oldArray[i].toString());
                    }
                    stack.add(selectedIndex, newArray);
                }
            } else if (c == '"') {
                String string = "\"";
                for (int cl0 = cl + 1; cl0 < content.length(); cl0++) {
                    string = string + content.charAt(cl0);
                    if (content.charAt(cl0) == '"') {
                        stack.add(string.substring(1, string.length() - 1));
                        cl = cl0;
                        break;
                    }
                }
            } else if (c == 's') {
                Object obj = stack.remove(selectedIndex);
                if (obj instanceof Double) {
                    Double dbl = (Double) obj;
                    if (dbl.doubleValue() == Math.floor(dbl)) {
                        stack.add(selectedIndex, "" + dbl.intValue() + "");
                    } else {
                        stack.add(selectedIndex, "" + dbl + "");
                    }
                }
            } else if (c == '╨') {
                cl++;
                char editmode = content.charAt(cl);
                if (editmode == '0') {
                    stack.add(selectedIndex, rot13(stack.remove(selectedIndex).toString()));
                } else if (editmode == '1') {
                    stack.add(selectedIndex,
                            new StringBuilder(stack.remove(selectedIndex).toString()).reverse().toString());
                } else if (editmode == '2') {
                    stack.add(selectedIndex, stack.remove(selectedIndex).toString().toLowerCase());
                } else if (editmode == '3') {
                    stack.add(selectedIndex, stack.remove(selectedIndex).toString().toUpperCase());
                }
            } else if (c == '_') {
                stack.add(selectedIndex, stack.get(selectedIndex));
            } else if (c == 'b') {
                stack.add(selectedIndex + 1, stack.remove(selectedIndex));
            } else if (c == 'd') {
                selectedIndex = stack.size() == 0 ? 0 : stack.size() - 1;
            } else if (c == 'm') {
                stack.add(stack.remove(selectedIndex));
            } else if (c == '@') {
                String number = "";
                for (int cl0 = cl + 1; cl0 < content.length(); cl0++) {
                    if (isNumber(content.charAt(cl0)))
                        number += content.charAt(cl0);
                    else {
                        cl = cl0 - 1;
                        selectedIndex = Integer.parseInt(number);
                        break;
                    }
                }
            } else if (c == 'w') {
                String number = "";
                for (int cl0 = cl + 1; cl0 < content.length(); cl0++) {
                    if (isNumber(content.charAt(cl0)))
                        number += content.charAt(cl0);
                    else {
                        cl = cl0 - 1;
                        Thread.sleep(Long.parseLong(number));
                        break;
                    }
                }
            } else if (c == '=') {
                Object obj0 = stack.remove(selectedIndex);
                Object obj1 = stack.remove(selectedIndex);
                stack.add(new Boolean(obj0.equals(obj1)));
            } else if (c == '~') {
                for (Object o : stack)
                    System.out.print(o);
                System.out.println();
            } else if (c == '²') {
                if (stack.get(selectedIndex) instanceof Double) {
                    Double dbl = (Double) stack.remove(selectedIndex);
                    stack.add(selectedIndex, dbl * dbl);
                } else if (stack.get(selectedIndex) instanceof Object[]) {
                    Object[] obj = (Object[]) stack.remove(selectedIndex);
                    Object[] newArray = new Object[obj.length];
                    for (int i = 0; i < obj.length; i++) {
                        newArray[i] = Math.pow((Double) obj[i], 2);
                    }
                    stack.add((Object[]) newArray);
                }
            } else if (c == '|') {
                String string = (String) stack.remove(selectedIndex);
                cl++;
                char splitChar = content.charAt(cl);
                stack.add((Object[]) string.split(splitChar + ""));
            } else if (c == '♀') {
                for (Object obj : (Object[]) stack.remove(selectedIndex)) {
                    stack.add(selectedIndex, obj);
                }
            } else if (c == '>') {
                whileStatements.add(new Integer(cl));
            } else if (c == '<') {
                cl = whileStatements.get(whileStatements.size() - 1);
            } else if (c == '!') {
                whileStatements.remove(whileStatements.size() - 1);
            } else if (c == '?') {
                if (stack.get(selectedIndex) instanceof Boolean) {
                    Boolean bool = (Boolean) stack.remove(selectedIndex);
                    if (bool == false) {
                        ifStatements++;
                        for (int cl0 = cl; cl0 < content.length(); cl0++) {
                            if (content.charAt(cl0) == '¿') {
                                ifStatements--;
                                cl = cl0;
                            }
                        }
                    }
                }
            } else if (c == 't') {
                break;
            } else if (c == '(') {
                stack.remove(selectedIndex);
            } else if (c == ':') {
                cl++;
                char charToVar = content.charAt(cl);
                vars.put(charToVar + "", stack.remove(selectedIndex));
            } else if (c >= 'A' && c <= 'Z') {
                stack.add(vars.get(c + ""));
            } else if (c == 'r') {
                stack.add(selectedIndex,
                        (double) new Random().nextInt(((Double) stack.remove(selectedIndex)).intValue() + 1));
            }
        }
        scanner.close();
    }

    public static String rot13(String input) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            if (c >= 'a' && c <= 'm')
                c += 13;
            else if (c >= 'A' && c <= 'M')
                c += 13;
            else if (c >= 'n' && c <= 'z')
                c -= 13;
            else if (c >= 'N' && c <= 'Z')
                c -= 13;
            sb.append(c);
        }
        return sb.toString();
    }

    public static boolean isNumber(char c) {
        return c >= '0' && c <= '9';
    }

}

क्या यह उपयोग करने के लिए कठिन माना जाता है? : /
कैलक्यूलेटरफलाइन

0

इंद्रधनुष (नोट: दुभाषिया जल्द ही आ रहा है)

मुझे पता है कि यह चुनौती समाप्त हो गई है।

इंद्रधनुष का मिश्रण है ... बहुत सारी चीजें।

इंद्रधनुष एक 2 डी स्टैक-आधारित भाषा है जिसमें दो स्टैक (जैसे ब्रेन-फ्लैक) और 8 दिशाएं ( N NE E SE S SW W NW) हैं। 8 आदेश हैं:

  • 1, +, *, "जैसा कि वे 1+ में ऐसा करते हैं।
  • ! सक्रिय स्टैक को टॉगल करता है।
  • > IP दक्षिणावर्त घुमाएं।
  • , एक चरित्र इनपुट और इसे धक्का।
  • . पॉप और एक चरित्र का उत्पादन।

हालांकि, स्रोत कोड के पात्रों को तुरंत निष्पादित नहीं किया जाता है। इसके बजाय, [The Character in the source code]^[Top Of Stack]Collatz अनुमान चीज़ में फ़ीड किया जाता है, और 1 तक पहुंचने के लिए जितने चरणों की आवश्यकता होती है, उसे ASIIII तालिका द्वारा एक चरित्र में बदल दिया जाता है। इस चरित्र को तब निष्पादित किया जाता है।

  • यदि इसे 1 तक पहुंचने में 127 से अधिक चरण लगते हैं, तो कुल चरण की गिनती 127 से विभाजित होती है, अनुस्मारक लेते हैं, और फिर भागफल में अनुस्मारक जोड़ते हैं।

कार्यक्रम की शुरुआत में, स्रोत कोड (अंतिम वर्ण को छोड़कर) स्टैक पर धकेल दिया जाता है।

जब आईपी स्रोत कोड के किनारे तक पहुंचता है, तो यह समाप्त हो जाता है।

कयामत

n और m दो रजिस्टर हैं। जब एक >निर्देश निष्पादित किया जाता है, तो एम को बढ़ा दिया जाता है। यदि n n से अधिक है तो सर्वनाश केवल ट्रिगर होता है। जब सर्वनाश होता है, यह:

  • दक्षिणावर्त के बजाय एंटीक्लॉकवाइज मोड़ें।
  • मी 0 हो जाता है।
  • n स्टैक का शीर्ष बन जाता है। और फिर, स्टैक popped है।

m शुरू में शून्य है, और n प्रारंभ में स्रोत कोड का अंतिम वर्ण है।

एन्क्रिप्शन

किसी भी निष्पादन को निष्पादित करने के बाद, स्रोत कोड एन्क्रिप्ट किया गया है। 1 वर्ण का ASCII एक से बढ़ जाता है, दूसरा एक से घट जाता है, तीसरा दो से बढ़ जाता है, 4 वां दो से बढ़ जाता है, आदि।


1
बहुत यकीन है कि आप एक दुभाषिया की जरूरत है यह एक वैध जवाब हो ...
Conor O'Brien

@ ConorO'Brien यह चुनौती पहले ही समाप्त हो गई है, यह केवल मनोरंजन के लिए है। मैं दुभाषिया प्रदान करेगा, हालांकि।
HighlyRadioactive

@HighlyRadioactive ... आपने लगभग एक महीने पहले कहा था।
पपड़ी
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.