bfcat - एक फ़ाइल को एक ब्रेनफेड *** प्रोग्राम के रूप में एनकोड करें


18

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखिए जो एक स्ट्रिंग देता है, एक मान्य ब्रेनफक प्रोग्राम लौटाता है, जब ब्रेनफक के रूप में संकलित और निष्पादित किया जाता है, जो एक बार फिर रिटर्न देता है।

  1. मान लें कि सभी इनपुट ASCII के रूप में एन्कोडेड हैं।

  2. आउटपुट बीएफ प्रोग्राम एक अनंत टेप के साथ वातावरण में निष्पादित करेगा मान लें।

  3. मान लें कि सेलर 0 से शुरू होता है, जो कि शून्य के मान से आरंभिक हर सेल के साथ होता है।

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

  5. टेप दोगुना अनंत है।

  6. दुभाषिया द्वारा प्रदान की गई सभी कोशिकाएं ठीक 8-बिट कोशिकाएं हैं। ओवरफ्लो और अंडरफ्लो एक अनुमानित और समझदार मामले में चारों ओर लपेटते हैं।

उदाहरण

अंतरिक्ष स्ट्रिंग

इनपुट को देखते हुए , आपका प्रोग्राम / फ़ंक्शन वापस आ सकता है:

+++++ +++++
+++++ +++++
+++++ +++++
++ .

विस्मयादिबोधक बिंदु

इनपुट को देखते हुए !, आपका प्रोग्राम / फ़ंक्शन वापस आ सकता है:

+++++ +++++
+++++ +++++
+++++ +++++
+++
.

दो अक्षर

इनपुट को देखते हुए hi, आपका प्रोग्राम / फ़ंक्शन वापस आ सकता है:

+++++ +++++
+++++ +++++
+++++ +++++
+++++ +++++
+++++ +++++

+++++ +++++
+++++ +++++
+++++ +++++
+++++ +++++
+++++ +++++

++++
.
+
.

यह , इसलिए सबसे कम संख्या में बाइट्स जीतता है। सौभाग्य।


10
अधिक वृषण कृपया।
लीक नून

1
वास्तव में क्या दिशा-निर्देश उल्लिखित हैं संशोधन 9 ?
user8397947

4
मैं इसे फिर से खोल रहा हूं। मुझे लगता है कि पीटर की चिंताओं को संबोधित किया गया है और हमारे पास एक नकल के रूप में जो मायने रखता है, उस पर हमारी स्पष्ट सहमति है, और यह चुनौती उन मानदंडों को पूरा नहीं करती है।
मार्टिन एंडर

"ओवरफ्लो और अंडरफ्लो रैप एक प्रेडिक्टेबल और सेंस तरीके से" - तो 127 + 1 रैप्स 0 से और -128-1 भी 0 से रैप होता है, सही? यह एक संभव पूर्वानुमान और समझदार तरीका है।
user253751

1
@ इमिबिअस बिल्कुल।
user8397947

जवाबों:


18

जेली , 8 बाइट्स

O”+ẋp“.>

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

नमूना चला

इनपुट के लिए hi, यह प्रोग्राम प्रिंट करता है

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++>

(बिना लाइनफीड के) जो बदले में, प्रिंट करता हैhi

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

O”+ẋp“.>  Main link. Argument: s (string)

O         Ordinal; convert each character in s into its code point.
 ”+       Yield the character '+'.
   ẋ      Repeat '+' k times, for each k in the code points.
     “.>  Yield the string ".>".
    p     Take the Cartesian product of both results.

तुम्हारा सीमित स्मृति पर काम नहीं है, मेरा करता है।
लीक नून

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

.>आउटपुट में क्यों नहीं दिखाई देता है?
बिल्ली

2
@cat क्योंकि कार्टेशियन उत्पाद ( p) प्रत्येक के लिए परिशिष्ट से छोटा है ( ;€)। ये ouput प्रोग्राम प्रिंटिंग के बाद और स्विच करने से पहले सेल को दोगुना करते हैं। चूँकि हम सेल को कभी भी नहीं बदलते हैं, यह आउटपुट को प्रभावित नहीं करता है।
डेनिस

