व्याख्या /// (उच्चारण 'स्लैश')

Question

क्योंकि हम गूढ़ भाषा गोल्फ के लिए पर्याप्त नहीं मिल सकता है, हम कर सकते हैं?

/// - स्पष्ट स्लैश- पेरल s///प्रसिद्धि के रेगेक्स-रिप्लेसमेंट फ़ंक्शन के आधार पर एक मजेदार छोटी भाषा । इसमें केवल दो विशेष वर्ण हैं, स्लैश /और बैकस्लैश \। आप इस पर एक पूरा लेख esolangs विकी पर पा सकते हैं , लेकिन मैं नीचे दिए गए भाषा के विवरण के साथ-साथ कुछ उदाहरणों को पुन: पेश करूंगा।

संक्षेप में, यह /pattern/repl/restकार्यक्रम में पहचान करके और प्रतिस्थापन को यथासंभव अधिक से अधिक बनाने का काम करता है। कोई भी वर्ण विशेष को छोड़कर नहीं हैं /और \: /कार्यक्रम में पैटर्न और प्रतिस्थापन का सीमांकन करते हैं, जबकि \आप अपने कोड में शाब्दिक /या \वर्ण सम्मिलित करने की अनुमति देते हैं । विशेष रूप से, ये नियमित अभिव्यक्ति नहीं हैं, बस सादे स्ट्रिंग प्रतिस्थापन हैं।

आपकी चुनौती /// भाषा के लिए दुभाषिया का उत्पादन करना है, या तो एसटीडीआईएन पढ़ने वाले एक कार्यक्रम या स्ट्रिंग तर्क लेने वाले फ़ंक्शन के रूप में संभव के रूप में कुछ वर्णों में।

आप स्वयं /// को छोड़कर किसी भी भाषा का उपयोग कर सकते हैं। आप व्याख्या /// की व्याख्या करने वाले किसी भी पुस्तकालय का उपयोग नहीं कर सकते हैं; हालाँकि, आप regexes, regex पुस्तकालयों, या स्ट्रिंग-मिलान पुस्तकालयों का उपयोग कर सकते हैं।

---

क्रियान्वयन

चार राज्य हैं, प्रिंट , पैटर्न , प्रतिस्थापन और प्रतिस्थापन । प्रतिस्थापन को छोड़कर हर राज्य में :

• यदि कार्यक्रम खाली है, तो निष्पादन रुक जाता है।
• एल्स, यदि पहला चरित्र है \, तो अगले चरित्र के साथ कुछ करें (यदि वर्तमान में) और प्रोग्राम से दोनों को हटा दें।
• एल्स, यदि पहला चरित्र है /, तो इसे हटा दें, और अगले राज्य में बदल दें।
• एल्स, पहले किरदार के साथ कुछ करें और इसे प्रोग्राम से हटा दें।
• दोहराएँ।

के माध्यम से चक्र कहा गया प्रिंट , पैटर्न , प्रतिस्थापन , और प्रतिस्थापन के क्रम में।

• में प्रिंट मोड, साधन उत्पादन चरित्र 'कुछ करना'।
• में पैटर्न मोड, साधन वर्तमान पैटर्न के चरित्र जोड़ें 'कुछ करना'।
• में प्रतिस्थापन मोड, साधन वर्तमान रिप्लेसमेंट के लिए चरित्र जोड़ें 'कुछ करना'।

में प्रतिस्थापन मोड, आप नियमों का एक अलग सेट का पालन करें। कार्यक्रम में वर्तमान प्रतिस्थापन के साथ वर्तमान पैटर्न की पहली घटना को बार-बार स्थानापन्न करें, जब तक कि कोई और प्रतिस्थापन संभव न हो। उस बिंदु पर, पैटर्न और प्रतिस्थापन को साफ़ करें और प्रिंट मोड पर लौटें ।

कार्यक्रम में /foo/foobar/foo foo foo, निम्नलिखित होता है:

/foo/foobar/foo foo foo
foo foo foo
foobar foo foo
foobarbar foo foo
foobarbarbar foo foo
...

यह हमेशा के लिए बंद हो जाता है और प्रतिस्थापन मोड से बाहर नहीं निकलता है। इसी तरह, यदि पैटर्न खाली है, तो कार्यक्रम की शुरुआत में खाली स्ट्रिंग की पहली घटना — हमेशा मेल खाती है, इसलिए प्रतिस्थापन मोड हमेशा के लिए बंद हो जाता है, कभी रुक नहीं पाता।

