46

OO CODE में लिखे गए प्रोग्राम के इनपुट को देखते हुए , BF कोड को आउटपुट करता है जो इसे दर्शाता है।

यहाँ कैसे सीओओ काम करता है का एक संक्षिप्त विवरण है:

सबसे पहले, सभी गैर-वर्णनात्मक वर्ण हटा दिए जाते हैं (श्रेणी में सब कुछ नहीं A-Za-z)।

उदाहरण के लिए, प्रोग्राम ले लो PROgRam reVERsES giVeN iNPut sEqUENcE(esolangs विकी पृष्ठ पर दिया गया एक उदाहरण जो वास्तव में आप क्या उम्मीद करेंगे)। इस पहले कदम के बाद, अब हमारे पास है PROgRamreVERsESgiVeNiNPutsEqUENcE।
अगला, सभी शेष वर्णों को 3. के समूहों में विभाजित करें PRO,gRa,mre,VER,sES,giV,eNi,NPu,tsE,qUE,NcE। अब हमारे पास है । यदि 1 या 2 वर्णों का अनुगामी समूह है, तो उसे छोड़ दें।
निम्न तालिका के आधार पर 3 अक्षरों के प्रत्येक समूह को BF कमांड में परिवर्तित करें:
```
ooo  >
ooO  <
oOo  [
oOO  ]
Ooo  -
OoO  +
OOo  .
OOO  ,
```
यही है, अगर एक समूह का पहला अक्षर लोअरकेस है, तो दूसरा अपरकेस है, और तीसरा लोअरकेस है, यह कमांड में अनुवाद करेगा [।

हमारे उदाहरण के साथ, यह अंततः बीएफ प्रोग्राम बन जाता है ,[>,]<[.<]+, जो वास्तव में इसके इनपुट को उलट देता है।

चूंकि यह कोड-गोल्फ है , बाइट्स में सबसे छोटा कोड जीत जाएगा।

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

<empty string> -> <empty string>
A -> <empty string>
Ab -> <empty string>
Abc -> -
AbcD -> -
AbcDe -> -
AbcDef -> --
1A_b%c*D[]e\\\f! -> --
PROgRamreVERsESgiVeNiNPutsEqUENcE -> ,[>,]<[.<]+

— Doorknob
स्रोत

26

मैं किसी जवाब के साथ इंतजार कर रहा हूं ऊ ...

— ग्लोरफाइंडेल

17

@Glorfindel: उपकृत करने के लिए खुश।

— nnonneo

127

ऊ, 1569 1515 बाइट्स

किया जाना था। इसे यहाँ आज़माएँ ।

golfed:

oooooooooOoOoooooooooooooooOoOooooooOOOoOoooooooOoOOoOOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOoooOoOOoOOoOOoOOoOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooOoOooooOoOoooooOoOooOoOOoooOoOooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOoOoOoooooOoooOoooooOOooOooOoOOooOoOoOoooooooooOoOoooOOooOooOoOOooOoOoOooooOooOooOooOooOooOooOooOooOooOooOOoOoooooooooooooooooooooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooOooOooOooOooOooOooOooOooOOoOooooooooooooOoOoooooooooooooooooooooooooOoOoooOOooOooOooOooOoOOoOOooOoOoOooooooooooooOoOoooOOooOooOooOooOoOOooOooOooOooOooOooOooOoOoooooOooooooooooooooooOoOOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOOoOooOooOooOoOoooooOoooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOooooooOOooOoOooooOoOooooOooooOooooOooOOoooooOoooOOooOoOoooooooOoOooOooOOoooOOooOOoooOOooOOooooooOOooOoOooooOoOooooooooooooOoOOoOOoOOoOoOoooOOoOOoOOoOOoOoooOoooOOooOooOooOoOooooooooooOoOOoOOoOOoOOoOoOoooOOoOOoOOoOOoOOoOOoOoooOoooOOooOOoOooOoOooooOoOOoOooOooOOoooooOoooOOooOoOoOoooOOooOOooooooOOooOoOooooOoOooooOoooOOoooooOoooOOooOoOoooooooOoOOoOooOooOOoooOOooOOoooOOooOOoooOOOoOooooooooooooOOooOoOoooOOooOooOooOooOooOOooooOOooooOOoooOOoOOooooooooooooooooooooooooOoOooooooOOOoOO

ब्रेनफक में अनुवादित (स्पष्टता के लिए लाइनब्रेक के साथ):

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

स्पष्टीकरण के साथ अपुष्ट:

this progrAm Translates ooo codE tO brainfUCK cOde. i guesS sINcE ThE ExAMpLE
tEXt WAs SeLf-doCUmENtINg, I ShOUlD PrOBaBLy Make This SElf-DOcUmeNtInG too.

oh, I shoUld menTIon ThaT i WRotE tHe OriginAl BrainFuCk code EnTirElY By haNd.
If you waNt TO sEE tHE bRAiNfUck cODe, RUn THiS PrOGrAm wiTh itSElf AS iNPuT!

baSiCaLly, thiS proGram seTS up MemOrY As fOlLoWs: the fIrSt thrEe Bytes aRe
"ValId" FLags (V0, v1, V2), theN tHErE'S a BArRIeR (A 1) fOLlOweD bY tHree
"vaLue" bIts (b0, b1, b2). THe rEst Of THe aRrAy Is basiCaLly juSt ScratcH
sPacE. tO Save SpAce, i'm slIdINg THe POiNTeR fOrwaRD bY OnE In EAcH ItEratIon
uNTil THe POiNteR hItS the baRrieR, at whiCH poInt ThE ProGrAm Prints out tHe
ConvERteD chArACteR.

tHe ProgrAm eXteNsiVelY usEs tHe cLevEr "gReaTEr-Than" comparison operator
described by dheeraj ram aT
hTtp://sTAckOveRflOw.cOm/QUeSTioNs/6168584/BrAinfuck-comparE-2-nUmbeRS. i hAppEn
tO reAlLY lIKe tHiS iMplemEntAtiOn bEcaUse It iS boTh cOMpAct and nestablE,
wHich is critical for my bf code tO wOrk pROpeRly.

I seT up ThE ReQUisItE sTructure, then pErForm A BunCh oF neSteD cOMpaRisOns
ThaT loOk rOugHlY like tHis:

    if(in >= 65 /* capital a */) {
        if(In <= 90 /* CApITaL Z */) {
            vI = 1
            Bi = 1
        } ELsE {
            iF(in >= 97 /* lOWeRCaSE a */) {
                IF(iN <= 122 /* LoWErCAsE z */) {
                    vi = 1
                }
            }
        }
    }

At thE End OF tHEsE coMpaRisOnS, if the V (valid) Bit iS Set, the ProgRAm sTePs
the poiNtER rIghTwaRDs. if IT hiTS the barRIer, It Then gOeS into A big sEt of
nEstED condiTionALs tHaT test the AcCumUlaTEd vaLUe bITs, anD ConSTruct thE
CorReSpondInG character to pRiNT oUT. tHEn It ReseTS bACk TO tHE iNitiAl stATe.

fInaLly, It Reads anotheR iNPuT ChARaCTeR aNd goES bACk TO lOOpINg.

SO tHere You hAVe iT - An Ooo To BrainFuCK cOnvErtER writtEn in OOo (aNd
BrAinfUCk, bY ExtensiON!). siNcE i havE a Few moRe chARacterS to sPAre In This
progRaM, HeRe's A coUPle oF StrESs teST paTTernS:

0123456789ABcDefghijklmnopQRstUvWxyzABcdEfgHijKlmNopQRstuvWXyz!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ 
 ~}|{`_^]\[@?>=<;:/.-,+*)('&%$#"!zyXWvutSRqPOnmlkjihgfedcbazyxwvutsrqPoNmlkjihGFEdCBa9876543210

दिलचस्प चुनौती के लिए धन्यवाद!

— nneonneo
स्रोत

1

हे भगवान ... यह महाकाव्य है! बहुत बढ़िया।

— R

11

... वाह। मैं प्रभावित हु। जिज्ञासु के लिए: goo.gl/vbh3h9 (पूरा प्रयास करें ऑनलाइन लिंक स्पष्ट कारणों के लिए बहुत लंबा था)।

— दरवाज़े

1

गोल्फ / चेरों का एक समूह अनुकूलित। नया प्रयास लिंक: goo.gl/ISjwLB

— nneonneo

7

यह सबसे अच्छा है जो मैंने इस साइट पर देखा है

— नौ

15

@Texenox उस मामले में, प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! मुझे यकीन है कि आपको इसके आसपास कई और उत्तर मिलेंगे जो आपके दिमाग में उस "सबसे अच्छी बात जो मैंने देखी है" के लिए

— दावेदार होंगे

15

CJam, 36 35 बाइट्स

l{el_eu-},'_f<0+3/W<2fb"><[]-+.,"f=

इसका परीक्षण यहां करें।

व्याख्या

l               e# Read input.
{el_eu-},       e# Discard all characters that don't change in a lower/upper case
                e# transformation, i.e. non-letters.
'_f<            e# Compare with '_' to determine case as 0 or 1.
0+              e# Append a zero.
3/              e# Split into chunks of 3.
W<              e# Discard last chunk.
2fb             e# Convert each chunk from base 2.
",.+-][<>"f=    e# Select the corresponding character for each chunk.

— मार्टिन एंडर
स्रोत

एक मान जोड़ें और अंतिम हिस्सा त्यागें: चतुर!

— लुइस मेंडो

आह, जो वास्तव में चतुर है

— अदनान

9

जावास्क्रिप्ट (ईएस 6), 94 93 91 85 84 83 बाइट्स

@ देव-नल को 1 बाइट धन्यवाद दिया

x=>x.replace(/[a-z]/gi,c=>(a+=c<'a'|0)[2]?b+="><[]-+.,"['0b'+a-(a="")]:0,a=b="")&&b

मैंने इसके कई प्रकार आज़माए हैं, लेकिन यह सबसे छोटा लगता है। खाली इनपुट पर भी काम करता है!

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

सबसे पहले, x.replace(/[a-z]/gi,c=>हम cइनपुट में प्रत्येक अक्षर लेते हैं । हम सेट aऔर bकरने के लिए ""समारोह कॉल के दूसरे छोर पर है, क्योंकि समारोह दूसरा अतीत कोई पैरामीटर ध्यान नहीं देता। aयह निर्धारित करने के लिए कि हम वर्तमान में क्या चरित्र बना रहे हैं, और bपरिणाम को संग्रहीत करेगा , के लिए एक बाइनरी स्ट्रिंग संग्रहीत करेगा।

भ्रामक भाग के लिए अब: सबसे पहले (a+=+(c<'a')), हम एक 0को जोड़ते हैं aअगर cऊपरवाला है; 1अन्यथा। यह अभिव्यक्ति का नया मान लौटाता है a, इसलिए हम जांच कर सकते हैं कि क्या यह सूचकांक की लंबाई के तीन वर्णों तक पहुंच गया है या नहीं, यह जांचकर कि क्या सूचकांक में मौजूद चरित्र मौजूद है [2]?:। यदि नहीं, तो हम केवल फ़ंक्शन को समाप्त करते हैं :0।

यदि aअब लंबाई में तीन वर्ण हैं, तो यह 000और के बीच एक द्विआधारी संख्या है 111। हम इसे "0b"शुरुआत में जोड़कर एक दशमलव संख्या में बदल सकते हैं , फिर इंजन को इसके साथ संख्या के रूप में पार्स करने के लिए मजबूर करते हैं '0b'+a-0।

हालांकि, हमें अभी भी aखाली स्ट्रिंग को रीसेट करने की आवश्यकता है । हम सिर्फ '0b'+(a="")-0इसलिए नहीं कर सकते क्योंकि इसका मतलब यह है कि स्ट्रिंग को पार्स किया गया है 0b। सौभाग्य से, जब एक संख्या के रूप में पार्स किया जाता है, तो खाली स्ट्रिंग 0 हो जाती है, इसलिए हम इसके 0साथ बदल सकते हैं (a="")।

अब हम हमारी संख्या है, और हम सिर्फ यह है कि सूचकांक में चरित्र जोड़ सकते हैं "><[]-+.,"करने के लिए b। प्रतिस्थापित होने के बाद, हम &&bइसे फ़ंक्शन से वापस करने के लिए उपयोग करते हैं। (ठीक है, जब तक कि परिणाम .replaceखाली न हो, जो केवल खाली इनपुट पर होता है और वैसे भी खाली स्ट्रिंग लौटाता है।)

— ETHproductions
स्रोत

नाइस वन बाइट के साथ बचाओ: '0b'+a-0बनाम +`0b${a}`और+("0b"+a)

— andlrc

तो, आखिर replaceजीतता है!

— नील

@ नील तुम नीचे matchनिशान का नेतृत्व करने के लिए खेद है ...

— and'rc

नवीनतम संस्करण में प्रमुख गैर-पत्रों के साथ समस्याएं हैं?

— नील

@ नील तुम सही हो। सौभाग्य से, मैं गैर-काम करने वाले से एक चाल का उपयोग करके काम करने वाले संस्करण के बाइट को गोल्फ में कामयाब रहा।

— 1

8

05AB1E , 35 32 बाइट्स

कोड:

á0«3÷\)vyS).uïJC",.+-][<>"Sr@?)\

इस उत्तर से, मार्टिन ब्यूटनर की एक बहुत ही चतुर चाल का उपयोग करना । स्पष्टीकरण:

á0«                               # Remove all non-alphabetic characters and append a zero
   3÷\                            # Split into pieces of 3 and discard the last one
      )v                          # Wrap everything into an array and map over it
        yS).uï                    # Is uppercase? Converts AbC to [1, 0, 1]
              JC                  # Join and convert from binary to int
                ",.+-][<>"        # Push this string
                          S       # Split the string
                           r@     # Reverse the stack and get the character from that index
                             ?    # Pop and print without a newline
                              )\  # Wrap everything into an array and pop

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

CP-1252 एन्कोडिंग का उपयोग करता है ।

— अदनान
स्रोत

8

रेटिना , 79 75 71 70 बाइट्स

1 बाइट बचाने के लिए यादृच्छिक के लिए धन्यवाद।

i`[^a-z]

M!`...
m`^
;
+`(.*);(.)
$1$1$2;
T`l
.+
$.&
T`d`_><[]\-+.,
¶

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

व्याख्या

i`[^a-z]

हम सब कुछ हटाकर शुरू करते हैं जो एक पत्र नहीं है।

M!`...

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

m`^
;

;प्रत्येक पंक्ति के लिए एक प्रस्तुत करना। हम इसका उपयोग आधार -2 रूपांतरण के लिए एक मार्कर के रूप में करेंगे। जिसमें से बोलते हुए, हम केवल ऊपरी-केस अक्षरों के रूप में 1और निम्न-केस अक्षरों के रूप में व्यवहार करेंगे 0।

+`(.*);(.)
$1$1$2;

यह एक आधारभूत रूपांतरण करने के लिए एक अजीब आधार -2 करता है। प्रत्येक चरण में हम केवल बचे हुए वर्णों को दोहराते हैं ;और ;एक को दाईं ओर ले जाते हैं। यह काम क्यों करता है? याद रखें कि हम निचले मामले को 0और ऊपरी मामले की व्याख्या कर रहे हैं 1। जब भी हम किसी पत्र को संसाधित करते हैं, तो हम बस चल रहे कुल (बाईं ओर) को अब तक दोगुना करते हैं - डबल लोअर-केस अक्षर बस हैं 2*0=0, इसलिए उन्हें पूरी तरह से नजरअंदाज किया जा सकता है और ऊपरी-मामले पत्र अब तक द्विआधारी संख्या का प्रतिनिधित्व करते हैं, इसलिए उन्हें दोगुना करना है हमें क्या चाहिऐ। फिर हम वर्तमान पत्र को उस रनिंग टोटल में जोड़ते हैं, जो प्रतिनिधित्व करता है 0या 1तदनुसार।

T`l

सभी लोअर-केस अक्षर / शून्य हटा दें।

.+
$.&

प्रत्येक पंक्ति से मिलान करें और उस पंक्ति में वर्णों की दशमलव (दशमलव) संख्या के साथ बदलें। इसके कारण ;यूनिरी नंबर अपने दशमलव समतुल्य + 1 में बदल जाता है।

T`d`_><[]\-+.,

लिप्यंतरण जो संगत कमांड के साथ 1-8 स्थानापन्न करता है।

¶

लाइनफीड हटाएं।

— मार्टिन एंडर
स्रोत

यह तीन वर्णों के विखंडू में विभाजित करने का एक चतुर तरीका है। क्या आपने इससे पहले इसका इस्तेमाल किया है?

— ETHproductions

@ETHproductions मुझे लगता है कि मेरे पास है लेकिन मुझे यकीन नहीं है कि मैं कहाँ हूँ। मैं codegolf.stackexchange.com/a/69518/8478

— मार्टिन

70 बाइट्स और मेरे नए जोड़े गए रेटिना विचारों के साथ थोड़ा कम ।

— रैंडम

@randomra आह अच्छा विचार के लिए ;। मैं बाद में इसे संपादित करूँगा।

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

7

MATL , 38 32 बाइट्स

'><[]-+.,'jt3Y2m)3ZCtAZ)92<!XBQ)

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

'><[]-+.,'      % push string with BF commands
j               % read input as a string
t               % duplicate
3Y2             % predefined literal: string 'A...Za...z'
m               % true for elements of input string that are letters
)               % index into input string to keep only letters
3ZC             % 2D array whose columns are non-overlapping slices of length 3.
                % The last column is padded with zeros if needed
tA              % duplicate. True for columns that don't contain zeros 
Z)              % keep those columns only. This removes padded column, if any
92<             % 1 for upper case letters, 0 for lower case letters in the 2D array
!               % transpose so each group of 3 is a row
XBQ             % convert each row from binary to decimal and add 1
)               % index into string containing the BF commands. Implicitly display

— लुइस मेंडो
स्रोत

5

जाप, 37 36 बाइट्स

Uo"%l" f'.³ £",><[]-+."gX®c ¤gJÃn2Ãq

इसे ऑनलाइन टेस्ट करें!

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

Uo"%l" f'.³ £  ",><[]-+."gX®   c ¤  gJÃ n2Ã q
Uo"%l" f'.³ mX{",><[]-+."gXmZ{Zc s2 gJ} n2} q

Uo"%l"      // Get rid of all non-letter chars in U.
f'.³        // Take each set of three chars in U.
mX{      }  // Map each item X in this group to:
XmZ{     }  //  Map each letter Z in X to:
Zc s2 gJ    //   Take the char code of Z as a binary string, and take the first char.
            //   This maps each character to 1 if it's UC, or 0 if it's lc.
        n2  //  Interpret the result as a binary number.
",><[]-+."g //  Get the item at this index in this string.
q           // Concatenate the result and implicitly output.

— ETHproductions
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 111 95 बाइट्स

s=>s.match(/[A-Z]/gi).map(c=>+(c<'a')).join``.match(/.../g).map(g=>'><[]-+.,'['0b'+g|0]).join``

बस गैर-अक्षरों को हटा देता है, ऊपरी मामले के अक्षरों को 1s में और निचले मामले को 0 में परिवर्तित करता है, तीन के समूहों में विभाजित करता है, 1 या 2 के अनुगामी समूह को अनदेखा करता है, और समूहों को डिकोड करता है।

संपादित करें: सहेजे गए 16 बाइट्स @ dev-null के लिए धन्यवाद, हालांकि खाली स्ट्रिंग पास होने पर कोड अब काम नहीं करता है।

— नील
स्रोत

@ देव-नल उघ, मैंने match(/.../g).map().joinदृष्टिकोण की कोशिश की थी, लेकिन बाइट की संख्या को कम कर दिया और हालांकि इससे मुझे कुछ भी नहीं बचा। पहले मैच पर टिप के लिए धन्यवाद।

— नील

4

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

b=1
for c in input():
 b=-~c.isalpha()*b+c.isupper()
 if b>7:print(end="><[]-+.,"[b-8]);b=1

हम्म ... थोड़ा लंबा दिखता है, खासकर दूसरी पंक्ति। b=[b,2*b+(c<'a')][c.isalpha()]हालांकि थोड़ा खराब है।

— Sp3000
स्रोत

2

इस तरह अंत का उपयोग करना वास्तव में स्मार्ट है। मैंने ऐसा पहले कभी नहीं देखा।

— मॉर्गन थ्रैप

3

पायथ, 40 बाइट्स

jkm@"><[]-+.,"id2f!%lT3cm?rId0Z1f!rIT2z3

यहाँ कोशिश करो!

अगर मैं एक स्ट्रिंग के बजाय वर्णों की सूची के रूप में परिणाम को आउटपुट कर सकता हूं तो 2 बाइट्स बचा सकता है।

व्याख्या

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

jkm @ "> <[] - +।," id2f!% lT3cm? rId0Z1f! rIT2z3 # z = input

                                fz # फिल्टर इनपुट टी के साथ
                                 ! # तार्किक नहीं
                                  rIT2 # T == स्वेपकेस (T), T अक्षर नहीं है तो सच है
                        एम # मानचित्र फ़िल्टर परिणाम d के साथ
                         ? rId0 # अगर d == toLower (d)
                              लोअरकेस के लिए Z1 # 0, अपरकेस के लिए 1
                       सी 3 # 3 के विखंडू में विभाजित करें, यदि आवश्यक हो तो अंतिम तत्व कम है
                 f # फ़िल्टर टी के साथ
                  ! # तार्किक नहीं
                   % lT3 # len (t) mod 3 -> केवल लंबाई 3 के तत्वों को रखें
  d के साथ m # नक्शा
              id2 # बाइनरी से दशमलव में कनवर्ट करें
   @ "> <[] - +।," # परिणामी BF कमांड प्राप्त करें
jk # एक तार से जुड़ें

— Denker
स्रोत

3

जोल्फ, 31 34 बाइट्स

यहाँ कोशिश करो! बदलें ►के साथ \x10और ♣साथ \x05। क्योंकि मैंने चॉप फ़ंक्शन को गलत तरीके से लागू किया है, इसलिए मुझे 3 बाइट्स प्राप्त हैं। :(

►ΜZeZcAAρi♣Epu1pl033d."><[]-+.,"ΙH
        ρi♣E                        remove all space in input
       A    pu1                     replace all uppercase letters with 1
      A        pl0                  replace all lowercase letters with 0
    Zc            3                 chop into groups of three
  Ze               3                keep groups of length three
 Μ                  d               map
                              ΙH   parse element as binary
                     ."><[]-=.,"    and return a member of that
►                                  join by nothing

— कोनोर ओ ब्रायन
स्रोत

3

हून , 212 बाइट्स

=+([v=turn c=curr q=cold k=tape] |=(t/k `k`(v (v `(list k)`(need ((unit (list k)) p:(rose (murn t (c rush alf)) (star (stun [3 3] ;~(pose (q '0' low) (q '1' hig))))))) (c scan bin)) (c snag (rip 3 '><[]-+.,')))))

Ungolfed:

|=  t/tape
^-  tape
%+  turn
  %+  turn  ^-  (list tape)
  %-  need  %-  (unit (list tape))
    =+  t=(murn t (curr rush alf))
    p:(rose t (star (stun [3 3] ;~(pose (cold '0' low) (cold '1' hig)))))
  (curr scan bin)
(curr snag (rip 3 '><[]-+.,'))

इनपुट में सभी वर्णों से छुटकारा पाने के लिए + murn का उपयोग करें जिसे "अल्फ" (वर्णमाला) के साथ पार्स नहीं किया जा सकता है
एक संयोजन के साथ सूची को पार्स करें जो सूची में एक बार में प्रत्येक 3 वर्णों को आउटपुट करता है, '0' के साथ लोअरकेस की जगह और '1' के साथ अपरकेस
परिणाम (यूनिट (सूची टेप)) के लिए कास्ट करें और फ़र्स्टेस्ट पार्स किए गए परिणाम को प्राप्त करने के लिए इसे जबरन खोल दें, बिना दुर्घटनाग्रस्त हुए केवल कई थ्रस्टरों के साथ काम करने के लिए
सूची पर नक्शा, प्रत्येक समूह को पार्स करने के रूप में यदि यह द्विआधारी था
सूची में प्रत्येक संख्या को '> <[] - +।,', और एक टेप में वापस सूची के रूप में सूची में उपयोग करें।

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

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

जब आप Urbit को बूट करते हैं तो आपको इसमें गिरा दिया जाता है: dojo, शेल और हून उत्तर। स्निपेट चलाने के लिए बस टाइप करें:

%.  "PROgRam reVERsES giVeN iNPut sEqUENcE"

और फिर अगली पंक्ति में स्टैंडअलोन फ़ंक्शन पेस्ट करें।

— RenderSettings
स्रोत

PPCG में आपका स्वागत है! आप उत्तर देते हैं कि यह बहुत अच्छी तरह से समझाया गया है, लेकिन क्या आप दुभाषिया या किसी स्थान पर इसे ऑनलाइन करने का प्रयास कर सकते हैं?

— Addison Crump

मैंने Urbit के github पेज के लिए एक लिंक जोड़ा, क्योंकि यह बहुत ही एकमात्र रास्ता है। क्या यह पर्याप्त है?

— रेंडरसेटिंग्स

पूर्ण रूप से। : डी एक पूर्ण कार्यक्रम में यह कैसे उपयोग करने के निर्देश छोड़ने के साथ ही अद्भुत होगा।

— एडिसन क्रम्प

3

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

=Œs¬Tịµ=Œu;0s3ṖḄ€ị“<[]-+.,>

इसे ऑनलाइन आज़माएं! ध्यान दें कि बैकस्लैश को दूसरे अंतिम परीक्षण मामले के लिए इनपुट स्ट्रिंग में भागने की आवश्यकता है।

Implicit input: string s (list of characters)

=Œs             Compare with swapcase
¬               Not - this gives 1 for letters, 0 otherwise
Tị              Take characters at truthy indices
µ               Start a new monadic chain

Input: string s' (list of letters)

=Œu             Compare with uppercase
;0              Append 0
s3              Split into chunks of length 3
Ṗ               Pop last chunk
Ḅ€              Apply convert-from-binary to each chunk
ị“<[]-+.,>      For each number, 1-based index cyclically into the string "<[]-+.,>"

— Sp3000
स्रोत

2

मतलाब, 98 बाइट्स

function t(s);s=s(isletter(s));s=s(1:end-mod(end,3));r='><[]-+.,';r([4 2 1]*reshape(s<92,3,[])+1)

स्वच्छ
ट्रिम
UC = 1, lc = 0 के साथ एक 3xn m मी में पुनः आकार दें
(४ २ १) * m + १ एक सूचकांक सूची में परिणाम है
सही वर्णों का सूचकांक

— जोनास
स्रोत

1

पर्ल, 76 73 72 + 1 = 73 बाइट्स

$a.=y+A-Z++dfor/[A-Z]/gi;print substr"><[]-+.,",oct"0b$_",1for$a=~/.../g

-nध्वज की आवश्यकता है :

$ perl -n oOo.pl <<< 'PROgRamr{}\eVERsESgiVeNiNPutsEqUENcE'
,[>,]<[.<]+

बेस -2 रूपांतरण के साथ चाल का उपयोग करना ।

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

                          # '-n' auto read first line into `$_`
            for/[A-Z]/gi; # Iterate over all letters a-z
$a.=y/A-Z//d              # Count number of uppercase letters (1 or 0)

                                  for$a=~/.../g # Split $b into hunks of 3 characters. And
                                                # remove any potential trailing characters.
      substr"><[]-+.,",oct"0b$_",1              # `oct("0b$binary")` will convert binary
                                                # to decimal.
print

— andlrc
स्रोत

1

जूलिया, 107 बाइट्स

s->"><[]-+.,"[map(j->parse(Int,j,2)+1,[map(i->i<'_'?'1':'0',m)for m=matchall(r"\w{3}",filter(isalpha,s))])]

यह एक अनाम फ़ंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें।

Ungolfed:

function f(s)
    # Brainfuck commands
    bf = "><[]-+.,"

    # Filter out non-alphabetic characters from the input
    chars = filter(isalpha, s)

    # Get all non-overlapping groups of three characters
    groups = matchall(r"\w{3}", chars)

    # Construct binary strings by comparing to _
    binary = [map(i -> i < '_' ? '1' : '0', m) for m = groups]

    # Parse each binary string as an integer and add 1
    indices = map(j -> parse(Int, j, 2) + 1, binary)

    # Return the Brainfuck commands at the indices
    return bf[indices]
end

— एलेक्स ए।
स्रोत

1

लुआ, 120 बाइट्स

string.gsub()यहाँ का बड़ा उपयोग , एक और समय मुझे कुछ बाइट्स प्राप्त करने के लिए इस फ़ंक्शन पर एक चरित्र सूचक बनाने की अनुमति दे सकता है। इसके अलावा, यह किसी भी स्थान के बिना मेरा पहला लुआ कार्यक्रम है! : डी

यह प्रोग्राम कमांड-लाइन तर्क के माध्यम से अपना इनपुट लेता है और ब्रेनफैक प्रोग्राम को आउटपुट करता है, प्रति लाइन एक कमांड।

संपादित करें: सहेजे गए 1 बाइट @ ओलेग वी। वोल्कोव को धन्यवाद

arg[1]:gsub("[%A]",""):gsub("%l",0):gsub("%u",1):gsub("...",function(c)x=1+tonumber(c,2)print(("><[]-+.,"):sub(x,x))end)

Ungolf और स्पष्टीकरण

arg[1]:gsub("[%A]","")    -- replace the non-letter character by an empty string
                          -- %A matches all the character not in %a (letters)
:gsub("%l",0)             -- replace lower case letters by 0s
:gsub("%u",1)             -- replace upper case letters by 1s
:gsub("...",function(c)   -- iterate over all groupe of 3 characters
  x=tonumber(c,2)+1       -- convert the 3-letter group from binary to decimal
  print(("><[]-+.,")      -- output the corresponding brainfuck command
             :sub(x,x))   
end)

— Katenkyo
स्रोत

आप एक बाइट को इनलाइन पर बचा सकते हैं bऔर एक string.gsubको छोटे संस्करण में सहेजने पर और मैन्युअल रूप से इसे करने के लिए पहली दलीलें दे सकते हैं:g=("").gsub g(g(g(g(arg[1],"[%A]",""),"%l",0),"%u",1),"...",function(c)x=1+tonumber(c,2)print(("><[]-+.,"):sub(x,x))end)

— ओलेग वी। वोल्कोव

... या शायद मैं तह पर गलत बाइट गिनती करता हूं। Inlining अभी भी काम करता है।

— ओलेग वी। वोल्कोव

@ ओएलवीवी.वल्कोव एक छोटे संस्करण की लागत को बचाते हुए, दुख की बात है कि अधिक, मैंने एक ही चीज़ की कोशिश की ^ ^। और ख के inlining के लिए धन्यवाद ... मुझे नहीं पता कि मैंने इसे एक var में क्यों सहेजा ...

— Katenkyo

1

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

''.join('><[]-+.,'[int('%d'*3%tuple(map(str.isupper,y)),2)]for y in zip(*[iter(filter(str.isalpha,input()))]*3))

इसे और अधिक निखारने की कोशिश करेंगे।

— दौड़ के लिये कभी भी न उतारा गया घोड़ा
स्रोत

1

मैथेमेटिका, 192 बाइट्स

StringJoin[FromDigits[#,2]&/@Partition[ToCharacterCode@#-48,3]&[StringDelete[#,a_/;!LetterQ[a]]~StringReplace~{_?UpperCaseQ->"1",_?LowerCaseQ->"0"}]/.Thread[0~Range~7->Characters@"><[]-+.,"]]&

अनाम फ़ंक्शन जो वांछित स्ट्रिंग को एक तर्क के रूप में लेता है। (बहुत सीधे) एल्गोरिथ्म में कदम:

स्ट्रिंग साफ करें
UC -> "1", lc -> "0" को बदलें
स्ट्रिंग को बाइनरी सूची में बदल दें
सूची को थ्रोट्स में विभाजित करें और बेस -2 नंबर के रूप में प्रत्येक चंक की व्याख्या करें
संख्याओं को उनके उपयुक्त प्रतीकों से बदलें और वापस एक स्ट्रिंग में शामिल हों।

— hYPotenuser
स्रोत

1

रूबी 117 114 113 111 86 79 बाइट्स

gets.tr(?^+m='a-zA-Z','').tr(m,?0*26+?1).scan(/.../){$><<"><[]-+.,"[$&.to_i 2]}

tr(?^+m='a-zA-Z','')'a-zA-Z'गैर-अक्षरों को m सेट करता है और हटाता है
.tr(m,?0*26+?1) लोअरकेस को 0 में कनवर्ट करता है, अपरकेस 1 को
.scan(/.../) स्ट्रिंग को 3 के समूहों में काटें और अंतिम समूह को त्यागें यदि इसमें 3 से कम है
{$><<"><[]-+.,"[$&.t‌o_i 2]} प्रत्येक बाइनरी नंबर को एक वर्ण में बदलें

— FuzzyTree
स्रोत

क्या आप उपयोग नहीं कर सकते tr("a-zA-Z","01")? या भीtr("A-Za-z",10)

— andlrc

@ देव-नल "AAz".tr("a-zA-Z","01")देता है111

— फजट्री

1

इतना ही यहाँ किया जा सकता है। यह एक शुरुआत है: gets.delete('^a-zA-Z').tr("a-z",?0).tr("^0",?1).scan(/.../){$><<"><[]-+.,"[$&.to_i 2]}(86 बाइट्स)। कमांड लाइन विकल्प से इनपुट को स्टडिन में बदल दिया; आउटपुट में आसपास के उद्धरण तय किए (लेकिन अब इसकी कोई नई सीमा नहीं है)

— daniero

@daniero धन्यवाद! इसे एक सामुदायिक उत्तर बनाया। परिवर्तन करने के लिए स्वतंत्र महसूस करें

— FuzzyTree

1

tr(^a-zA-Z','').tr('a-zA-Z',?0*26+?1)छोटा है

— चार्ल्स

1

पर्ल 6, 81 बाइट्स

यह शायद बेहतर किया जा सकता है, लेकिन इस पर मेरा ध्यान है

{m:g/:i<[a..z]>/;[~] ("><[]-+.,".comb[:2[$_]]for (+(91>$_.ord)for |$/).rotor(3))}

प्रयोग

> my &f = {m:g/:i<[a..z]>/;[~] ("><[]-+.,".comb[:2[$_]]for (+(91>$_.ord)for |$/).rotor(3))}
-> ;; $_? is raw { #`(Block|149805328) ... }
> f("PROgRamreVERsESgiVeNiNPutsEqUENcE")
,[>,]<[.<]+