@ डेनिस आह, दिलचस्प।
बिल्ली

55

ब्रेनफक, 55 51 बाइट्स

,[>+++[>+++++++<-]>[<++>>+++<-]<+<[>.<-]>+++.>>-.,]

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

उदाहरण के लिए hi(बिना लाइनफीड के) आउटपुट :

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>

व्याख्या

यह प्रोग्राम लिखते समय टेप के पार जाता है। आसपास ,[...,]एक मानक इनपुट लूप है। प्रत्येक वर्ण के लिए, हम चार कोशिकाओं का उपयोग करते हैं:

[... x a b c ...]

xवह सेल कहां है जिसे हम इनपुट लिखते हैं

>+++[>+++++++<-]

इस भाग में और के मानक गुणा के माध्यम से सेल में aलिखने के लिए सेल का उपयोग किया जाता है ।21b37

>[<++>>+++<-]

अब हम का उपयोग 21लिखने के लिए 42में aऔर 63में cसे गुणा करके 2और 3क्रमशः। फिर एक (कोड बिंदु ) में बदलते हुए <+<सेल पर वापस जाता है । संक्षिप्त:x4243+

[... x 43 21 63 ...]

अब मुख्य उत्पादन लूप:

[>.<-]

अर्थात्, घटते समय xहम +प्रत्येक बार एक प्रिंट करते हैं।

>+++.

हमारा काम हो जाने के बाद हम पुन: उपयोग +सेल, जोड़कर 3देने के लिए .

>>-.

अंत में, हम 63इसे 62( >) और आउटपुट के रूप में अच्छी तरह से घटाते हैं। अगली पुनरावृत्ति इस सेल का उपयोग करेगी x


5
अगर मैं और अधिक प्रतिनिधि था, तो मैं इसे एक इनाम दूंगा।
user8397947

34

ब्रेनफक, 39 33 32 31 बाइट्स

-[-[>]<--<--],[[>.<+]>+.--.+<,]

टेप पर 45 स्थान पर आने वाला एल्गोरिथ्म Esolang के Brainfuck स्थिरांक से लिया गया है

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

लंबे समय तक (लंबे समय तक) समाधान के लिए जो बिना शर्त काम करता है, मेरा दूसरा जवाब देखें

परीक्षण चालन

इनपुट के लिए Code Golf, निम्न आउटपुट उत्पन्न होता है।

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.,-------------------------------------------------------------------------------------------------------------------------------------------------.,------------------------------------------------------------------------------------------------------------------------------------------------------------.,-----------------------------------------------------------------------------------------------------------------------------------------------------------.,--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.,-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------.,-------------------------------------------------------------------------------------------------------------------------------------------------.,----------------------------------------------------------------------------------------------------------------------------------------------------.,----------------------------------------------------------------------------------------------------------------------------------------------------------.,

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

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

हम पूर्णांक 45 (वर्ण कोड -) को टेप के सेल में डालकर शुरू करते हैं । निम्न कोड इसे प्राप्त करता है।

-      Decrement cell 0, setting it to 255.
[      While the cell under the head in non-zero:
  [>]    Advance to the next zero cell.
  <--    Decrement the cell to its left.
  <--    Decrement the next cell to the left.
]

इससे पहले कि हम लूप में प्रवेश करें, टेप इस तरह दिखता है।

         v
000 000 255

ये तीन कोशिकाएं - -2 , -1 और 0 - केवल वही हैं जो हम इस कार्यक्रम में उपयोग करेंगे।

लूप के पहले प्रत्येक पुनरावृत्ति में, सबसे दाहिनी कोशिका होती है, फिर उस कोशिका और मध्य कोशिका का दो बार क्षरण होता है, जो निम्न अवस्था को छोड़ देती है।

     v
000 254 252