---

उदाहरण

no

आउटपुट: no।

/ world! world!/Hello,/ world! world! world!

आउटपुट: Hello, world!।

/foo/Hello, world!//B\/\\R/foo/B/\R

आउटपुट: Hello, world!।

a/ab/bbaa/abb

आउटपुट: a। कार्यक्रम रुकता नहीं है।

//

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

///

आउटपुट: कोई नहीं। कार्यक्रम रुकता नहीं है।

/\\/good/\/

आउटपुट: good।

विकी पर एक क्वीन भी है जिसे आप आज़मा सकते हैं।

Comments

/-/World//--/Hello//--W/--, w/---!क्या प्यार करने लायक नहीं? (अंत से डैश को हटाने का प्रयास करें)

— Seequ

@ लोजोवो \ चरित्र किसी भी ऐसे चरित्र से बच जाता है /, जो उसका अनुसरण करता है, जिसमें बाद में सामान्य रूप से इस्तेमाल किया जा सकता है। हालांकि यह ज्यादा नहीं दिखता है, लेकिन यह /// ट्यूरिंग-पूर्ण बनाता है ।

— एल्गोरिद्मशार्क

मुझे लगता है कि यह भाषा की बेहतर व्याख्या है, जो एसोलंग्स विकी लेख की तुलना में है। मेरे ///आईडीई में इस जानकारी का उपयोग करेंगे जो मैं बना रहा हूं!

— clabe45

Answer 1

एपीएल (133)