Ungolfed

sub oOo ($_) {
    m:g/:i<[a..z]>/;  # Match all letters and put them in $/

    my @digits = (                
        for |$/ -> $c {           # For all $c in $/
            +(91>$c.ord)          # 1 if $c.ord < 91 else 0
        }
    );
    @digits.=rotor(3);            # Split the digits into chunks of 3

    my @chars = (
        for @digits -> @l {
            "><[]-+.,".comb[:2[@l]] # Take the character from "><[]-+.,"
                                    # at an index given by converting 
                                    # @l (a list of 3 binary digits)
                                    # from base 2 to base 10
        }
    );
    @chars.join # Join the list of chars into a string and return
}

— हॉटकी
स्रोत

1

सी ++, 173 167 बाइट्स

पूरा कार्यक्रम, गोल्फ (मानक इनपुट से पढ़ता है):

#include <cstdio>
main(){for(char*a="@[`{>-[.<+],",c,o=0,t=1;(c=getchar())>0;)if(c=c>*a&&c<a[1]?2:c>a[2]&&c<a[3]?1:0){o|=c>1?t:0;t*=2;if(t>4)putchar(a[o+4]),o=0,t=1;}}

कुछ हद तक असंयमी:

#include <cstdio>
main(){
    for(char*a="@[`{>-[.<+],",c,o=0,t=1;(c=getchar())>0;)
        if(c=c>*a&&c<a[1]?2:c>a[2]&&c<a[3]?1:0){
            o|=c>1?t:0;
            t*=2;
            if(t>4)putchar(a[o+4]),o=0,t=1;            
        }
}

