ब्रेन-फ्लैक क्लासिक दुभाषिया लिखें!


18

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

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

भाषा

ब्रेन-फ्लैक में दो स्टैक होते हैं, जिन्हें 'लेफ्ट' और 'राइट' के रूप में जाना जाता है। सक्रिय स्टैक बाईं ओर शुरू होता है। यदि खाली स्टैक पॉपप या तिरछा है, तो यह 0. लौटेगा। कोई चर नहीं हैं। जब प्रोग्राम शुरू होता है, तो प्रत्येक इनपुट को सक्रिय स्टैक पर क्रम में धकेल दिया जाता है (ताकि अंतिम इनपुट स्टैक के शीर्ष पर हो)।

ब्रेन-फ्लैक प्रोग्राम में केवल मान्य वर्ण हैं ()[]{}<>, और उन्हें हमेशा संतुलित होना चाहिए । यदि अमान्य वर्ण हैं, या कोष्ठक बेजोड़ हैं, तो आपको अपरिभाषित व्यवहार मिलता है। कुछ भी मान्य है।

दो प्रकार के कार्य हैं: नीलाड और मोनाड । एक निलाद एक फ़ंक्शन है जो 0 तर्क लेता है। यहाँ सभी निलाद हैं:

  • () +1।
  • [] -1।
  • {} सक्रिय स्टैक पॉप।
  • <> सक्रिय स्टैक को टॉगल करें।

जब उनका मूल्यांकन किया जाता है तो ये एक साथ सम्‍मिलित होते हैं। इसलिए यदि हमारे पास सक्रिय स्टैक के शीर्ष पर '3' है, तो यह स्निपेट:

()(){}

मूल्यांकन करने के लिए 1 + 1 + active.pop()जो मूल्यांकन करेगा 5. <>0 का मूल्यांकन करता है।

भिक्षु एक तर्क लेते हैं, ब्रेन-फ्लैक कोड का एक हिस्सा। यहाँ सभी मठ हैं:

  • (n) सक्रिय स्टैक पर 'एन' पुश करें।
  • [n] इंट और न्यूलाइन के रूप में 'एन' प्रिंट करें।
  • {foo}सक्रिय रहते हुए। peek ()! = 0, foo करें। 0alu का मूल्यांकन करता है।
  • <foo> फूको का निष्पादन करें, लेकिन इसका मूल्यांकन 0 के रूप में करें।

ये फ़ंक्शन उनके अंदर मूल्य भी लौटाएंगे, इसलिए

(()()())

3 और धक्का देगा

[()()()]

3 छपेगा लेकिन

[(()()())]

3 प्रिंट और धक्का होगा ।

जब प्रोग्राम निष्पादित किया जाता है, तो सक्रिय स्टैक पर छोड़ा गया प्रत्येक मान एक पूर्णांक के रूप में मुद्रित होता है, जिसके बीच एक नई रेखा होती है। दूसरे स्टैक पर मानों की अनदेखी की जाती है।

नियम:

  • आपके प्रोग्राम को (-128, 127) रेंज में संख्याओं का समर्थन करना चाहिए, और कम से कम 255 का स्टैक आकार होना चाहिए। यदि आप बड़े, महान का समर्थन करते हैं।

  • अंडरफ्लो / ओवरफ्लो अपरिभाषित है।

नमूना IO:

खाली कार्यक्रम:

इनपुट: कोई नहीं

आउटपुट: कोई नहीं

इसके अलावा। स्रोत:

({}{})

इनपुट:

2, 3

आउटपुट:

5

घटाव। स्रोत:

({}<>){({}[])<>({}[])<>}<>

इनपुट:

2, 3

आउटपुट:

-1

गुणन। स्रोत:

({}<>)<>({}[]){({}[])<>(({}))<>}<>{({}<>{})<>}<>

इनपुट:

7, 8

आउटपुट:

56

फाइबोनैचि। स्रोत:

<>((()))<>{({}[])<>({}<>)<>(({})<>({}<>))<>}<>

इनपुट:

5

आउटपुट:

13
8
5
3
2
1
1

सत्य मशीन

{[({})]}