अगले 126 पुनरावृत्तियों में, प्रारंभिक -सेल मध्य सेल [>]<को घटाता है, --<--सबसे सही सेल को कूदता है, और मध्य और सही सेल को घटाता है। परिणामस्वरूप, 3 को मध्य सेल (मॉडुलो 256 ) से घटाया जाता है और 2 को सबसे दाहिने सेल से घटाया जाता है।

चूंकि 254 25 3 (मॉड 256) = (254 + 256) 510 3 = 510 = 3 = 170 और 252 25 3 = 84 , मध्य प्रदेश से पहले सबसे दाहिने सेल को शून्य किया जाता है, जिससे निम्न स्थिति होती है।

     v
000 132 000

लूप के पहले पुनरावृत्ति के समान, अगला पुनरावृत्ति अब मध्य सेल से 3 और बाईं सेल से 2 को घटाता है , सिर को बाईं ओर सेल पर रखता है।

 v
254 129 000

बाद में पुनरावृत्तियों, उनके रूप में 126 पुनरावृत्ति में, बाएं सेल से 3 और सबसे दाएं सेल से 2 घटाना ।

चूंकि 254 25 3 (मॉड 256) = 170 और 129 mod 2 (मॉड 256) अपरिभाषित है, यह 170 बार किया जाता है, जो निम्न स्थिति को छोड़ देता है।

 v
000 045 000

सिर के नीचे की कोशिका शून्य है; लूप समाप्त होता है।

अब हम आउटपुट तैयार करने के लिए तैयार हैं।

,      Read a character from STDIN and put it the leftmost cell.
[        While the leftmost cell is non-zero:
  [        While the leftmost cell is non-zero:
    >.     Print the content of the middle cell ('-').
    <-     Increment the leftmost cell.
  ]      If the leftmost cell held n, the above will print 256 - n minus signs
         which, when executed, will put n in cell 0 of the output program.
  >      Increment the middle cell, setting it to 46 ('.').
  .      Print its content ('.').
  --     Decrement the middle cell twice, setting it to 44 (',').
  .      Print its content (',').
         When executed, since the output program receives no input, the above
         will zero cell 0 of the output program.
  +      Increment the second cell, setting it back to 45 ('-').
  <,     Go back to the leftmost cell and read another character from STDIN.
]      Once EOF is reached, this will put 0 in the leftmost cell, ending the loop.

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

2
उस दुभाषिया में बहुत सारी सेटिंग्स हैं। 32 बाइट संस्करण के लिए, आपको गतिशील मेमोरी और इनपुट के अंत की\0 आवश्यकता होगी :।
डेनिस

10

ब्रेनफक, 35 13 43 बाइट्स

++[>+<------],[[>.>+<<-]>+++.->[<.>-]<--<,]

यह उत्तर आउटपुट प्रोग्राम के इंटरप्रेटर के बारे में कोई धारणा नहीं बनाता है । इसे ऑनलाइन आज़माएं!

एक छोटे समाधान के लिए (जो केवल कुछ दुभाषियों के साथ काम करता है), मेरे दूसरे उत्तर को देखें

परीक्षण चालन

इनपुट के लिए Code Golf, निम्न आउटपुट उत्पन्न होता है।

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-------------------------------------------------------------------+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.---------------------------------------------------------------------------------------------------------------++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.----------------------------------------------------------------------------------------------------+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-----------------------------------------------------------------------------------------------------++++++++++++++++++++++++++++++++.--------------------------------+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.-----------------------------------------------------------------------+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.---------------------------------------------------------------------------------------------------------------++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.------------------------------------------------------------------------------------------------------------++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.------------------------------------------------------------------------------------------------------+++++++++++++++++++++++++++++++++.---------------------------------

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

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

हम टेप के दूसरे सेल में पूर्णांक 43 (चरित्र कोड +) डालकर शुरू करते हैं । निम्न कोड इसे प्राप्त करता है।

++         Increment the first cell twice, setting it to 2.
[          While the first cell in non-zero:
  >+         Increment the second cell.
  <------    Decrement the first cell six times.
]

