ब्रेनफक को कम करें

Question

आपकी चुनौती इन नियमों के अनुसार ब्रेनफक कोड को छोटा करना है:

• जो कुछ भी नहीं है उसे हटा दें +-><[].,।
• लगातार +या -वर्णों के किसी भी समूह के लिए , यदि +s और -s की मात्रा समान है, तो उन्हें हटा दें।
• ऊपर जैसा है वैसा ही करें, लेकिन साथ >और <।
• +-><यदि वे कुछ नहीं करते हैं तो पात्रों के दृश्यों को हटा दें । उदाहरण के लिए, आपको हटा देना चाहिए +>-<->+<। (यह लागू करने के लिए सबसे कठिन और सबसे कठिन हो सकता है।) सुनिश्चित करें कि आपको कोई झूठी सकारात्मकता नहीं मिलती है, जैसे +>-<+>-<, जिसे हटाया नहीं जाना चाहिए।

---

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

इनपुट

++++++[->++++++<]>.   prints a $
[-]<                  resets tape
>,[>,]<[.<]           reverses NUL terminated input string
++-->><<              does nothing

उत्पादन

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

इनपुट

Should disappear: ++>>+<+++<->-->-<<->-<
Should disappear: +++>-<--->+<
Should stay: +++>-<+>---<

उत्पादन

+++>-<+>---<

---

आप इनपुट और आउटपुट को स्वीकार कर सकते हैं, हालांकि आप चाहेंगे - स्टडिन / स्टडआउट, एक फंक्शन इत्यादि, लेकिन इनपुट हार्डकोड नहीं हो सकता है।

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

Comments

मुझे पता है कि यह एक पुरानी चुनौती है, लेकिन परीक्षण के मामले अपर्याप्त हैं। ++>>++<<--आउटपुट होना चाहिए >>++<<, और वह कवर नहीं किया गया था। कृपया अधिक परीक्षण मामले जोड़ें।

— mbomb007

@ mbomb007 क्या आपने पिछले परीक्षण मामले की जांच की +++>-<+>---<,? इसे अनावश्यक सूचक आंदोलन से बचने के लिए छोटा किया जा सकता है, लेकिन अपेक्षित आउटपुट इसे अपरिवर्तित छोड़ देता है। प्रश्न और उत्तर दोनों को देखने के आधार पर मेरी समझ यह है कि डॉर्कनब लूज के साथ लिया जा रहा है। हम किसी भी नो-सेशन सन्निहित को खत्म करना होगा +-><के रूप में स्पष्ट रूप से कहा दृश्यों, और कहा कि परे यह आपके उदाहरण के रूप में अतिरिक्त कम करने से ऐसा करने के लिए अनुमति दी जाती है ++>>++<<--, और हम भी लंबे समय के रूप rearrangements कर सकते हैं के रूप में वे कोड, जैसे की कार्यक्षमता में परिवर्तन नहीं करते >+<+में +>+<।

— मिच श्वार्ट्ज़

@MitchSchwartz "+ के दृश्यों को हटाएं -> <अक्षर अगर वे कुछ भी नहीं करते हैं। उदाहरण के लिए, आपको हटा देना चाहिए +>-<->+<। (इसे लागू करने के लिए सबसे कठिन और सबसे कठिन हो सकता है।) सुनिश्चित करें कि आपको कोई झूठी सकारात्मकता नहीं मिलती है, जैसे +>-<+>-<। जिसे हटाया नहीं जाना चाहिए। ” - यह अस्पष्ट की तरह है

— mbomb007

@ mbomb007 और दूसरी और तीसरी बुलेट बिंदु अनावश्यक और अनावश्यक हैं क्योंकि वे चौथी बुलेट बिंदु में शामिल हैं। तो क्या? यह एक अच्छा काम है। मेरी टिप्पणी रचनात्मक होने और स्पष्टीकरण प्रदान करने के लिए थी, न कि आप पर हमला करने के लिए। कृपया इसे मेरे इच्छित तरीके से लें, या मुझे बताएं कि मुझे इसे अलग तरीके से कैसे कहना चाहिए था। क्योंकि आपने वास्तव में जो लिखा था उसे संबोधित नहीं किया था; ऐसा लगता है जैसे आप वास्तव में रचनात्मक होने के बिना खुद का बचाव करने की कोशिश कर रहे हैं। किस तरह से आप इसे अस्पष्ट पाते हैं? आप इसे कैसे लिखेंगे? क्या आप प्रश्न संपादित करना चाहते हैं? क्या आप Doorknob से पूछना चाहते हैं?

— मिच श्वार्ट्ज

ओह, तो हमें केवल सन्निहित दृश्यों को हटाना है?

— mbomb007

Answer 1

REBEL - 104

_/^_$/$</([^][<>.,+-]|\+-|-\+|<>|><)//((?<X>(<|>))+[+-]+(?!\2)(?<-X><|>)+(?(X)(?!)))([+-]+)/$3$1/.+/$>$&

उपयोग:

इनपुट: स्टड से एक लाइन पढ़ता है।