स्टैंडर्ड लूपहोल्स लागू होते हैं, और बाइट्स जीत में सबसे छोटा जवाब होता है।


  • Actually: यह वास्तव में मेरी ओर से एक गलती थी। {...} इसे सभी के योग का मूल्यांकन करना चाहिए, जो कि आईएमओ, मस्तिष्क-परत की सबसे अच्छी विशेषताओं में से एक है। हालांकि, इस चुनौती के प्रयोजनों के लिए, मान लें कि {...} 0 के रूप में मूल्यांकन करता है।

क्या प्रोग्राम को संभालने के लिए न्यूनतम पूर्णांक मूल्य से संबंधित कोई नियम है?
0 '

मोनाड किसका {...}मूल्यांकन करता है?
नील

किस क्रम में घटाव तर्क हैं? मुझे उम्मीद है कि मुझे इसकी उपेक्षा मिल रही है।
नील

@Neil इसके बारे में क्षमा करें। मोनाड {...}0. का मूल्यांकन करता है। इसके अलावा, तर्कों को क्रम में धकेल दिया जाता है, इसलिए 2धक्का दिया जाता है, फिर 3धक्का दिया जाता है, इसलिए जब प्रोग्राम शुरू होता है, तो दूसरा इनपुट ( 3) स्टैक के शीर्ष पर होता है। मैं उन दोनों को पोस्ट में स्पष्ट करूँगा।
DJMcMayhem

जवाबों:


6

पिप -n , 151 148 101 98 बाइट्स

YRVg;VqR^"{}()<>[]";,8R J,8<>2AL,8("POy|i o0Syl1v0W@y{ }1yPU$+[ ]&@y0 1P$+[ ]"R0" (V{"R1"i}) "^s)y

इनपुट की सूची को कमांड-लाइन तर्क और ब्रेन-फ्लैक कोड से (एक लाइन) स्टड के रूप में लेता है। इसे ऑनलाइन आज़माएं!

संपादित करें: अनुवाद-और-निष्कासन रणनीति पर स्विच करके मेरे मूल दृष्टिकोण पर बहुत सारे बाइट्स सहेजे गए।

असहमति और टिप्पणी की

इस संस्करण में पिप कोड दिखाने वाले कुछ डिबग आउटपुट भी शामिल हैं, जो अनुवाद से परिणाम, साथ ही निष्पादन के बाद स्टैक सामग्री।

;;; Setup ;;;

; y is the active stack, l is the off-stack
; y is initialized from command-line arguments
y:RVg   (reversed to put the last input at the top)
; l is preset to empty list by default

; p is the program (read from stdin)
p:q

; Translate from braces to numbers 0-7 (we do this so that the
; later replacement step won't try to replace the braces in the
; Pip code)
p R: ^"()[]{}<>" 0,8

;;; Replace nilads with the appropriate code ;;;

; () => o (variable preset to 1)
p R: 01 "o"

; [] => v (variable preset to -1)
p R: 23 "v"

; {} => POy|i
; Pop y; return that value OR i (variable preset to 0)
p R: 45 "POy|i"

; <> => (V{Syli})
; Eval the code Syl to swap stacks y and l, then return i (i.e. 0)
p R: 67 "(V{Syli})"

;;; Replace monads with the appropriate code ;;;

; ( ) => yPU$+[ ]&@y
; Sum ($+) the inside and push (PU) the sum onto y; return
; the just-pushed value, which is the first element of y (@y)
; y will always be truthy (nonempty), since we just pushed a value onto it
p R: 0 "yPU$+["
p R: 1 "]&@y"

; [ ] => P$+[ ]
; Sum ($+) the inside, print (P) the sum, and return it
p R: 2 "P$+["
p R: 3 "]"

; { } => (V{W@y{ }i})
; Eval the code W@y{ }, which wraps the inside in curly braces
; and runs it while (W) the first element of y (@y) is truthy
; (i.e. not zero, and not nil from an empty stack)
; Then return i (i.e. 0)
p R: 4 "(V{W@y{"
p R: 5 "}i})"

; < > => (V{ i})
; Eval the inside, then return i (i.e. 0)
p R: 6 "(V{"
p R: 7 "i})"

; Debug: print the resulting translated code and a blank line
Pp.n