{T←''∘{(0=≢⍵)∨'/'=⊃⍵:(⊂⍺),⊂⍵⋄(⍺,N⌷⍵)∇⍵↓⍨N←1+'\'=⊃⍵}⋄⍞N←T⍵⋄p N←T 1↓N⋄r N←T 1↓N⋄''≡N:→⋄∇{⍵≡p:∇r⋄∨/Z←p⍷⍵:∇(r,⍵↓⍨N+≢p),⍨⍵↑⍨N←1-⍨Z⍳1⋄⍵}1↓N}

यह एक फ़ंक्शन है जो ///कोड को उसके सही तर्क के रूप में लेता है।

असंबद्ध, स्पष्टीकरण के साथ:

slashes←{
   ⍝ a function to split the input string into 'current' and 'next' parts,
   ⍝ and unescape the 'current' bit
   split←''∘{
       ⍝ if the string is empty, or '/' is reached,
       ⍝ return both strings (⍺=accumulator ⍵=unprocessed)
       (0=≢⍵)∨'/'=⊃⍵:(⊂⍺),⊂⍵
       ⍝ otherwise, add current character to accumulator,
       ⍝ skipping over '\'s. (so if '\/' is reached, it skips '\',
       ⍝ adds '/' and then processes the character *after* that.)
       idx←1+'\'=⊃⍵
       (⍺,idx⌷⍵)∇idx↓⍵
   }

   ⍞   next ← split ⍵      ⍝ output stage
   pat next ← split 1↓next ⍝ pattern stage, and eat the '/'
   rpl next ← split 1↓next ⍝ replacement stage, and eat the '/'

   ⍝ if there are no characters left, halt.
   ''≡next:⍬

   ⍝ otherwise, replace and continue.
   ∇{  ⍝ if the input string equals the pattern, return the replacement and loop
       ⍵≡pat:∇rpl

       ⍝ otherwise, find occurences, if there are, replace the first and loop
       ∨/occ←pat⍷⍵:∇(rpl, (idx+≢pat)↓⍵),⍨ (idx←(occ⍳1)-1)↑⍵

       ⍝ if no occurences, return string
       ⍵

   }1↓next
}

Comments

"अगर कोई पात्र नहीं बचा है, तो रोकें।" क्या यह सही तरीके से ///और //foo/(यानी हमेशा के लिए काम करता है)?

— एल्गोरिद्मशर्क

@algorithmshark: हाँ, उस स्थिति में /अभी भी उस बिंदु पर छोड़ दिया जाएगा।

— मारिनस

Answer 2

जे - 181 190 170 चार

यह एक बुरा सपना था। मैंने इसे दो बार स्क्रैच से रीक्रिएट किया, क्योंकि यह सिर्फ मुझे गुस्सा दिलाता रहा। यह एक एकल स्ट्रिंग तर्क लेने वाला कार्य है, जो STDOUT को आउटपुट करता है।

(0&$`((2{.{:@>&.>)((j{.]),-i@=`p@.~:~/@[,]}.~#@p+j=.0{p I.@E.])i 5;@}.&,'/';"0;&.>)@.(2<#)@}.[4:1!:2~{:@>@p=.>@{.@[)@((0;(0,:~1 0,.2);'\';&<1 0)<;._1@;:'/'&,)i=. ::](^:_)

समझाने के लिए, मैं इसे उपमेय में तोड़ दूंगा।

i =. ::](^:_))
parse =: ((0;(0,:~1 0,.2);'\';&<1 0)<;._1@;:'/'&,)
print =: 4:1!:2~{:@>@p=.>@{.@[
eval  =: 0&$`((2{.{:@>&.>)sub 5;@}.&,'/';"0;&.>)@.(2<#)@}.
sub   =: ((j{.]),-i@=`p@.~:~/@[,]}.~#@p+j=.0{p I.@E.])i

interp =: (eval [ print) @ parse i

• i(के लिए कम पुनरावृति ) एक क्रिया विशेषण है। यह बाईं ओर एक क्रिया तर्क देता है और एक क्रिया देता है (f)i, जो जब एक तर्क पर लागू होता है, fतब तक तर्क पर बार-बार लागू होता है जब तक कि दो चीजों में से एक होता है: यह एक निश्चित बिंदु ( y = f y) पाता है , या यह एक त्रुटि फेंकता है। निश्चित-बिंदु व्यवहार अंतर्निहित है ^:_, और ::]त्रुटि से निपटने के लिए करता है।

• parseआधे-परसेंट फॉर्म को कॉल करने पर इनपुट को टोकेनेट करता है , और फिर इसे अनसैप्ड '/' पर काट देता है। यह बैकस्लैश से बचने के लिए अपने पात्रों को बांधता है, लेकिन बैकस्लैश से छुटकारा नहीं मिलता है - इसलिए हम या तो इसे वापस कर सकते हैं या इसे खत्म कर सकते हैं जिसके आधार पर हम चाहते हैं।

  दिलचस्प काम के थोक में होता है ;:। यह एक अनुक्रमिक-मशीन दुभाषिया आदिम है, (0;(0,:~1 0,.2);'\';&<1 0)बाईं तरफ मशीन ( ) का विवरण और दाईं ओर पार्स करने के लिए कुछ ले रहा है। यह टोकन करता है। मैं ध्यान दूंगा कि यह विशिष्ट मशीन वास्तव में पहले चरित्र को अनिर्दिष्ट मानती है, भले ही यह एक \और बांधना चाहिए। मैं कुछ कारणों से ऐसा करता हूं: (1) राज्य तालिका सरल है, इसलिए इसे आगे बढ़ाया जा सकता है; (2) हम आसानी से समस्या को चकमा देने के लिए सामने से एक डमी चरित्र जोड़ सकते हैं; और (3) कि डमी-चरित्र बिना किसी अतिरिक्त लागत के आधा-पार हो जाता है, इसलिए मैं इसे काटने के चरण के लिए सेट कर सकता हूं, अगले।

  हम बिना <;._1पढ़े /(जो कि मैं पहले चार बनने के लिए चुनता हूं) पर एक टोकन परिणाम को काटने के लिए भी उपयोग करता हूं। यह आउटपुट, पैटर्न और out/patt/repl/restसभी को एक चरण में बदलने के लिए आसान है , लेकिन दुर्भाग्यवश बाकी प्रोग्राम को भी काट देता है, जहां हमें /अछूते रहने की जरूरत होती है। मैं इन पीठों को अंदर से अलग करता हूं eval, क्योंकि <;._1उन्हें अकेला छोड़ देने से लागत बहुत अधिक हो जाती है।

• कांटा अपने दुष्प्रभावों के लिए परिणाम पर (eval [ print)निष्पादित करता है , और फिर चलाता है । एक साधारण क्रिया है जो पहले बॉक्स को खोलती है (जिसे हम जानते हैं कि यह आउटपुट है), इसे पार्स करना समाप्त करता है, और इसे STDOUT को भेजता है। हालांकि, हम एक उपयोगिता क्रिया को परिभाषित करने का मौका भी लेते हैं ।printparseevalprintp

  pके रूप में परिभाषित किया गया है >@{.@[, इसलिए यह अपना बायाँ arg लेता है (केवल एक arg दिए जाने पर पहचान की तरह कार्य करता है), उस का पहला आइटम लेता है (पहचान जब एक स्केलर दिया जाता है), और इसे अनबॉक्स करता है (पहचान यदि पहले से ही अनबॉक्स है)। यह बहुत काम आएगा sub।

• evalशेष संसाधित कार्यक्रम का मूल्यांकन करता है। यदि हमारे पास एक पूर्ण पैटर्न या पूर्ण प्रतिस्थापन नहीं है, तो evalइसे बाहर फेंक देता है और बस एक खाली सूची देता है, जो अगले पुनरावृत्ति पर त्रुटि ;:( parseबाहर) बनाकर मूल्यांकन को समाप्त करता है । एल्स, evalपूरी तरह से पैटर्न और प्रतिस्थापन को पार्स करता है, शेष स्रोत को सही करता है, और फिर दोनों को पास करता है sub। विस्फोट से:

                                                @}.  NB. throw out printed part
                                         @.(2<#)     NB. if we have a pattern and repl:
        2{.                                          NB.  take the first two cuts:
               &.>                                   NB.   in each cut:
           {:@>                                      NB.    drop escaping \ from chars
       (          )                                  NB.  (these are pattern and repl)
                                     &.>             NB.  in each cut:
                                    ;                NB.   revert to source form
                              '/';"0                 NB.  attach a / to each cut
                            &,                       NB.  linearize (/ before each cut)
                       5  }.                         NB.  drop '/pattern/repl/'
                        ;@                           NB.  splice together
      (            sub                  )            NB.  feed these into sub
     `                                               NB. else:
  0&$                                                NB.  truncate to an empty list
  

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

  हालांकि मुसीबत के दो धब्बे हैं। पहला यह है कि J verbs में अधिकतम दो तर्क हो सकते हैं, इसलिए हमारे पास पैटर्न और प्रतिस्थापन की तरह, किसी भी बंडल को एक्सेस करने का आसान तरीका नहीं है। pहमारे द्वारा परिभाषित उपयोगिता के चतुर उपयोग के माध्यम से , यह समस्या का बड़ा हिस्सा नहीं है। वास्तव में, हम pइसकी >@{.@[परिभाषा के कारण , केवल एक वर्ण में पैटर्न का उपयोग कर सकते हैं : वाम खंड के पहले आइटम का अनबॉक्स। प्रतिस्थापन प्राप्त करना मुश्किल है, लेकिन सबसे छोटा तरीका होगा p&|., मैन्युअल रूप से इसे बाहर निकालने की तुलना में 2 चार्ट कम।

  दूसरी समस्या यह है कि iहमेशा के लिए लूपिंग के बजाय निश्चित बिंदुओं पर बाहर निकलता है, और यदि पैटर्न और प्रतिस्थापन समान हैं और आप एक प्रतिस्थापन बनाते हैं, जो जे को एक निश्चित बिंदु की तरह दिखता है। हम इसे 1 ओवर की उपेक्षा के अनंत लूप में प्रवेश करके संभालते हैं और यदि हम पता लगाते हैं कि वे समान हैं: यह वह -i@=`p@.~:~/हिस्सा है, जिसकी जगह है p&|.।

                                      p    E.]    NB. string search, patt in src
                                        I.@       NB. indices of matches
                                    0{            NB. take the first (error if none)
                                 j=.              NB. assign to j for later use
                             #@p+                 NB. add length of pattern
                         ]}.~                     NB. drop that many chars from src
                     /@[                          NB. between patt and repl:
                    ~                             NB.  patt as right arg, repl as left
                @.~:                              NB.  if equal:
          -i@=                                    NB.   loop forever
              `p                                  NB.  else: return repl
   (j{.])                                         NB. first j chars of src
         ,              ,                         NB. append all together
  (                                           )i  NB. iterate
  

• iजब तक subत्रुटियों के बाहर कुछ नहीं होता, तब तक यह चक्र दोहराता है। जहां तक ​​मुझे पता है, यह केवल तब हो सकता है जब हम वर्णों से बाहर होते हैं, जब हम पैटर्न-और-रिप्लेसमेंट के अधूरे सेट को फेंक देते हैं।

इस गोल्फ के बारे में मजेदार तथ्य:

• एक बार के लिए, ;:स्ट्रिंग के माध्यम से मैन्युअल रूप से पुनरावृत्ति की तुलना में इसका उपयोग करना कम है।
• 0{subअनंत लूप में जाने से पहले गलती करने का मौका होना चाहिए , इसलिए यह ठीक काम करना चाहिए अगर पैटर्न प्रतिस्थापन से मेल खाता है, लेकिन शेष स्रोत में कभी नहीं दिखाता है। हालाँकि, यह अनिर्दिष्ट व्यवहार नहीं हो सकता है, क्योंकि मैं डॉक्स में किसी भी तरह से उद्धरण नहीं पा सकता हूं। उफ्फ।
• कीबोर्ड इंटरप्ट को रनिंग फ़ंक्शंस के अंदर सहज त्रुटियों के रूप में संसाधित किया जाता है। हालांकि, की प्रकृति के कारण i, वे त्रुटियां भी फंस जाती हैं। आपके द्वारा Ctrl + C हिट करने पर निर्भर करता है, आप निम्न कर सकते हैं:
  • नकारात्मक-हमेशा के लिए लूप से बाहर निकलें, subएक स्ट्रिंग को एक संख्या को समेटने की कोशिश करके लूप से त्रुटि , और फिर इंटरप्रेटिंग /// पर जाएं जैसे कि आपने एक स्ट्रिंग को एक अनंत बार खुद के साथ प्रतिस्थापित किया।
  • subआधे रास्ते को छोड़ दें और आधे-अधूरे /// अभिव्यक्ति की व्याख्या करने पर जाएं।
  • दुभाषिया से बाहर तोड़ो और एक अनपेक्षित /// प्रोग्राम को REPL (STDOUT नहीं, हालांकि) लौटाएं।

उदाहरण का उपयोग:

   f=:(0&$`((2{.{:@>&.>)((j{.]),-i@=`p@.~:~/@[,]}.~#@p+j=.0{p I.@E.])i 5;@}.&,'/';"0;&.>)@.(2<#)@}.[4:1!:2~{:@>@p=.>@{.@[)@((0;(0,:~1 0,.2);'\';&<1 0)<;._1@;:'/'&,)i=. ::](^:_)
   f 'no'
no
   f '/ world! world!/Hello,/ world! world! world!'
Hello, world!
   f '/foo/Hello, world!//B\/\\R/foo/B/\R'
Hello, world!
   f '//'  NB. empty string

   f '/\\/good/\/'
good

Comments

वाह। मैं इस मर्दवादी को बुलाऊंगा। +1

— सीके

जब मैं इसे चलाता हूं, तो मुझे प्रत्येक परीक्षण मामले से खाली स्ट्रिंग मिलती है। मैं jqt64 का उपयोग कर रहा हूं, आप इसे चलाने के लिए क्या उपयोग कर रहे हैं?

— bcsb1001 16

@ bcsb1001 मैं सीधे (64-बिट) jconsole बाइनरी का उपयोग कर रहा हूं। अब jqt की जाँच, मुझे वास्तव में /\\/good/\/परीक्षण के मामले को छोड़कर इच्छित परिणाम मिल रहे हैं ; डिबगिंग मुझे बताता है कि मुद्दा मेरा उपयोग है 1!:2&4, क्योंकि jqt में स्टडिन / आउट नहीं है। जांच करेंगे। क्या हैं आपके 9!:12''और 9!:14''?

— एल्गोरिथमशार्क

@ अल्गोरिद्मशर्क माय 9!:12''6 है, और 9!:14''j701 / 2011-01-10 / 11: 25 है।

— bcsb1001

Answer 3

पर्ल - 190

$|=1;$/=undef;$_=<>;while($_){($d,$_)=/(.)(.*)/;eval(!$e&&({'/','$a++','\\','$e=1'}->{$d})||('print$d','$b.=$d','$c.=$d')[$a].';$e=0');if($a==3){while($b?s/\Q$b/$c/:s/^/$c/){}$a=0;$b=$c=''}}

///EOF तक स्टड से कार्यक्रम को पढ़ता है ।

Comments

- एक m/^(.*?)(?<!\\)\/(.*?)(?<!\\)\/(.*?)(?<!\\)\/(.*)$/sमैच के आउटपुट के साथ एक दृष्टिकोण - आउटपुट, पैटर्न, और एक ही बार में बदलना - एक छोटे से गोल्फ के लिए बनाना होगा? मैं खुद किसी पर्ल को नहीं जानता।

— एल्गोरिथमशार्क

मेरा मानना है कि इस के साथ विफल रहता है/a/\0/a

— Asone Tuhid

Answer 4

पिप , 100 102 बाइट्स

मैंने कभी भी पिप को ट्यूरिंग-पूर्ण (हालांकि यह बहुत स्पष्ट रूप से ऐसा है) साबित नहीं किया था, और बीएफ के सामान्य मार्ग पर जाने के बजाय मैंने सोचा /// दिलचस्प होगा। एक बार जब मेरे पास समाधान था, मुझे लगा कि मैं इसे गोल्फ करूंगा और इसे यहां पोस्ट करूंगा।

कोड के 101 बाइट्स, -rध्वज के लिए +1 :

i:gJnf:{a:xW#i&'/NE YPOia.:yQ'\?POiya}W#iI'\Q YPOiOPOiEIyQ'/{p:VfY0s:VfIyQ'/WpNi&YviR:Xp{++y?ps}}E Oy

यहाँ प्रचुर टिप्पणियों के साथ मेरा ungolfed संस्करण है:

; Use the -r flag to read the /// program from stdin
; Stdin is read into g as a list of lines; join them on newline and assign to c for code
c : gJn

; Loop while c is nonempty
W #c {
 ; Pop the first character of c and yank into y
 Y POc
 ; If y equals "\"
 I yQ'\
  ; Pop c again and output
  O POc
 ; Else if y equals "/"
 EI yQ'/ {
  ; Build up pattern p from empty string
  p : ""
  ; Pop c, yank into y, loop while that is not equal to "/" and c is nonempty
  W #c & '/ NE Y POc {
   ; If y equals "\"
   I yQ'\
    ; Pop c again and add that character to p
    p .: POc
   ; Else, add y to p
   E p .: y
  }

  ; Yank 0 so we can reliably tell whether the /// construct was completed or not
  Y0
  ; Build up substitution s from empty string
  s : ""
  ; Pop c, yank into y, loop while that is not equal to "/" and c is nonempty
  W #c & '/ NE Y POc {
   ; If y equals "\"
   I yQ'\
    ; Pop c again and add that character to s
    s .: POc
   ; Else, add y to s
   E s .: y
  }

  ; If the last value yanked was "/", then we have a complete substitution
  ; If not, the code must have run out; skip this branch, and then the outer loop
  ; will terminate
  I yQ'/ {
   ; While pattern is found in code:
   W pNc {
    ; Set flag so only one replacement gets done
    i : 0
    ; Convert p to a regex; replace it using a callback function: if ++i is 1,
    ; replace with s; otherwise, leave unchanged
    c R: Xp {++i=1 ? s p}
   }
  }
 }
 ; Else, output y
 E Oy
}

इसे ऑनलाइन आज़माएं! (ध्यान दें कि कार्यक्रम के समाप्त न होने पर TIO कोई आउटपुट नहीं देता है, और इसकी एक समय सीमा भी है। बड़े उदाहरणों और अनंत छोरों के लिए, कमांड लाइन से पिप चलाने की सिफारिश की जाती है।)

Comments

मुझे लगता है कि यह होना चाहिए pip + -r, 101 बाइट्स

— Asone Tuhid

Answer 5

C ++: विजुअल C ++ 2013 = 423, g ++ 4.9.0 = 442

यह कभी नहीं जीतेगा, लेकिन जब से मैंने फैसला किया है कि मेरी सभी भविष्य की सॉफ्टवेयर परियोजनाएं इस भयानक भाषा में लिखी जाएंगी, मुझे इसके लिए एक इंट्रिप्टर की आवश्यकता थी और मुझे लगा कि मैं जो भी बना सकता हूं उसे साझा कर सकता हूं ...

स्कोर में अंतर यह है कि Visual C ++ को पहले शामिल करने की आवश्यकता नहीं है, लेकिन g ++ करता है। स्कोर मानता है कि लाइन अंत 1 के रूप में गिना जाता है।

#include<string.h>
#include<string>
#define M(x)memset(x,0,99);
#define P o[i])
#define N(x)P;else if(n<x)(P==92?
#define O (o[++i]):(P==47?n++:
#define S std::string
int main(int n,char**m){S o=m[1];char p[99],*q=p,r[99],*s=r;M(p)M(r)for(int i=0,t;i<=o.size();++i){if(!N(3)putchar O putchar(N(4)*q++=O(*q++=N(5)*s++=O(*s++=P;if(n>4){for(;;){if((t=o.find(p,i+1))==S::npos)break;o=o.substr(0,t)+r+o.substr(t+strlen(p));}M(p)M(r)n=2;q=p;s=r;}}}

Comments

आप को फिर से लिखने कर सकते हैं if(!o[i]);के रूप में if(Pवर्ण को बचाने के लिए, या मैं गलत समझ रहा हूँ #define कैसे काम करता है?

— एल्गोरिद्मशार्क

@ अल्गोरिद्मशर्क मुझे कैसे याद किया? अगर (! P एकदम सही है। मैं इसे बदल दूंगा।

— जेरी जेरेमिया

प्रत्येक उदाहरण Pमें mainइसके बाद एक स्थान होता है, इसलिए आप उन स्थानों को अर्धविराम से बदलकर और इसे हटाकर एक चरित्र बचा सकते हैं #define। तब, यदि आप उपयोग कर सकते हैं #defineअन्य लोगों के अंदर है, आप कुछ और लिख कर बचा सकता है N(x)के रूप में (92==Pके बजाय o[i]==92और Oवैसे ही।

— एल्गोरिथमशार्क

@ अल्गोरिद्मशर्क आप स्पष्ट रूप से इस पर बहुत बेहतर हैं I मदद के लिए धन्यवाद।

— जेरी यिर्मयाह

मुझे पता है कि यह लगभग चार साल पुराना है, लेकिन के N(x)रूप में फिर से लिखना P;else if(n<x)(P==92?और कॉल को बदलना Nकुछ बाइट्स को बचा सकता है।

— ज़ाचारि 28:18

Answer 6

पायथन 2 (236), पायथन 3 (198?)

from __future__ import print_function
def d(i):
 t=0;p=['']*3+[1]
 while i:
  if'/'==i[0]:t+=1
  else:
   if'\\'==i[0]:i=i[1:]
   p[t]+=i[0]
  i=i[1:]
  print(end=p[0]);p[0]=''
  if t>2:
   while p[1]in i:i=i.replace(*p[1:])
   d(i);i=0

के रूप में पुकारा गया d(r"""/foo/Hello, world!//B\/\\R/foo/B/\R""")। ट्रिपल कोट्स की जरूरत तभी पड़ती है जब ///प्रोग्राम में नई सुर्खियाँ हों: अन्यथा सरल उद्धरण ठीक हैं।

संपादित करें: यह दुभाषिया अब अपेक्षा के अनुसार सामान प्रिंट करता है (पहले यह केवल बहुत अंत में छपा था, cf. टिप्पणियों)। पायथन 3 के लिए, पहली पंक्ति को हटा दें (लेकिन मेरे पास मेरी प्राचीन स्थापना पर पायथन 3 नहीं है, इसलिए यह सुनिश्चित नहीं किया जा सकता है कि कोई अन्य परिवर्तन नहीं है)।

Comments

दुभाषिया समस्याग्रस्त होने तक कुछ भी नहीं छाप रहा है। /// में एक अनंत लूप लिखना संभव है, इसलिए आपका दुभाषिया नॉन-टर्मिनेटिंग-लेकिन-स्टिल-प्रिंटिंग-कुछ प्रोग्राम पर विफल रहता है।

— गर्वित हैकेलर

@proudhaskeller फिक्स्ड।

— ब्रूनो ले फ्लो

वास्तव में, यह तय नहीं है, यह कुछ भी प्रिंट नहीं करता है /a/ab/bbaa/abb।

— बीटा क्षय

@ BetaDecay /a/ab/bbaa/abbकिसी भी चीज को प्रिंट किए बिना एक अंतहीन लूप में फंस जाएगा, क्योंकि पहला प्रतिस्थापन a=> है ab। सही a/ab/bbaa/abbविज्ञापन के रूप में काम करता है।

— एल्गोरिथमशार्क

@ बीटाडेके: एल्गोरिथमशार्क द्वारा सुझाए गए बदलाव के अलावा, -uआउटपुट बफर को असंबद्ध करने के लिए मजबूर करने के लिए आपको कमांड लाइन विकल्प को शामिल करना पड़ सकता है।

— ब्रूनो ले फ्लोच

Answer 7

कोबरा - 226

sig Z as String
def f(l='')
    m=Z(do=[l[:1],l=l[1:]][0])
    n as Z=do
        if'/'<>(a=m())>'',return if(a=='\\',m(),a)+n()
        else,return''
    print n()stop
    p,s=n(),n()
    if''<l
        while p in l,l=l[:l.indexOf(p)+1]+s+l[p.length:]
        .f(l)

Answer 8

रूबी , 119 110 बाइट्स

अपवाद के साथ समाप्ति

r=->s,o=$>{s[k=s[0]]='';k==?/?o==$>?s.gsub!([r[s,''],e=r[s,'']][0]){e}:t=o:o<<(k==?\\?s[0]+s[0]='':k);t||redo}

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

साफ-सुथरा कार्यकाल (116 बाइट्स)

r=->s,o=$>{s[k=s[0]||exit]='';k==?/?o==$>?s.gsub!([r[s,''],e=r[s,'']][0]){e}:t=o:o<<(k==?\\?s[0]+s[0]='':k);t||redo}

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

Answer 9

अजगर 2/3 (211 बाइट्स)

निम्नलिखित कोड, ब्रूनो ले फ्लोच के उत्तर के आधार पर , पायथन 2 और पायथन 3 संगत है।

इसके अलावा, पुनरावर्ती होने के बजाय पुनरावृत्ति होने के कारण यह पायथन की अधिकतम पुनरावृत्ति की गहराई से टकराने का जोखिम नहीं है।

def S(c):
 while c:
  B=["","",1]
  for m in 0,1,2:
   while c:
    if"/"==c[0]:c=c[1:];break
    if"\\"==c[0]:c=c[1:]
    if m:B[m-1]+=c[0]
    else:yield c[0]
    c=c[1:]
  while c and B[0]in c:c=c.replace(*B)

Comments

नमस्कार और पीपीसीजी में आपका स्वागत है। आप गोल्फ कर सकते हैं in(0,1,2)करने के लिए in 0,1,2और [""]*2+[1]करने के लिए ["","",1]है, जिसके परिणामस्वरूप 211 बाइट्स ।

— जोनाथन फ्रेच

मैंने संदर्भित उत्तर से जोड़ा है और "बाइट्स" शब्द जोड़ा है। यदि आप मेरे संपादन से असहमत हैं, तो बेझिझक वापस आ जाएं।

— जोनाथन फ्रेच

धन्यवाद जोनाथन, आपके सुझावों का बहुत स्वागत है!

— कार्लोस लूना

Answer 10

बाकोन , 391 387 395 बाइट्स

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

BASIC के साथ कोडगोल्फ प्रतियोगिता में भाग लेना आसान नहीं है, क्योंकि BASIC लंबे शब्दों का इस्तेमाल बयानों के रूप में करता है। आमतौर पर BASIC में पाया जाने वाला एकमात्र संक्षिप्त नाम है '?' संकेत, जिसका अर्थ है प्रिंट।

इसलिए नीचे का कार्यक्रम कभी नहीं जीत सकता है, लेकिन कम से कम यह कोडगॉल्फ पेज पर और एसोलंग्स विकी पर सभी प्रदर्शन कोड के साथ काम करता है । जिसमें "बीयर की 99 बोतलें" के सभी संस्करण शामिल हैं।

p$=""
r$=""
INPUT i$
WHILE LEN(i$)
t$=LEFT$(i$,1)
i$=MID$(i$,2)
IF NOT(e) THEN
IF t$="\\" THEN
e=1
CONTINUE
ELIF t$="/" THEN
o=IIF(o<2,o+1,0)
IF o>0 THEN CONTINUE
FI
FI
IF o=1 THEN
p$=p$&t$
ELIF o=2 THEN
r$=r$&t$
ELIF o=0 THEN
IF LEN(p$) THEN i$=REPLACE$(i$,p$,r$)
IF NOT(INSTR(t$&i$,"/")) THEN
?t$;
BREAK
ELSE
?LEFT$(i$,INSTR(i$,"/")-1);
i$=MID$(i$,INSTR(i$,"/"))
FI
p$=""
r$=""
FI
e=0
WEND
?i$

Comments

उपयोगकर्ता से इनपुट प्राप्त करने के लिए INPUT स्टेटमेंट जोड़ा गया।

— पीटर