आउटपुट: प्रिंटआउट के लिए एक लाइन प्रिंट करता है।

विसंगतियों *:

• प्रवेश करने के _कारण दूसरी पंक्ति को पढ़ने और उपयोग करने का कारण बनता है, बजाय कुछ भी आउटपुट करने के।
• इसके ++++>----<बजाय दूसरा परीक्षण आउटपुट +++>-<+>---<। लेकिन यह ठीक है, है ना? ;)
• >-<+आदि के साथ बदल दिया जाता है +>-<।

स्पॉइलर:

विसंगति # 3 को लागू करने से चीजें काफी तुच्छ हो जाती हैं।

_{* यह एक बग नहीं है, यह एक सुविधा है!}

Comments

"यह एक बग इसकी विशेषता नहीं है" +1!

— रोहन झुनझुनवाला

Answer 2

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

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

प्रारूपण और कुछ टिप्पणियों के साथ:

,
[
  <<+>> >>+<<
  [
    [<+> >+<-]
    ++++++[>-------<-]
    >-
    [
      not plus
      -
      [
        not comma
        -
        [
          not minus
          -
          [
            not period
            --------------
            [
              not less than
              --
              [
                not greater than
                <+++++[>------<-]>+
                [
                  not open bracket
                  --
                  [
                    not close bracket
                    <<[-]>>-
                  ]
                ]
                <
              ]
              >
              [
                greater than
                >>-<<
                <<<[-]<[<]<<<[<]
                >>>>>>>>[<]
                <-[+>]
                +[->+]
                >>>>+>[<-]
                <[>+<-<]
                >
              ]
              <
            ]
            >
            [
              less than
              <<<[-]-[<]
              >>>> >>>>>>>[<]
              <<<<<<[<]
              <-[+>]
              +[-<+]
              <<<+<[>-<<<]
              >[-<+<]
            ]
          ]
          <
        ]
        >
        [
          minus
          +>[-<]
          <[<<]
          <[-]>>
        ]
      ]
      <
    ]
    +>
    [
      plus
      -[<-]
      <[>+>+<<-<]
      <[-]>+>
    ]
    <<
    [
      comma or period or bracket
      >-
    ]
    >[,>]
    <
  ]
  comma or period or bracket or eof
  <+<
  [
    start and end same cell
    >
  ]
  >
  [
    >>>
    [
      <<<<[-<]<<<
    ]
    >>>+>>>>
    [
      start right of end
      <<<<->>>>
      [>>>[-<]>>>>]
    ]
  ]
  >
  [
    <<<
    [
      <+[-->>]
    ]
    >[-[.[-]]]
    >[<]
    >
    [
      <<++++++[>+++++++<-]>+>>
      [<<.>>-]
      <<++>-[<.>-]
      +++[<+++++>-]
      +<<<<< <+>
      [
        <<
        [
          go left
          >->>>>>.
          [[-]<<<<]
          <<<+>>>
        ]
        >
        [
          toggle left right
          ->->>>>[-]
        ]
      ]
      <
      [
        toggle right left
        ->+[>>>>>]>>[<]
        <<<<<<<<
        [
          [-]<
        ]
        >
        [
          go right
          ++.[-]
          >>>>>>>
        ]
        <
      ]
    ]
    >>
  ]
  <[>>>>>>>]
  +[-<<<<<[-]<<]
  ,
]

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

इसे ऑनलाइन आज़माएं। (यदि एक नकली सेल का निरपेक्ष मान 256 के करीब हो जाता है, तो अतिप्रवाह समस्याएँ होंगी।)

समग्र संरचना है

while not EOF:
  while not EOF and next char not in ",.[]":
    process char
  print minified sequence (followed by the char in ",.[]" if applicable)

टेप को 7-सेल नोड्स में विभाजित किया गया है; आंतरिक लूप की शुरुआत में, मेमोरी लेआउट है

0 s 0 c 0 a b

sस्टार्ट सेल के लिए बूलियन ध्वज कहां है, cवर्तमान चरित्र है, aसिम्युलेटेड सेल वैल्यू (प्लस वन) का नकारात्मक हिस्सा है, और नकली सेल वैल्यू bका सकारात्मक हिस्सा है।

जब छोटा अनुक्रम मुद्रित किया जा रहा है, तो मेमोरी लेआउट है

d n e 0 0 a b

जहां dदिशा के लिए एक बूलियन ध्वज है, aऔर bपहले की तरह कर रहे हैं (लेकिन बन एक / शून्य जब मुद्रित), और nऔर eअंत नोड के लिए केवल अशून्य हैं; nसंबंधित है कि कितनी बार नोड को देखा गया है, और eचार लूप का मूल्य है जो आंतरिक लूप (प्लस एक) को रोक दिया है।

मूल रूप से मैंने प्रति नोड अधिक जानकारी का ट्रैक रखने पर विचार किया: बूलियन झंडे के रूप में बाईं और सबसे दाहिनी नोड, और प्रारंभ और अंत नोड के संबंध में नोड की स्थिति। लेकिन जब हम जरूरत पड़ने पर पड़ोसी कोशिकाओं को देखते हैं और स्टार्ट नोड को खोजने के लिए बाएं और दाएं स्कैन करके इससे बच सकते हैं।

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