;;; Run the code ;;;

; Eval the translated code
(Vp)

; Output the active stack, newline-separated
PyJn

; Debug: print the active stack and the off-stack
P"Active stack: ".RPy
"Off-stack: ".RPl

क्या पाइप इस चुनौती से नया है?
DJMcMayhem

@DJMcMayhem नहींं ! और न ही मैं चुनौती की तुलना में नई सुविधाओं का उपयोग कर रहा हूं।
DLosc

59

ब्रेन-फ्लैक क्लासिक , 1271 1247 1239 बाइट्स

<>(()){<>((([][][][][])<(((({}){})(({})({}))[])({}(({})({}({})({}{}(<>)))))[])>{()<{}>}{})<{{}}{}>())}{}<>(<(({()(((<>))<>)}{}{<({}(([][][])((({})({}))[]{})){})>((){[]<({}{})((){[]<({}{}<>((({})({})){}{}){})(<>)>}{}){{}{}<>(<({}{}())>)(<>)}>}{}){(<{}{}{}((<>))<>>)}{}}<>)<{({}[]<({}<>)<>{(<{}>)<>{<>({}[])}{}<>({}<>)(<>)}{}>)}{}<>>)>)<>{(({}[])(){(<{}>)<><(({})[])>[][][][]{()()()()(<{}>)}{}<>}{}<>)<>}<>{}{(({})<({()<<>({}<>)>}{})>([]))((){[](<(({}()()(<>))()()()){(<{}>)<>}>)}{}<>){{}((){[]<({}())((){[]<({}())((){[]<({}())((){[]<({}())((){[]<({}())((){[]<({}())((){[](<{}<>{({}<>)<>}{}(({}))({<{}({}<>)<>>{}(<<>({}[]<>)>)}<><{({}<>)<>}>{})>)}{}){{}{}(<([])>)}>}{}){{}<>{({}<>)<>}{}((({})())<{({}[]<({}<>)<>>)}>{}){({}[]<><({}<><({()<({}[]<({}<>)<>>)>}{}<>)><>)<>({()<({}[]<({}<>)<>>)>}{}<>)>)}<>(<{({}<>)<>}>)}>}{}){{}{}(<(())>)}>}{}){(<{}{}>)<>{({}<>)<>}{}(({}))({<{}({}<>)<>>({})(<<>({}<>)>)}<><{({}<>)<>}>){{}([][][])<>(((<{}>)<>))}}>}{}){{}(<([{}])>)}>}{}){{}((<{}>))}>}{}){{}(({})(<()>)<<>{({}<>)<>}{}({}()<>)<>>)<>(<({}<>)>)<>{({}<>)<>}}{}(<({}<({}<>)<>>{})<>({}<>)>)<>(<({}())>)}{}({}<{({}[]<({}<>)<>>)}{}>){((({}[]<>){(<{}({}<>)>)}{}())<{({}()<({}<>)<>(({})[])>{[][](<{}>)}{})}{}>()){{}(<>)}}{}}{}{({}[]<[{}]>)}{}{({}[]<{}>)}{}

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

+4 बाइट्स से एक बग को ठीक करने की स्थिति में {...}मोनाड में, और -36 बाइट्स विभिन्न गोल्फ से।

1238 बाइट्स कोड, -aध्वज के लिए +1 बाइट (जिसे भाषा के ध्वज के साथ जोड़ा जा सकता है)।

यह अब {...}चुनौती विनिर्देश के अनुसार शून्य के रूप में मूल्यांकन करता है। ध्यान दें कि {...}इस चुनौती को पोस्ट करने से दो दिन पहले ब्रेन-फ्लैक ने 7 मई, 2016 के बगफिक्स के बाद से सभी रनों के योग के रूप में मूल्यांकन किया है।

निम्नलिखित कोड ब्रेन-फ्लैक क्लासिक की सही ढंग से व्याख्या करता है, {...}सभी रनों के योग के रूप में। दो दुभाषियों के बीच एकमात्र अंतर एक {}निलाद की नियुक्ति है ।