यह अनिवार्य रूप से मॉड्यूलर विभाजन 2 perform 6 (मॉड 256) करता है । चूंकि (2 + 256) = 6 = 258 43 6 = 43 , परिणाम 43 , जैसा कि इरादा है।

अब हम आउटपुट तैयार करने के लिए तैयार हैं।

,      Read a character from STDIN and put it the first cell.
[        While the first cell is non-zero:
  [        While the first cell is non-zero:
    >.     Print the content of the second cell ('+').
    >+     Increment the third cell.
    <<-    Decrement the first cell.
  ]      If the first cell held n, the above prints n plus signs
         and puts n in the third cell.
  >+++   Add three to the second cell, setting it to 46 ('.').
  .      Print its content ('.').
  -      Decrement, setting it to 45 ('-').
  >      Advance to the third cell.
  [      While the third cell is non-zero:
    <.     Print the content of the second cell ('-').
    >-     Decrement the third cell.
  ]      If the first cell held n, the above prints n minus signs,
         thus negating the plus signs and zeroing the cell of the output program.
  <--    Subtract 2 from the second cell, setting it back to 43.
  <,     Go back to the first cell and read another character from STDIN.
]      Once EOF is reached, ',' will put 0 in the first cell, ending the loop.

ओ आदमी! आप क्रॉस-आउट-44-is-44 मेम नहीं तोड़ सकते, चलो! वैसे भी इसे हराने की आपकी कोशिश बुरी तरह से विफल रही क्योंकि यह बाहर नहीं दिखता है, ऐसा लगता है कि मेरी स्क्रीन पर कुछ गंदगी है (PHP, शायद?): पी
बिल्ली

2
उस टिप्पणी से बचने के लिए कुछ भी ...
डेनिस


4

05AB1E, 12 11 बाइट्स

vyÇ`'+ׄ.>J

व्याख्या की

v             # for each char in input string
 yÇ`          # convert to its ascii value
    '+×       # push the char '+' that many times
       „.>J   # push string ".>" and join with the plus signs
              # implicitly print combined string

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

@ अदनान को 1 बाइट धन्यवाद दिया


'+×इसके बजाय F'+}एक बाइट बचाता है।
अदनान

1
@ अदनान: धन्यवाद! मैं "रिपीट" कमांड ढूंढ रहा था।
इमीना

4

जावा, 98 बाइट्स

class a{String A(char[]b){String z="";for(char B:b){for(int c=B;c-->0;)z+="+";z+=".>";}return z;}}

Strings char[]उपयोगिता विधियों के एक समूह के साथ अपरिवर्तनीय s से अधिक कुछ नहीं हैं , इसलिए चलो सरणी का उपयोग करें!

Ungolfed:

class a {
    void A(char[] b) {
        for (char B : b) {
            for (int c = B; c-- > 0;)
                 System.out.print('+');
            System.out.print(".>");
        }
    }
}

समतुल्य स्टैंडअलोन प्रोग्राम जो कि 138 बाइट लंबा है:

interface a{static void main(String[]A){for(char b:A[0].toCharArray()){for(int B=b;B-->0;)System.out.print('+');System.out.print(".>");}}}

बक्शीश:

interface a{static void main(String[]A){for(char b:new java.util.Scanner(new java.io.File(A[0])).useDelimiter("\\Z").next().toCharArray()){for(int B=b;B>0;B--)System.out.print('+');System.out.print(".>");}}}

यह 207-बाइट ऐप वास्तव में बीएफ प्रोग्राम के रूप में एक फ़ाइल को एनकोड करता है, जैसा कि शीर्षक में कहा गया है।


2
क्या यह सिर्फ मुझे या जिस तरह से अनऑर्गनाइज्ड प्रोग्राम इंडेंट लुक कमाल का है?
user8397947

इससे पहले कि मैं जवाब दिया कि मेरा जवाब मूल रूप से तुम्हारा का एक गोल्फ नीचे संस्करण है एहसास हुआ।
पागल

2

विटसी, 19 17 बाइट्स

I\[&'>.+'i1-\Du]Z