Comments

स्रोत: ब्रेनफक लक्ष्य: ब्रेनफक। +1

— आउटगॉल्फ

यह अनिश्चितकालीन इनाम

— विनाशकारी नींबू

मैं इसे कुछ ध्यान आकर्षित करने और एक या दो दिन में इनाम देने की अनुमति

— दूंगा

@MitchSchwartz आप अपने कोड के खिलाफ अपने कोड का परीक्षण करने के लिए हुआ था? आप वास्तव में इसे छोटा कर सकते हैं! #meta

— वैलीवेस्ट

@WallyWest (7 बाइट्स बचाने के लिए प्रतीत होता है!) नेवरमाइंड, पर्मलिंक में कोड में लाइनब्रेक हैं।

— डेनिस

Answer 3

अजगर, 404 चरस

इस कोड के बाद के सभी का एक सही अनुकूलन करता है +-<>। थोड़ा अधिक आप के लिए कहा है, लेकिन वहाँ तुम जाओ।

M=lambda n:'+'*n+'-'*-n                                                           
def S(b):                                                                         
 s=p=0;t=[0];G,L='><'                                                             
 for c in b:                                                                      
  if'+'==c:t[p]+=1                                                                
  if'-'==c:t[p]-=1                                                                
  if G==c:p+=1;t+=[0]                                                             
  if L==c:s+=1;t=[0]+t                                                            
 if p<s:k=len(t)-1;t,p,s,G,L=t[::-1],k-p,k-s,L,G                                  
 r=[i for i,n in enumerate(t)if n]+[s,p];a,b=min(r),max(r);return(s-a)*L+''.join(M(n)+G for n in t[a:b])+M(t[b])+(b-p)*L                                           
s=b=''                                                                            
for c in raw_input():                                                             
 if c in'[].,':s+=S(b)+c;b=''                                                     
 else:b+=c                                                                        
print s+S(b) 

यह +-<>टेप पर संचालन का अनुकरण करके काम करता है t। sटेप पर प्रारंभिक स्थिति pहै और वर्तमान स्थिति है। सिमुलेशन के बाद, यह उस सीमा का [a,b]पता लगाता है जिसे संचालित करने की आवश्यकता होती है और एक इष्टतम पास में सभी +/- होता है।

Answer 4

कॉफीस्क्रिप्ट - 403 397

i=prompt().replace /[^\]\[,.+-><]/g,''
x=(c)->
 t={};p=n=0
 for d in c
  t[p]?=0;switch d
   when'+'then n=1;t[p]++;when'-'then n=1;t[p]--;when'<'then p--;when'>'then p++
 (n=0if v!=0)for k,v of t;n
s=e=0;((e++;(i=(i.substr 0,s)+i.substr e;e=s=0)if x (i.substr s,e-s).split "")while(i[e]||0)!in['[',']',0];e=++s)while s<=i.length
r=/(\+-|-\+|<>|><|^[<>]$)/g
i=i.replace r,'' while r.test i
alert i

डेमो (कृपया बिट का उपयोग क्षमा करें। यहाँ, पूरा URL मार्कडाउन को तोड़ देगा)

असम्पीडित संस्करण (w / डिबग कोड):

console.clear()
input = """Should disappear: ++>>+<+++<->-->-<<->-<
Should disappear: +++>-<--->+<
Should stay: +++>-<+>---<"""

input = input.replace /[^\]\[,.+-><]/g, ''
console.log input

execute = (code) ->
  stack = {}
  item = 0
  console.log code
  nop = false
  for char in code
    switch char
      when '+' then nop = true; stack[item]?=0;stack[item]++
      when '-' then nop = true; stack[item]?=0;stack[item]--
      when '<' then item--
      when '>' then item++
  console.debug stack
  (nop = false if v != 0) for k,v of stack
  nop
start = 0
end = 0

while start <= input.length
 while input.charAt(end) not in [ '[', ']', '' ]
  end++
  if execute (input.substring start, end).split("")
    input = (input.substring 0, start) + input.substring end
    end = start = 0
    console.log input
 end = ++start
input = input.replace /(\+-|-\+|<>|><|^(<|>)$)/g, '' while /(\+-|-\+|<>|><)/.test input
console.log 'Result: ' + input

Comments

Coffeescript डेमो पोस्ट करने का एक वैकल्पिक तरीका JSFiddle का उपयोग करना है । बाएं मार्जिन में "भाषा" कॉन्फिग पेन है जो आपको JS के बजाय CoffeeScript का उपयोग करने देता है।

— पीटर टेलर

@PeterTaylor धन्यवाद, मुझे पहले JSFiddle के बारे में पता था, लेकिन यह नहीं कि वह

— कॉफ़ीस्क्रिप्ट

यह उस पर विफल रहता है >+.-<, खाली स्ट्रिंग का उत्पादन करने के बजाय इसे अपरिवर्तित छोड़ देता है।

— मिच श्वार्ट्ज