<>(()){<>((([][][][][])<(((({}){})(({})({}))[])({}(({})({}({})({}{}(<>)))))[])>{()<{}>}{})<{{}}{}>())}{}<>(<(({()(((<>))<>)}{}{<({}(([][][])((({})({}))[]{})){})>((){[]<({}{})((){[]<({}{}<>((({})({})){}{}){})(<>)>}{}){{}{}<>(<({}{}())>)(<>)}>}{}){(<{}{}{}((<>))<>>)}{}}<>)<{({}[]<({}<>)<>{(<{}>)<>{<>({}[])}{}<>({}<>)(<>)}{}>)}{}<>>)>)<>{(({}[])(){(<{}>)<><(({})[])>[][][][]{()()()()(<{}>)}{}<>}{}<>)<>}<>{}{(({})<({()<<>({}<>)>}{})>([]))((){[](<(({}()()(<>))()()()){(<{}>)<>}>)}{}<>){{}((){[]<({}())((){[]<({}())((){[]<({}())((){[]<({}())((){[]<({}())((){[]<({}())((){[](<{}<>{({}<>)<>}{}(({}))({<{}({}<>)<>>{}(<<>({}[]<>)>)}<><{({}<>)<>}>{})>)}{}){{}{}(<([])>)}>}{}){{}<>{({}<>)<>}{}((({})())<{({}[]<({}<>)<>>)}>{}){({}[]<><({}<><({()<({}[]<({}<>)<>>)>}{}<>)><>)<>({()<({}[]<({}<>)<>>)>}{}<>)>)}<>(<{({}<>)<>}>)}>}{}){{}{}(<(())>)}>}{}){(<{}>)<>{({}<>)<>}{}(({}))({<{}({}<>)<>>({})(<<>({}<>)>)}<><{({}<>)<>}>{}){{}([][][])<>(((<{}>)<>))}}>}{}){{}(<([{}])>)}>}{}){{}((<{}>))}>}{}){{}(({})(<()>)<<>{({}<>)<>}{}({}()<>)<>>)<>(<({}<>)>)<>{({}<>)<>}}{}(<({}<({}<>)<>>{})<>({}<>)>)<>(<({}())>)}{}({}<{({}[]<({}<>)<>>)}{}>){((({}[]<>){(<{}({}<>)>)}{}())<{({}()<({}<>)<>(({})[])>{[][](<{}>)}{})}{}>()){{}(<>)}}{}}{}{({}[]<[{}]>)}{}{({}[]<{}>)}{}

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

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

पहला चरण सभी इनपुट को पार्स करना है, जो कोष्ठक से शुरू होता है:

# Move to right stack, and push 1 to allow loop to start
<>(())
{
   # While keeping -5 on third stack:
   <>((([][][][][])<

       # Pop bracket or newline k from left stack, and push 0, k-10, k-40, k-60, k-91, k-123 on right stack
       (((({}){})(({})({}))[])({}(({})({}({})({}{}(<>)))))[])

   # Search this list for a zero, and push the number of nonzero entries popped minus 5 
   # (thus replacing the 0 if it was destroyed)
   >{()<{}>}{})

   # Remove rest of list, and push the same number plus 1
   # Result is -4 for {, -3 for [, -2 for <, -1 for (, 0 for newline, or 1 for everything else (assumed closing bracket)
   <{{}}{}>())

# Repeat until newline found
}{}<>

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

दूसरे स्टैक पर पूर्णांक दो संख्याओं में दर्ज किए गए हैं: एक पूर्ण मान के लिए, और एक साइन के लिए। फिर इन्हें पहले स्टैक पर वापस ले जाया जाता है।

व्याख्या किए गए ढेर निम्नलिखित क्रम में पहले स्टैक पर कोड के नीचे संग्रहीत हैं: वर्तमान स्टैक ऊंचाई, वर्तमान स्टैक, अन्य स्टैक ऊंचाई, अन्य स्टैक। अन्य स्टैक ऊंचाई के लिए 0 को इस बिंदु पर धकेलने की आवश्यकता नहीं है, क्योंकि यह एक अंतर्निहित शून्य होगा जब यह पहली बार पढ़ा जाता है।