I                     Get the length of the input stack.
 \[            ]      Pop n, repeat this block of code n times.
   &                  Push a new stack and move to it.
    '>.+'             Push the string '+.>' to the stack.
         i            Pop an item from the input stack and push it to the current
                      program stack.
          1-          Subtract one from the top program stack item.
            \D        Duplicate the '+' in the stack that many times.
              u       Merge the current program stack with the previous.
                Z     Output the entire current stack as a string.

ध्यान दें कि यह उत्तर उन कुछ समयों में से एक है जिसका मैंने कभी उपयोग किया है Iऔर u। : डी

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


2

, 13 बाइट्स

i{'+n#*".>"}d

स्पष्टीकरण:

i              Read standard input into a string and push it onto the stack.
 {         }d  For each character in the string...
  '+           Push "+".
    n#         Convert the character (n) to its ASCII code.
      *        Multiply the "+" by the character code to get the number of +'s needed.
       ".>"    Push the string ".>".
               In O, the stack is printed after execution, so this prints out the result.

2

K6, 16 बाइट्स

,/{|">.",x#"+"}'

प्रयोग

,/{|">.",x#"+"}'"some string"

व्याख्या

  {           }'  For each character in the string...
         x#"+"    Repeat "+" as many times as the character's ASCII code.
        ,         Combine that with...
    ">."          The code to print it and move on.
   |              But we put the string together backwards...so now it gets reversed.
,/                Combine all the substrings into one BIG string.

स्पष्टीकरण plz: D
Addison Crump

@VTCAKAVSMoACE हो गया! :)
kirbyfan64sos

2

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

lambda s:''.join('+'*ord(c)+'.>'for c in s)

पायथन प्रत्येक वर्ण के ASCII कोड के बराबर कई प्लस रखता है, उसके बाद .> अगले सेल में प्रिंट और स्थानांतरित होता है। सही मूल्य, प्रिंट, और अगले सेल पर आगे बढ़ने के लिए ब्रेनफैक बढ़ जाता है।

के लिए उत्पादन hi(स्पष्टता के लिए newlines के साथ):

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>

उस कार्यक्रम का आउटपुट:

hi

2

पर्ल, 25 बाइट्स

s/./"+"x ord($&).".>"/eg

प्रयोग

echo -n hi | perl -pe 's/./"+"x ord($&).".>"/eg'

व्याख्या

+उस वर्ण के क्रमिक मान से परिकलित संख्या के साथ मानक इनपुट पर दी गई प्रत्येक पंक्ति में प्रत्येक वर्ण को बदलने के लिए ऑपरेशन की जगह एक नियमित अभिव्यक्ति का उपयोग करता है , फिर .>अगले वर्ण के लिए प्रिंट और अग्रिम करने के लिए आउटपुट देता है।

-pस्वचालित रूप से इनपुट को पढ़ने और परिणाम को प्रिंट करने के लिए पर्ल फ्लैग का उपयोग करता है , जो कि 1 अतिरिक्त बाइटकाउंट को जोड़ता है।


2

जावा, 91 बाइट्स

String b(char[] f){String k="";for(char b:f){for(int u=b;u>0;u--)k+="+";k+=".>";}return k;}

मेरी पिटाई के लिए dorukayhan को सहारा :)


आप केवल बॉयलरप्लेट को हटा नहीं सकते हैं और चर के सभी नामों को बदल सकते हैं और फिर एक नए उत्तर के रूप में दावा कर सकते हैं।
लीक

@ LeakyNun मैंने नहीं किया था, लेकिन मैं चाहता तो कर सकता था।
इन्सान

यह उत्तर आपके द्वारा जुड़े उत्तर से अलग कैसे है?
लीक नून

@LeakyNun डाउनवोट और आगे बढ़ें
Insane

2

सी, 72 64 60 बाइट्स

main(c){for(;c=~getchar();)for(;printf(~c++?"+":".>")^2;);}

Ungolfed संस्करण:

main( c )
{
    for ( ; c = ~getchar( ); )
        for ( ; printf( ~c++ ? "+" : ".>" ) ^ 2; );
}

संकलन और परीक्षण:
gcc -o bfcat bfcatgolf.c && cat 1.txt | ./bfcat > o.txt && beef o.txt

परिणाम


cबिटवाइज़ का उलटा क्यों होता है getchar, खासकर अगर आप उलटे को फिर से उल्टा करते हैं?
बिल्ली

@cat c = ~getchar( )0 पर मूल्यांकन करता है EOFc = ~getchar( )और ~c++बस की तुलना में कम कर रहे हैं ~( c = getchar( ) )औरc--
Jacajack

2

CJam, 12 बाइट्स

प्रत्येक वर्ण को उसके ASCII मान में परिवर्तित करता है, और वर्तमान सेल को प्रिंट करने से पहले उस संख्या से बढ़ाता है। चूंकि हमारे पास अनंत टेप हैं इसलिए हम प्रत्येक वर्ण को संसाधित करने के बाद दाईं ओर जा सकते हैं।

q{i'+*'.'>}%

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


2

लूआ, 67 66 61 बाइट्स

बस तर्क में प्रत्येक वर्ण पर पुनरावृत्ति करें, और प्रत्येक के लिए एक पंक्ति प्रिंट करें n +.> जहां से उसके बादn ASCII तालिका में इस वर्ण का मान है, करें।

Gsatch समाधान के ऊपर 1 बाइट बचाने के लिए टिप्पणी में सलाह दी गई @LeakyNun के रूप में gmatch का उपयोग करता है

for c in(...):gmatch"."do print(("+"):rep(c:byte())..".>")end

पुराने समाधान gsub का उपयोग कर

(...):gsub(".",function(c)print(c.rep("+",c:byte())..".>")end)

पुराना ६

(...):gsub(".",function(c)print(string.rep("+",c:byte())..".>")end)

इसे चलाने के लिए, बस इसे एक फ़ाइल ( golf.luaउदाहरण के लिए) के रूप में सहेजें और इसके साथ चलाएं lua golf.lua "hi"। इसके लिए hi, यह आउटपुट होना चाहिए

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>

मैं इसका प्रयोग कैसे करूं? बस इसे REPL में चिपकाने से attempt to index a nil value, और f = ...वही देता है, और function f ... endदेता हैunexpected symbol near ':'
बिल्ली

@ बस इसे एक फ़ाइल में सहेजें और इसे चलाएं lua file.lua "argument", मैं निर्देश देने के लिए पोस्ट को अपडेट करूंगा।
काटेन्को

इससे काम होता ही कैसे है? है ...argv साथ एक पहचानकर्ता?
बिल्ली

1
@cat अनपैक्ड ...टेबल में मान सम्‍मिलित करता है arg। जिसका अर्थ है कि यह हमेशा arg[1]तब तक अनुरूप होगा जब तक कि आप इसे अंतिम पैरामीटर के रूप में फ़ंक्शन कॉल में उपयोग नहीं करते हैं, तब यह खर्च करेगा।
कटेन्को

n=...for n:gmatch"."do print(("+"):rep(c:byte())..".>")end48 बाइट्स के लिए
लीके नन

1

जे, 28 बाइट्स

[:;[:('.>',~'+'#~])"0[:]3&u:

काफी सरल। 3&u:चार्ट को चार्ट में बदल देता है। बाकी बस '+'उस समय की संख्या को दोहराएं , फिर उसके साथ सहमति.> प्रत्येक पंक्ति के अंत में , और; समतल करते हैं परिणाम को समतल करते हैं।

कुछ परिणाम

   bf =: [:;[:('>.',~'+'#~])"0[:]3&u:
   bf 'hi'
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>. +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>.
   bf ' !'
++++++++++++++++++++++++++++++++>. +++++++++++++++++++++++++++++++++>.
   bf ' ~'
++++++++++++++++++++++++++++++++>.
                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>.


1

दरअसल, 13 बाइट्स

O`'+*".>"@`MΣ

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

यहां उपयोग की जाने वाली रणनीति अन्य कई समाधानों की तरह ही है - प्रत्येक चरित्र के लिए, पर्याप्त +ASCII अध्यादेश को एक शून्य-आरंभिक सेल बढ़ाने के लिए आउटपुट, इसके साथ आउटपुट ., और इसके साथ अगले सेल पर जाएं>

स्पष्टीकरण:

O`'+*".>"@`MΣ
O              list of ordinals (technically this is Unicode code points, but code points 0-127 are the same for Unicode and ASCII)
 `'+*".>"@`M   for each ordinal:
  '+*            push a string containing that many +s
     ".>"@       push ".>" and swap (putting it before the +s)
            Σ  concatenate all the strings (if "[", "]", and "," weren't meaningful characters in BF, this technically wouldn't be necessary)

1

माउस- 2002, 27 बाइट्स

(?'l:l.^(l.^"+"l.1-l:)".>")

यह सिद्धांत में और भाषा के प्रलेखन के अनुसार काम करता है, लेकिन माउस के दुभाषिया के संदर्भ कार्यान्वयन में एक बग लगता है जहां स्ट्रिंग इनपुट एक संलग्न करता है ', इसलिए aइस आउटपुट के लिए

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++.>

जो बदले में आउटपुट देता है a'। यह ठीक हो सकता है या नहीं भी हो सकता है, इसलिए यहां एक 39 बाइट लंबी है, जो 'कभी आउटपुट नहीं करती है और इस तरह अधिक अमान्य है।

(?'l:l.39=l.0=+0=^(l.0>^"+"l.1-l:)".>")

जो सन्दर्भ निहित में सही आउटपुट देता है। जब तक हैं नहीं' s हैं :)

व्याख्या की:

(              ~ while (true) {
  ?' l:        ~   l = getchar() 
  l. ^         ~   if (! (l) ) { break }
  (            ~   while (true) {
    l. ^       ~     if (! (l) ) { break }
    "+"        ~     puts("+")
    l. 1 - l:  ~     l-- // l = l - 1
  )            ~   }
  ".>"         ~   puts(".>")
)              ~ }

1

फैक्टर, 58 बाइट्स

[ [ [ 43 ] ""replicate-as ".>"append ] { } map-as ""join ]

जैसे काम करता है:

[ 
  [ 
    [ 43 ] "" replicate-as  ! ``+'' * code point, clone-like a string ""
    ".>" append             ! append ".>"
  ] 
  { } map-as                ! for each char in string and clone-like an array { }
  "" join                   ! join array of str into str by ""
]

चूंकि फैक्टर एक ब्रेनफैक दुभाषिया के साथ आता है, इसलिए यह परीक्षण करना सरल है।

bfcat.factor

USING: sequences ;
IN: bfcat

: string>brainfuck ( s -- bf )
  [ [ 43 ] "" replicate-as ".>" append ]
  { } map-as "" join ;

bfcat-tests.factor

USING: tools.test bfcat brainfuck ;
IN: bfcat.tests

{ "a"  } [ "a"  string>brainfuck get-brainfuck ] unit-test
{ "ab" } [ "ab" string>brainfuck get-brainfuck ] unit-test
{ "+++++++++++++" } [ "+++++++++++++" string>brainfuck get-brainfuck ] unit-test
{ "Code Golf" } [ "Code Golf" string>brainfuck get-brainfuck ] unit-test

उत्पादन

Unit Test: { { "a" } [ "a" string>brainfuck get-brainfuck ] }
Unit Test: { { "ab" } [ "ab" string>brainfuck get-brainfuck ] }
Unit Test: {
    { "+++++++++++++" }
    [ "+++++++++++++" string>brainfuck get-brainfuck ]
}
Unit Test: {
    { "Code Golf" }
    [ "Code Golf" string>brainfuck get-brainfuck ]
}

वाह! वे सभी पास हैं।


1

माणिक, 40 38 बाइट्स

gets.chop.each_byte{|o|puts"+"*o+".>"}

मैं माणिक नहीं जानता, लेकिन मैं जानता हूं कि आप putsइसके बजाय उपयोग कर सकते हैं print, क्योंकि आउटपुट का प्रारूप महत्वपूर्ण नहीं है, जब तक कि यह वैध है और ब्रेनफक अन्य पात्रों के बारे में परवाह नहीं करता है
बिल्ली

@cat ओह मुझे नहीं पता था कि bf अन्य पात्रों को अनदेखा करता है, धन्यवाद!
कोकोनट

1

साइडफ , 38 बाइट्स

अरे, रूबी जितनी ही लंबाई! बस वह साइड रूबी रूबी नहीं है: डी

read().bytes.each{|c|say"+"*c;say".>"}

कुछ चार्ट पढ़ें, फिर प्रत्येक बाइट के लिए उस चीज़ को करें।


1

जीएनयू बैश, 100 85 बाइट्स

while IFS= read -rn1 c;do printf '+%.0s' $(seq 1 $(printf %d \'$c));echo '.>';done<$1

धन्यवाद मुझे 15 बाइट बचाने के लिए @cat !

Postramble

  1. मान लेता है कि इनपुट स्ट्रिंग को पहली दलील के रूप में पारित फाइल में दर्शाया गया है।
  2. उपयोग: bash bfcat.sh <path to file containing string>
  3. उपयोग (नामित पाइप के साथ): bash bfcat.sh <(echo -n '<string>')

Ungolfed

while IFS= read -r -n1 c # Read file byte by byte [1]
do
    n=$(printf "%d" \'"$c") # `ord` of a char in bash [2]
    printf '+%.0s' $(seq 1 $n) # emit character $n times [3]
    echo '.>' # Emit output and shift command for bf. I love infinite memory.
done <"$1"

Ungolfed संस्करण में संदर्भ

  1. फाइल बाइट को बाईट पढ़ें

  2. ord बैश में एक चार की

  3. एमिट चरित्र $ n बार


1
मैंने आपके उत्तर में कुछ स्वरूपण और सामग्री में सुधार किया है, और लिंक से अनावश्यक जानकारी हटा दी है। यदि आपको यह पसंद नहीं है, तो इसे पूर्ववत करें। इसके अलावा, यह GNU बैश है, GNU / Linux की तरह GNU / बैश नहीं है। :)
बिल्ली

1
गोल्फ युक्तियाँ (मैं बैश गोल्फर नहीं हूँ):, read -rn1रिक्त स्थान से छुटकारा पाने के बाद ;, done <"$1"कुल 9 बाइट बचाने के लिए जगह से छुटकारा पाएं
बिल्ली

1
@ यह बहुत बढ़िया लग रहा है! मुझे वास्तव में संपादित करने की आदत प्राप्त करने की आवश्यकता है-> पूर्वावलोकन-> संपादन -> ...
येव_मेंग

1

ईएस 6, 119 115 बाइट्स

f=s=>{a='';for(i in[...s]){b=s[c='charCodeAt'](i)-(s[c](i-1)|0);a+=(b>0?'+'.repeat(b):'-'.repeat(-b))+'.'}return a}

सहेजे गए 4 बाइट्स, @Leibrug की बदौलत


1
आप charCodeAtकुछ संस्करण ( cजैसे कहते हैं ) को असाइन कर सकते हैं और उस तरह का उपयोग कर सकते हैं : s[c](i)1 बाइट को छोटा करने के लिए, और कुछ वर्णों को भी हटा दें (मैं 3 पाया: पहले की [...s]जगह, तार्किक को बदलें या बिटवाइज़ एक, और अर्धविराम से पहले return)।
लीब्रुग


0

रूबी, 26 बाइट्स

gsub(/./){?+*$&.ord+'.>'}

pकमांड लाइन विकल्प के लिए + 1 बाइट । जैसे आप प्राप्त ABC xyzकर सकते हैं के लिए brainfuck कोड प्राप्त करने के लिए

$ ruby -p -e 'gsub(/./){?+*$&.ord+".>"}' <<< "ABC xyz"

और पाओ

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>

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