ध्यान दें कि @A... Z[ASCII में, और इसी तरह के लिए `a... z}।

— tucuxi
स्रोत

148 बाइट्स

— सीलिंगकैट

1

जाप v2.0a0 `-P`, 27 बाइट्स

r\L ò3 l3 Ëmè\A Íg"><[]-+.,

@ बस्ती के लिए 3 बाइट्स को सहेजा गया

कोशिश करो

— अज्ञान का अवतार
स्रोत

29 बाइट्स

— झबरा

0

पाइके, 31 बाइट्स, नॉन-कंपेटिटिव

Pyke चुनौती से अधिक पुराना है, लेकिन मैंने इसे और अधिक प्रतिस्पर्धी बनाने के लिए कुछ विशेषताएं जोड़ीं - चंक फंक्शन। मैंने @Martin Büttner की तरह ही ट्रिक का इस्तेमाल किया।

#~l{)\`Lm<0+3cFb2"><[]-+.,"@)st

यहाँ कोशिश करो!

— नीला
स्रोत

0

जावास्क्रिप्ट, 148 बाइट्स

function a(s){function b(c){return c.charCodeAt()&32}return (l=(s=s.replace(/[^a-z]/gi)).substr(3))?",.+-][<>"[b(s[0])*4+b(s[1])*2+b(s[2])]+a(l):""}

— Naruyoko
स्रोत

0

टीआई-बेसिक, 311 288 बाइट्स

क्या, कोई TI-BASIC जवाब नहीं? मुझे ठीक करने के लिए समय!

Ans→Str1:" →Str2:" →Str6:"ABCDEFGHIJKLMNOPQRSTUVWXYZ→Str4:For(S,1,length(Str1:sub(Str1,S,1:If inString(Str4+"abcdefghijklmnopqrstuvwxyz",Ans:Str2+Ans→Str2:End:sub(Str2,2,length(Str2)-1→Str2:For(B,1,.1+3⁻¹length(Str2:sub(Str2,3B-2,3→Str3:1+sum({4,2,1}seq(0≠inString(Str4,sub(Str3,X,1)),X,1,3→L₁(B:End:For(C,1,.1+dim(L₁:Str6+sub("><[]-+.,",L₁(C),1→Str6:End:sub(Str6,2,length(Str6)-1→Str6

इनपुट में ओओ कोड है Ans।
आउटपुट अनुवादित बीएफ कोड है।

उदाहरण:

"AbcDef
AbcDef
prgmCDGF18
--
"PROgRam reVERsES giVeN iNPut sEqUENcE
PROgRam reVERsES giVeN iNPut sEqUENcE
prgmCDGF18
.[>,]<[.<]+
"AbcDe
AbcDe
prgmCDGF18
-

अन-गोल्फ:
(नई टिप्पणियाँ और टिप्पणियाँ जोड़ी गईं)

Ans→Str1                                                   ;store the input in "Str1"
" →Str2                                                    ;set "Str2" and "Str6" to a
" →Str6                                                    ; space character
                                                           ; (needed b/c TI-BASIC doesn't
                                                           ;  like concatenating empty
                                                           ;  strings)

"ABCDEFGHIJKLMNOPQRSTUVWXYZ→Str4                           ;store the uppercase alphabet
                                                           ; in "Str4"
For(S,1,length(Str1                                        ;loop over the input string
sub(Str1,S,1                                               ;get the current character
If inString(Str4+"abcdefghijklmnopqrstuvwxyz",Ans          ;if the character is in either
                                                           ; the uppercase or lowercase
                                                           ; alphabet
Str2+Ans→Str2                                              ;add it to "Str2", the code
                                                           ; string
End
sub(Str2,2,length(Str2)-1→Str2                             ;remove the space added earlier
For(B,1,.1+3⁻¹length(Str2                                  ;loop over each 3-char substring
                                                           ; and skip any extra chars
                                                           ; (.1 is added to force one
                                                           ;  loop)
sub(Str2,3B-2,3→Str3                                       ;store said substring in "Ans"
1+sum({4,2,1}seq(0≠inString(Str4,sub(Str3,X,1)),X,1,3→L₁(B ;convert to the respective
                                                           ; index in "><[]-+.,"
                                                           ; (1-indexed)
End
For(C,1,.1+dim(L₁                                          ;loop over each index
                                                           ; (.1 is added to force one
                                                           ;  loop)
Str6+sub("><[]-+.,",L₁(C),1→Str6                           ;add the char to the translation
                                                           ; string
End
sub(Str6,2,length(Str6)-1→Str6                             ;remove the added space and
                                                           ; store the result in "Str6"
                                                           ; and "Ans"
                                                           ;implicit print of "Ans"

टिप्पणियाँ:

TI-BASIC एक टोकन भाषा है। कैरेक्टर काउंट बाइट काउंट नहीं के बराबर होता है ।

— ताउ
स्रोत

OOo CODE का अनुवाद करें

ऊ, 1569 1515 बाइट्स

CJam, 36 35 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 94 93 91 85 84 83 बाइट्स

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

05AB1E , 35 32 बाइट्स

रेटिना , 79 75 71 70 बाइट्स

व्याख्या

MATL , 38 32 बाइट्स

जाप, 37 36 बाइट्स

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

जावास्क्रिप्ट (ईएस 6), 111 95 बाइट्स

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

पायथ, 40 बाइट्स

व्याख्या

जोल्फ, 31 34 बाइट्स

हून , 212 बाइट्स

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

मतलाब, 98 बाइट्स

पर्ल, 76 73 72 + 1 = 73 बाइट्स

जूलिया, 107 बाइट्स

लुआ, 120 बाइट्स

Ungolf और स्पष्टीकरण

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

मैथेमेटिका, 192 बाइट्स

रूबी 117 114 113 111 86 79 बाइट्स

पर्ल 6, 81 बाइट्स

सी ++, 173 167 बाइट्स

जाप v2.0a0 -P, 27 बाइट्स

पाइके, 31 बाइट्स, नॉन-कंपेटिटिव

जावास्क्रिप्ट, 148 बाइट्स

टीआई-बेसिक, 311 288 बाइट्स

जाप v2.0a0 `-P`, 27 बाइट्स