(<((

    # If stack nonempty, register first stack entry.
    {()(((<>))<>)}{}

    # For each byte k of input:
    {

        # Push -3, -13, and k-32
        <({}(([][][])((({})({}))[]{})){})>

        # Evaluate to 1 if space
        # If not space (32):
        ((){[]<

            # If not minus (45):
            ({}{})((){[]<

                # Replace top of right stack (n) with 10*n + (k-48)
                ({}{}<>((({})({})){}{}){})(<>)

            # Else (i.e., if minus):
            >}{}){

                # Remove excess "else" entry and -3
                {}{}

                # Set sign to negative (and destroy magnitude that shouldn't even be there yet)
                <>(<({}{}())>)(<>)}

        # Else (i.e., if space):
        >}{}){

            # Remove working data for byte, and push two more 0s onto right stack
            (<{}{}{}((<>))<>>)

    # Push number of integers found
    }{}}<>)

    # For each integer:
    <{({}[]<

        # Move magnitude back to left stack
        ({}<>)<>

        # If sign is negative, negate
        {(<{}>)<>{<>({}[])}{}<>({}<>)(<>)}{}

    >)}{}

    # Push stack height onto stack
    <>>)

# Push 0
>)

कोड का प्रतिनिधित्व अब बाएं स्टैक पर वापस चला गया है। बाद में चीजों को आसान बनाने के लिए, हम 4 को निलाड्स के उद्घाटन कोष्ठक से घटाते हैं, ताकि प्रत्येक ऑपरेशन में -1 से -8 तक एक अद्वितीय पूर्णांक हो।

# For each bracket in the code:
<>{

    # Push k-1 and evaluate to k
    (({}[])()

    # If not closing bracket:
    {

        # Check next bracket (previously checked, since we started at the end here)
        (<{}>)<><(({})[])>

        # Subtract 4 if next bracket is closing bracket
        # Inverting this condition would save 8 bytes here, but cost 12 bytes later.
        [][][][]{()()()()(<{}>)}{}

    <>}{}

    # Push result onto left stack
    <>)

<>}<>{}

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

{

    (

        # Get current instruction
        ({})

        # Move all code to left stack, and track the current position in code
        <({()<<>({}<>)>}{})>

        # Push -1, signifying that the code will move forward to just before a matching }.
        # In most cases, this will become 0 (do nothing special) before it is acted upon
        ([])

    # Push instruction minus 1
    )

    # If opening bracket:
    ((){[](<

        # Push instruction+1 and instruction+4
        (({}()()(<>))()()())

        # If instruction+4 is nonzero (not loop monad), replace the earlier -1 with 0 to cancel forward seek
        # This would be clearer as {(<{}>)<>(<{}>)<>}, but that would be unnecessarily verbose
        {(<{}>)<>}

    # Else (i.e., if closing bracket):
    >)}{}<>){

# If closing bracket, parse command
# Post-condition for all: if not moving to {, pop two and push evaluation, 0.
# (For nilads, can assume second from top is 0.)
# If moving to {, pop one, push -3, 0, 0.

        # Seven nested if/else statements, corresponding to eight possible instruction.
        # The "else" statements end with 0 already on the stack, so no need to push a 0 except in the innermost if.
        # Each one beyond the first increments the instruction by 1 to compare the result with 0
        # Each instruction will pop the instruction, leaving only its evaluation (with a 0 on top).
        {}((){[]<
        ({}())((){[]<
        ({}())((){[]<
        ({}())((){[]<
        ({}())((){[]<
        ({}())((){[]<
        ({}())((){[](<

            # -7: pop
            # Pop instruction to reveal existing 0 evaluation
            {}

            # Move code out of the way to access stack
            <>{({}<>)<>}{}

            # Duplicate stack height (only useful if stack height is zero)
            (({}))

            (

                # If stack height nonzero
                {

                    # Save stack height on second stack
                    <{}({}<>)<>>

                    # Pop stack
                    {}

                    # Move stack height back and subtract 1
                    (<<>({}[]<>)>)

                }

                # Move code back to normal position
                <><{({}<>)<>}>{}

            # Evaluate as popped entry (0 if nothing popped)
            )

        # (else)
        >)}{}){

            # -6: -1 nilad
            # Just evaluate as -1
            {}{}(<([])>)

        # (else)
        }>}{}){

            # -5: swap nilad
            # Move code out of the way to access stack
            {}<>{({}<>)<>}{}

            # Number of integers to move: stack height + 1 (namely, the stack height and every entry in the stack)
            ((({})())

            # Move to second stack
            <{({}[]<({}<>)<>>)}>{}

            # Do (stack height + 1) times again
            ){({}[]<><

                # Get stack element
                ({}<><

                    # Move alternate (interpreted) stack to second (real) stack, and push length on top of it
                    ({()<({}[]<({}<>)<>>)>}{}<>)

                # Push current stack element below alternate stack
                ><>)

                # Move alternate stack back above newly pushed element
                <>({()<({}[]<({}<>)<>>)>}{}<>)

            >)}

            # Move code back to normal position
            <>(<{({}<>)<>}>)

        # (else)
        }>}{}){

            # -4: 1
            # Just evaluate to 1
            {}{}(<(())>)

        # (else)
        }>}{}){

            # -3: loop
            # Create zero on stack while keeping existing evaluation
            # This becomes (<{}{}>) in the version that meets the challenge spec
            (<{}>)

            # Move code out of the way to access stack
            <>{({}<>)<>}{}

            # Duplicate stack height
            (({}))

            (

                # If stack height nonzero
                {

                    # Save stack height on second stack
                    <{}({}<>)<>>

                    # Peek at top of stack
                    ({})

                    # Move stack height back
                    (<<>({}<>)>)

                }

                # Move code back to normal position
                <><{({}<>)<>}>

            # Look at peeked entry
            # Remove the {} in the version meeting the challenge spec
            {})

            # If peeked entry is nonzero
            {

                # Replace -3 instruction on third stack
                {}([][][])

                # Replace loop indicator to 0 (to be incremented later to 1)
                <>(((<{}>)

                # Create dummy third stack entry to pop
                <>))

            }

        # (else)
        }>}{}){

            # -2: print
            # Just print evaluation without modifying it
            {}(<([{}])>)

        # (else)
        }>}{}){

            # -1: evaluate as zero
            # Just change evaluation to 0
            {}((<{}>))

        # else
        }>}{}){

            # 0: push
            # Get current evaluation (without modifying it)
            {}(({})

                # Create zero on stack as barrier
                (<()>)

                # Move code out of the way to access stack
                <<>{({}<>)<>}{}

                # Increment stack height and save on other stack
                ({}()<>)<>

            # Push evaluation
            >)

            # Move stack height back (and push zero)
            <>(<({}<>)>)

            # Move code back to normal position
            <>{({}<>)<>}

        }{}

        # Update third stack by adding evaluation to previous entry's evaluation
        # Previous entry's instruction is saved temporarily on left stack
        (<({}<({}<>)<>>{})<>({}<>)>)

        # Increment loop indicator
        # If instruction was loop monad and top of stack was nonzero, this increments 0 to 1 (search backward)
        # Otherwise, this increments -1 to 0 (do nothing)
        <>(<({}())>)

    }{}

    # While holding onto loop indicator
    ({}<

        # Go to immediately after executed symbol
        {({}[]<({}<>)<>>)}{}

    >)

    # If looping behavior:
    {

        # Switch stack and check if searching forward
        ((({}[]<>)

        # If so:
        {

            # Move just-executed { back to left stack, and move with it
            (<{}({}<>)>)

        }{}

        # Either way, we are currently looking at the just-executed bracket.
        # In addition, the position we wish to move to is on the current stack.

        # Push unmodified loop indicator as initial value in search
        ())

        # While value is nonzero:
        <{

            # Add 1
            ({}()

                # Move current instruction to other stack
                <({}<>)<>

                # Check whether next instruction is closing bracket
                (({})[])>

                # If opening bracket, subtract 2 from value
                {[][](<{}>)}{}

            )

        }{}>

        # If searching backward, move back to left stack
        ()){{}(<>)}

    }{}

}

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

# Pop the zero
{}

# Output current stack
{({}[]<[{}]>)}{}

# Discard other stack to avoid implicit printing
{({}[]<{}>)}{}

12
: ओ क्या ... ठीक है, तुरंत इनाम। अच्छी नौकरी! : डी
DJMcMayhem

4
मुझे इसे सीधे करने दें ... आपने व्याख्या की जाने वाली भाषा के लिए एक दुभाषिया बनाया है। योद्वाग
टिसकोनंड्रम 8

ठीक है, इसमें केवल 2 अंकों का अपवोट नंबर क्यों है?
NieDzejkob

संचायक को सही तरीके से लागू करने पर अच्छी नौकरी {...}, जो कि आधुनिक मस्तिष्क-फ्लैक के लिए सही व्यवहार है और (मुझे लगता है) मस्तिष्क-फ्लैक क्लासिक, हालांकि मैंने इस चुनौती में लिखा है कि {...}0. का मूल्यांकन करता है। आप शायद गोल्फ को बाइट्स की एक महत्वपूर्ण संख्या बता सकते हैं कि कार्यक्षमता को दूर करने, हालांकि यह मूल के आसपास रखने के लिए है क्योंकि यह (इस चुनौती के लिए सिर्फ गलत) सामान्य रूप में तकनीकी रूप से अधिक सही है अच्छा होगा द्वारा
DJMcMayhem

@DJMcMayhem फिक्स्ड। बस मुझे ब्रेन-फ्लैक के उस काल्पनिक संस्करण के लिए पूरे दुभाषिया को पोर्ट नहीं करना चाहिए।
नाइट्रोडॉन

8

एपीएल, 255 257 बाइट्स

b←{S←(⌽⍺)⍬
e←{0=⍴⍵:0
v+∇⊃_ v←∇{r←⊂2↓⍵
'()'≡n←2↑⍵:r,1
'[]'≡n:r,¯1
'{}'≡n:r,{i←⊃⊃⊃S⋄S[1]↓⍨←1⋄i}⍬
'<>'≡n:r,0⊣S⌽⍨←1
r←⊂⍵↓⍨i←0⍳⍨(+\c=⍵)-+\')]>}'['([<{'⍳c←⊃⍵]=⍵
i←1↓¯1↓c←i↑⍵
'('=c←⊃c:r,S[1],⍨←⍺⍺i
'['=c:r,+⎕←⍺⍺i
'{'=c:r,{0≠⊃⊃⊃S:∇e i⋄0}⍬
'<'=c:r,0⊣⍺⍺i}⍵}
⎕←⍪⊃S⊣e⍵}

यह प्रोग्राम को इसके सही तर्क के रूप में लेता है, और प्रोग्राम इनपुट को इसके बाएं तर्क के रूप में, अर्थात:

      2 3 b '({}{})'
5
      2 3 b '({}<>){({}[])<>({}[])<>}<>'
¯1
      7 8 b '({}<>)<>({}[]){({}[])<>(({}))<>}<>{({}<>{})<>}<>'
56
      5 b '<>((()))<>{({}[])<>({}<>)<>(({})<>({}<>))<>}<>'
13
 8
 5
 3
 2
 1
 1

Ungolfed संस्करण: यहाँ


7

APL (Dyalog Classic) , 146 बाइट्स

↑⍕¨s⊣{⍎⍕1 ¯1'(s↓⍨←1)⊢⊃s' '0⊣s t←t s' 's,⍨←+/∇¨a' '⎕←+/∇¨a' '∇{×⊃s:∇⍺⍺¨a⋄0}0' '0⊣+/∇¨a'[(⊃⍵)+4×⍬≢a1↓⍵]}¨⍎∊(')',⍨'(',¨⍕¨⍳4)[0,4,⍨'([{<'⍳⍞]⊣s←⌽⎕⊣t←⍬

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

एक क्लासिक दूसरे की व्याख्या :)


6

पायथन 3, 429 बाइट्स

import re
S='s+=[v];v=0';T='v+=s.pop()';i=0
d={'()':'v+=1','(':S,')':'a+=[v];'+T,'[]':'v-=1','[':S,']':'print(v);'+T,'<>':'a.reverse()','<':S,'>':T,'{}':'v+=0if a[-1]==""else a.pop()','{':S+';while a[-1]:','}':T}
def r(m):global i;t=m.group();i-=(t=='}');s=' '*i;i+=(t=='{');return''.join(s+r+'\n'for r in d[t].split(';'))
def g(c,*a):
 a,s,v=['']+list(a),[],0;exec(re.sub(r'[<({[]?[]})>]?',r,c));
 while a[-1]!="":print(a.pop())

जैसे इस्तेमाल किया g('[{}{}]', 2, 3)

यह re.subअजगर को मस्तिष्क-फ्लैक स्रोत को "संकलित" करने के लिए उपयोग करता है और फिर अजगर को निष्पादित करता है। (debuging के लिए, की जगह execके साथ printअजगर कोड की एक सूची प्राप्त करने के लिए)

कोड में बहुत सारे बाइट्स को खाने के दौरान उचित रूप से इंडेंटिंग नेस्टेड।


3

पायथन, 616 बाइट्स

निर्देश:

  1. अजगर के साथ भागो
  2. [1,2,...]प्रारूप में इनपुट सूची , फिर एंटर दबाएं
  3. प्रोग्राम चिपकाएँ / लिखें, फिर दोबारा एंटर करें
  4. किया हुआ

मूल रूप से, यह कार्यक्रम जो करता है, वह पुन: नेस्टेड सूचियों में ब्रेन-फ्लैक कोड को "संकलन" करता है, और इस सूची की पुनरावृत्ति करता है। शायद दोनों को मिलाने का एक तरीका है ...

मैं कोशिश करूँगा और तर्क को बाद में फिर से तैयार करूँगा।

y="([{<)]}>"
w,z,g=print,len,input
def c(s):
 if z(s)<1:return[]
 t,i,o=[],1,0
 t.append(y.index(s[0]))
 while z(t)>0:
  x=y.index(s[i])
  if x<4:t.append(x)
  else:o=t.pop()
  i+=1
 r=[[o,c(s[1:i-1])]]
 r.extend(c(s[i:]))
 return r
p=lambda t:t.pop()if z(t)>0 else 0
k=lambda t:t[z(t)-1]if z(t)>0 else 0
r,l=[],eval(g())
a=l
def i(u):
 v=0
 global a
 for t,n in u:
  if t<1:
   if n:o=i(n);v+=o;a.append(o)
   else:v+=1
  if t==1:
   if n:o=i(n);v+=o;w(o)
   else:v-=1
  if t==2:
   if n:
    while k(a)!=0:i(n)
   else:v+=p(a)
  if t>2:
   if n:i(n)
   elif a==l:a=r
   else:a=l
 return v
i(c(g()))
for n in a:w(n)

3

पर्ल 5.6, 419 414 बाइट्स

मैंने इसे थोड़ा सा गोल्फ दिया है लेकिन इसमें सुधार की गुंजाइश है। कुछ पठनीयता की खातिर यहां नईं और टैब जोड़ी गईं:

use Text::Balanced extract_bracketed;
$s=shift;
@a=reverse@ARGV;
sub p
{
    my($c)=@_;
    my$s=0;
    while(my$n=extract_bracketed($c)){
        $s+='()'eq$n||'{}'eq$n&&shift@a;
        $s-='[]'eq$n;
        @t=@a,@a=@i,@i=@t if'<>'eq$n;
        my$m=chop($n);
        $n=substr($n,1);
        if($n){
            p($n)while'}'eq$m&&$a[0];
            p($n)if'}'ne$m;
            $s+=$v,unshift@a,$v if')'eq$m;
            $s+=$v,print"n=$n m=$m v=$v\n"if']'eq$m;
        }
    }
    $v=$s;
}
p($s);
foreach(@a){
    print"$_\n";
}

1

पायथन 2 , 361 , 348 बाइट्स

c,s=input();s=s,[]
a=s[0]
def w():global a,s;s=s[::-1];a=s[0];return 0
def p(c):a.append(c);return c
def n(c):print c;return c
z=lambda c:0
def l(f):
 global a
 while a and a[-1]:f()
 return 0
for x,y in zip("() ( [] {} <> [ < { } ] >".split(),"+1 +p( -1 +(len(a)and(a.pop())) +w() +n( +z( +l(lambda: ) ) )".split()):c=c.replace(x,y)
exec c
print a

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

-13 बाइट्स ने @Mr को धन्यवाद दिया। Xcoder!

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