गोलाकार टेप रोमांचक हैं?

Question

एक ब्रेनफॉक व्युत्पन्न

आइए एक सरल ब्रेनफैक जैसी प्रोग्रामिंग भाषा को परिभाषित करें । इसमें कोशिकाओं का दो-दिशात्मक टेप होता है, और प्रत्येक कोशिका में एक बिट होता है। सभी बिट्स शुरू में 0. टेप पर एक घूमता हुआ सिर होता है, शुरुआत में स्थिति 0. एक कार्यक्रम पात्रों पर एक स्ट्रिंग है <>01!, जिसे बाएं से दाएं तक निष्पादित किया जाता है, जिसमें निम्नलिखित शब्दार्थ हैं:

• < सिर को एक कदम बाईं ओर ले जाता है।
• > सिर को एक कदम दाईं ओर ले जाता है।
• 0 वर्तमान सेल में 0 डालता है।
• 1 वर्तमान सेल में 1 डालता है।
• ! वर्तमान सेल फ़्लिप करता है।

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

एक उदाहरण कार्यक्रम

कार्यक्रम पर विचार करें 1>>>!<<<<0>!>>>!। एक अनंत टेप पर, निष्पादन कार्य इस प्रकार है:

     v
00000000000000  Put 1
     v
00000100000000  Move by >>>
        v
00000100000000  Flip
        v
00000100100000  Move by <<<<
    v
00000100100000  Put 0
    v
00000100100000  Move by >
     v
00000100100000  Flip
     v
00000000100000  Move by >>>
        v
00000000100000  Flip
        v
00000000000000

अंत में, सभी कोशिकाएं 0 हैं, इसलिए यह कार्यक्रम उबाऊ है। अब, चलो उसी प्रोग्राम को लंबाई 4 के एक गोलाकार टेप पर चलाते हैं।

v
0000  Put 1
v
1000  Move by >>>
   v
1000  Flip
   v
1001  Move by <<<< (wrapping around at the edge)
   v
1001  Put 0
   v
1000  Move by > (wrapping back)
v
1000  Flip
v
0000  Move by >>>
   v
0000  Flip
   v
0001

इस बार, मूल्य 1 के साथ एक सेल है, इसलिए कार्यक्रम रोमांचक है! हम देखते हैं कि कोई कार्यक्रम उबाऊ है या रोमांचक टेप के आकार पर निर्भर करता है।

काम

आपका इनपुट एक गैर-रिक्त स्ट्रिंग <>01!है जो उपरोक्त प्रोग्रामिंग भाषा में एक कार्यक्रम का प्रतिनिधित्व करता है। वर्णों का एक सरणी भी एक स्वीकार्य इनपुट प्रारूप है। अनंत टेप पर चलने पर कार्यक्रम को उबाऊ होने की गारंटी है। आपका आउटपुट टेप लंबाई की सूची होगी, जिस पर कार्यक्रम रोमांचक है। ध्यान दें कि आपको प्रोग्राम को केवल टेप पर प्रोग्राम की आवश्यकता है जो प्रोग्राम की लंबाई से कम है।

प्रत्येक भाषा में सबसे कम बाइट गिनती के साथ समाधान विजेता है। मानक कोड-गोल्फ नियम लागू होते हैं।

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

> : []
110 : []
1>0<! : [1]
0>>1>0<<>! : [1]
1>>>!<<<<0>!>>>! : [2, 4]
!<!<><<0>!>!<><1!>>0 : [2]
>>!>><>001>0<1!<<!>< : [1, 2, 3]
1!><<!<<<!!100><>>>! : [1, 3]
!!1>!>11!1>>0<1!0<!<1><!0<!<0> : [3, 4]
<><<>>!<!!<<<!0!!!><<>0>>>>!>> : [1, 2, 4]
0>>><!<1><<<0>!>>!<<!!00>!<>!0 : [3]
0000!!!!><1<><>>0<1><<><<>>!<< : []
!>!>!>!>!>1>!>0<!<!<!<0<!<0<!<!<!<1>!>0<<! : [1, 2, 5, 7]
<!!>!!><<1<>>>!0>>>0!<!>1!<1!!><<>><0<<!>><<!<<!>< : [1, 2, 4, 5]
!>1<<11<1>!>!1!>>>0!!>!><!!00<><<<0<<>0<<!<<<>>!!> : [1, 2, 3, 5, 6]

Comments

क्या हम इसके बजाय कोई अलग और सुसंगत चरित्र चुन सकते हैं <>01!?

— मिस्टर एक्सकोडर

निर्देशों का एक सरणी एक स्वीकार्य इनपुट है?

— अरण्युलड

@ Mr.Xcoder नहीं, आपको इन सटीक वर्णों का उपयोग करना चाहिए।

— ज़गरब

@ अरनल्ड वर्णों की एक श्रृंखला एक स्ट्रिंग के लिए पर्याप्त है, मैं इसे अनुमति दूंगा।

— ज़गर्ब

Answer 1

हास्केल, 119 बाइट्स

t#'<'=last t:init t
(h:t)#c|c<'#'=1-h:t|c>'='=t++[h]|1<2=read[c]:t
f p=[n|n<-[1..length p],sum(foldl(#)(0<$[1..n])p)>0]

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

फ़ंक्शन #एकल कमांड के लिए दुभाषिया है c। पूरा कार्यक्रम शुरू टेप के साथ आईएनजी pद्वारा चलाया जाता है । हर टेप के लिए निष्पादित करता है और उन लोगों को रखता है जहां कोशिकाओं का योग कम से कम 1 है।fold#pfp

Comments

n<-[1..length p] ... 0<$[1..n]काफी लंबा लगता है, एक छोटा रास्ता होना चाहिए।

— निमि

मैं इससे छोटा रास्ता नहीं देख सकता। जो समस्या मुझे दिखाई दे रही है वह यह है कि आपको वास्तव nमें परिणाम के मूल्य की आवश्यकता है , इसलिए यदि आपने 0<$[1..n]एक अलग तरह से निर्माण किया है (साथ में कहें scanr(:)), तो आपको इसे लेने की आवश्यकता होगी length। (मैं भी उपयोग करने की कोशिश 1(बदलने के लिए lengthके साथ sum) या False(उपयोग करने के लिए orपरीक्षण के लिए) के बजाय 0, लेकिन यह कम नहीं आया था।)

— Orjan Johansen

@ TriedrjanJohansen: हाँ, मैंने कोशिश की n<-init$scanr(:)[]$0<$p ... nजो 2 बाइट्स छोटी है, लेकिन यह उनकी लंबाई के बजाय टेप शुरू करने की सूची देता है, जैसे [[0],[0,0,0]]। थोड़ा सा नियम झुकने के कारण टेपों को एकात्मक संख्याओं के रूप में देखा जा सकता है, इसलिए शायद यह ठीक है।

— nimi

init$एक [0]प्रारंभिक सूची के रूप में प्रतिस्थापित किया जा सकता है , लेकिन यह अभी भी बहुत कम नहीं मिला है। मुझे लगता है कि एक और अधिक प्राकृतिक संख्या प्रतिनिधित्व के बिना भाषाओं के लिए यूनीरी की अनुमति है ।

— अर्जन जोहान्सन

Answer 2

स्टैक्स , 56 54 43 38 35 बाइट्स ^CP437

è¥%►BΣ░ÜY⌂y(â&.═ªê►V½▲y▌)▀♫♂╣ª?√»!#

42 बाइट्स जब अनपैक किए जाते हैं,

%fz(y{{|(}{|)}{B!s+}{0_]e&}4ls"><! "I@!F|a

भागो और डिबग ऑनलाइन!

-2 बाइट्स प्रति टिप्पणी @recursive द्वारा

व्याख्या

मैं समझाने के लिए उपसर्ग i(यानी i%fz(y{{|(}{|)}{B!s+}{0_]e&}4ls"><! "I@!F|a) के साथ संस्करण का उपयोग करूंगा और समझाऊंगा कि क्यों iहटाया जा सकता है

i               Suppress implicit eval
                    This prevents the test case "110" from being interpreted as a number
                    However, this can be removed because a program containing only numbers cannot be exciting and the output will be empty anyway.
                    This is based on the fact that the program is boring on non-circular tapes
 %f             Filter range [1..n] with the rest of this program
                    Where n is the length of the input
                    Implicit output the array after filtering, one element per line
   z(           Initialize the tape
     y{  F      Run the program
          |a    Any cell is non-zero

प्रोग्राम चलाने के लिए कोड:

{|(}                                 Block to rotate left by one element
    {|)}                             Block to rotate right by one element
        {B!s+}                       Block to perform logical not on the element at index 0
              {0_]e&}                Block to obtain current instruction,
                                         Convert it to a number
                                         And assign to element at index 0

                     4l              Pack the 4 blocks in an array
                       s"<>! "I      Find the index of current instruction in string, if not found, the index will be -1
                                         And when indexed with -1, it wraps around to the 4th element.

                               @!    And execute the corresponding block.

Comments

मैंने आपके iचेक को मान्य करने के लिए सभी अंकों का एक परीक्षण मामला जोड़ा ।

— ज़गारब

0]*से बदला जा सकता है z(। इसके अलावा, आप के लिए स्ट्रिंग परिवर्तित करते हैं "<>!", तो 0और 15. इस के सूचकांक -1 दे देंगे, ताकि जिस तरह से अपने ब्लॉक सूची केवल 4 ब्लॉक की जरूरत है, बजाय के बाद से काम करेंगे 0और 1संचालकों समान वैसे भी कर रहे हैं।

— पुनरावर्ती

@recursive अच्छा बिंदु लिया गया।

— वीजुन झोउ

Answer 3

CJam , 57 56 49 46 बाइट्स

^{-7 @MartinEnder को धन्यवाद}

{:T,({)0a*T{i23%")!+(+ W0tW1t)\+"3/=~}/:+},:)}

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

Answer 4

पर्ल 5 , 83 82 79 77 बाइट्स

के लिए शामिल +3है-F

STDIN पर एक पंक्ति के रूप में निर्देश दें

#!/usr/bin/perl -F
1~~@$m&&say$m until++$m>map{*r=\$$m[($n+=/>/-/</)%$m];$r=/\d/?$&:$r^/!/}@F

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

Comments

झंडे अब स्कोरिंग के बजाय भाषा के हिस्से के रूप में गिने जाते हैं ।

— अर्जन जोहान्सन

Answer 5

पर्ल 5 ( -F), 101 बाइट्स

map{$,=@a=(0)x$_;map{$,+=/>/-/</;$a[$,%@a]=$&if/0|1/;$a[$,%@a]=!$a[$,%@a]if/!/}@F;say if@a~~/1/}1..@F

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

Answer 6

लाल , 243 बाइट्स

func[p][repeat n length? p[b: copy[]insert/dup b 0 n i: 1
parse p[any["<"(i: i - 1 if i < 1[i: n])|">"(i: i + 1 if i > n[i: 1])|"0"(b/(i): 0)|"1"(b/(i): 1)|"!"(b/(i): either b/(i) = 0[1][0])|
skip]]s: 0 foreach c b[s: s + c]if s > 0[print n]]]

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

प्रीति क्रिया और सीधा कार्यान्वयन। रेड का 1-इंडेक्सिंग मुझे परिपत्र टेप के माध्यम से लूपिंग के लिए मॉड्यूलर अंकगणितीय का उपयोग करके बाइट की संख्या को कम करने की अनुमति नहीं देता है।

Ungolfed

f: func[p][ 
    repeat n length? p[
        b: [] 
        insert/dup b 0 n
        i: 1
        parse p[
            some [
                 "<" (i: i - 1 if i < 1[i: n])
               | ">" (i: i + 1 if i > n[i: 1])
               | "0" (b/(i): 0)
               | "1" (b/(i): 1)
               | "!" (b/(i): either b/(i) = 0 [1][0])
               | skip 
            ]
        ]
        s: 0
        foreach c b[s: s + c]
        if s > 0 [print n]
    ]
]

Answer 7

पायथन 2 , 139 135 133 132 131 बाइट्स

-3 बाइट्स मिस्टर एक्सकोडर की बदौलत

def f(p):i=0;exec"i+=1;s=[0]*i\nfor c in p:c=ord(c)-61;s=c>-2and s[c:]+s[:c]or[[s.pop(0)^1,0,1][c%7]]+s\nif 1in s:print i\n"*len(p)

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

Comments

131 बाइट्स?

— श्री एक्सकोडर

Answer 8

रेटिना , 121 बाइट्स

.+
$.&*0¶$&
\G0
0$`¶
{ms`^.(?=.*¶¶(0|1))
$1
"¶¶!"&mT`d`10`^.
"¶¶>"&`(.)(.*)¶
$2$1¶
"¶¶<"&`(.*)(.)¶
$2$1¶
)`¶¶.
¶¶
G`1
%`.

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
$.&*0¶$&
\G0
0$`¶

इनपुट प्रोग्राम की लंबाई तक प्रत्येक लंबाई के टेपों की एक सरणी बनाएं।

{

कार्यक्रम का उपभोग होने तक लूप करें।

ms`^.(?=.*¶¶(0|1))
$1

यदि कार्यक्रम का अगला वर्ण 0 या 1 है, तो प्रत्येक वर्ण पर पहले वर्ण को उस वर्ण में बदलें।

"¶¶!"&mT`d`10`^.

यदि यह !प्रत्येक पंक्ति पर पहले वर्ण को टॉगल करने के लिए है।

"¶¶>"&`(.)(.*)¶
$2$1¶
"¶¶<"&`(.*)(.)¶
$2$1¶

यदि यह >या <तो लाइन घुमाएगी। (सिर हिलाने से ज्यादा आसान।)

)`¶¶.
¶¶

निर्देश हटाएं और लूप को समाप्त करें।

G`1

केवल रोमांचक रेखाएँ रखें।

%`.

प्रत्येक पंक्ति की लंबाई गिनें।

Answer 9

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

सहेजे गए 3 बाइट्स @ user71546 के लिए धन्यवाद

1-वर्ण स्ट्रिंग्स की एक सरणी के रूप में इनपुट लेता है।

f=(s,l=0,p=0,t=[])=>s[l++]?s.map(c=>1/c?t[p%l]=+c:c>'='?p++:c>';'?p+=l-1:t[p%l]^=1)&&+t.join``?[l,...f(s,l)]:f(s,l):[]

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

Comments

जगह t.some(x=>x)?से +t.join``?बजाय अंकों के रूप में सरणी जाँच (और 0 एक सब शून्य टेप को इंगित करता है), लेकिन 3 बाइट्स कम।

— शायरु असकोतो

Answer 10

APL (Dyalog Unicode) , 79 64 54 बाइट्स ( Adám's SBCS )

⍸⊂{∨/⍎⍕(↓',',⍨5 3⍴'0@11@1~@1 1⌽¯1⌽')['01!<'⍳⌽⍺]⍵}¨0=,\

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

-15 Adám के लिए धन्यवाद ( राक्षसी के बारे में भूल गया ⍸)।
-10 धन्यवाद ngn करने के लिए ।

Comments

64

— अड्म

@ एडम एचएम, ऐसा लगता है कि यह इष्टतम नहीं है (उदाहरण के लिए आपको इसकी आवश्यकता नहीं है ↓)। मैं इसे देखूंगा और अपडेट करूंगा। :)

— बजे आउटगोल्फ

लेकिन अगर आप निकालते हैं तो आपको ↓एक की आवश्यकता होगी ;, नहीं?

— आदम

@ नहीं , तुम क्यों करोगे?

— आउटगोल्फर

क्योंकि रैंक -2 सरणियों को दो सूचकांक भागों की आवश्यकता होती है ।

— आदम

Answer 11

MATL , 46 39 बाइट्स

f"@:~G"@59>?@61-YS}@33=?t1)~}@U]1(]]a?@

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

f             % Push indices of nonzero chars of (implicit) input string: gives
              % [1 2 ... n] where n is input length
"             % For each k in [1 2 ... n]. These are the possible tape lengths
  @:~         %   Push array of k zeros. This is the tape, in its initial state
  G           %   Push input string
  "           %   For each char in the input string
    @59>?     %     If code point of current char exceeds 59 (so it is '<' or '>')
      @61-    %       Push code point minus 61: gives -1 for '<', or 1 for '>'
      YS      %       Circularly shift the tape by that amount. Instead of moving
              %       the head, we shift the tape and keep the head at entry 1
    }         %     Else
      @33=?   %       If code point of current char is 33 (so it is '!')
        t1)   %         Duplicate the array representing the tape, and get its
              %         first entry
        ~     %         Logical negate
      }       %       Else
        @U    %         Push current char (it is '0' or '1') converted to number
      ]       %       End
      1(      %       Write (either 0, 1 or old value negated) at entry 1
    ]         %     End
  ]           %   End
  a?          %   If the tape contains at least a nonzero value
    @         %     Push tape length, k
              %   End (implicit)
              % End (implicit)
              % Display (implicit)

Answer 12

एपीएल (डायलॉग यूनिकोड) , 192 78 बाइट्स

⊂{t/⍵⊣⍵{t[m]←('01!'⍳⍵)⊃0 1,e,⍨~e←t[m←⍺|i⊣i+←¯1 1 0⊃⍨'<>'⍳⍵]}¨⍺⊣i←⊃t←⍬⍳⍺}¨1+⍳∘≢

इसे ऑनलाइन आज़माएं! (गैर-चपटा परिणाम)

इसे ऑनलाइन आज़माएं! (चपटा)

कुछ समय दीवार के खिलाफ मेरे सिर को पीटने के बाद, मैंने एक डीएफएन के बजाय एक ट्रेडफ़न बनाने का फैसला किया। यह परिणाम है। होशियार लोग मुझसे ज्यादा इस से बाहर निकलने में सक्षम हो सकते हैं।

आश्चर्य, हैरानी की बात, किसी ने होशियार की तुलना में इस गोल्फ को बाहर किया। 114 बाइट्स के लिए आपको धन्यवाद।

उसने कहा:

ध्यान दें कि यह आपका सटीक कार्यक्रम है, केवल आंतरिक के बजाय अनुक्रमण का उपयोग करने के अलावा: वैश्विक स्तर पर प्रतिस्थापित करने के लिए एक बाईं ओर तर्क देते हुए: for-loops to {_} exact।

फ़ंक्शन मानता है ⎕IO←0।

---

कैसे?

(यह स्पष्टीकरण पढ़ने की सुविधा के लिए एक "अनगुल्ड" संस्करण का उपयोग करता है)

⊂{                                  ⍝ Enclose
      i←⊃t←⍬⍳⍺                      ⍝ Assign a vector of 0s to t (the tape), then assign the first 0 to i.
      t/⍵⊣⍵{                        ⍝ Use ⍵ as left argument for the nested function, then compress the result into t. If there is a 1 anywhere in t, the result will be a vector of the result. If not, the result is an empty vector.
          i+←¯1 1 0⊃⍨'<>'⍳⍵         ⍝ Map the string '<>' to the argument (which is the BF program). That yields 0 for <, 1 for >, and 2 for anything else.
                                    ⍝ The resulting vector will then be used as the argument for ⊃ to add -1 (index 0), 1 (index 1) or 0 (index 2) to the variable i.
          e←t[m←⍺|i]                ⍝ Assign i mod ⍺ (left arg) to m, and use it to index t. Then, assign the value to e.
          t[m]←('01!'⍳⍵)⊃0 1,e,⍨~e  ⍝ Map the string '01!' to ⍵. As before, this yields 0 for 0, 1 for 1, 2 for ! and 3 for anything else.
                                    ⍝ Then, concatenate (not e) with e, then concatenate that with the vector 0 1. This is used as argument to be picked from, and it is assigned to t[m].
      }¨⍺                           ⍝ Do that for each argument
  }¨1+⍳∘≢                           ⍝ And do that for each possible tape length from 1 to the length of the input.

Comments

बनाकर सहेजें एक बाइट t←l⍴0हो t←l⍴i←0, और यह ऊपर लाइन को हटाने के। तुम भी बदलकर एक और सहेज सकते हैं t[i|⍨≢t]←1-t[i|⍨≢t]करने के लिए t[i|⍨≢t]←~t[i|⍨≢t]।

— Zacharý

@ Zacharý सही है, और आगे एक अतिरिक्त 112 बाइट्स बचाएं । बिल्कुल एक ही कोड, बस थोड़ा गोल्फ।

— अड्म

हाँ, यह सिर्फ "थोड़ा सा" है। क्या आपको एस की जरूरत नहीं है ∇?

— जच्चा

@ Zacharý क्या है ∇? यह एक मौन कार्य है।

— Adám

@ Zacharý मैं इस एक सुंदर Adám'd पर विचार करेंगे, क्या तुम नहीं?

— जे। सेले

Answer 13

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

JR0ṁð3“1⁺¦01¦¬1¦ṙ1 ṙ- ”s“10!<>”,yẎvЀ⁸Ẹ€T

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

Answer 14

सी (क्लैंग) , 171 बाइट्स

l,i;f(S){for(char*p,t[l=strlen(S)];l;memchr(t,1,l)&&printf("%d ",l),l--)for(memset(t,i=0,l),p=S;*p;p++)*p==60?i=i?i-1:l-1:*p==62?i=i^l-1?i+1:0:*p^33?t[i]=*p-48:(t[i]^=1);}

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

क्लैंग का उपयोग करना पड़ा, क्योंकि char*p,t[l=strlen(S)]किसी कारण से प्रारंभिक अभिव्यक्ति के रूप में उपयोग करने से जीसीसी को लगता है कि मैं strlenइसे कॉल करने के बजाय घोषित करना चाहता हूं ।

बहुत सीधा-सीधा: घटती लंबाई के गोलाकार टेपों पर प्रोग्राम चलाता है, किसी भी लम्बाई का उत्पादन करता है जिसका परिणाम टेप पर कहीं 1 होता है।

टर्नरी ऑपरेटरों की उलझन को कम करने की कोशिश की, लेकिन स्वस्थ होने की तुलना में अधिक कोष्ठक की जरूरत समाप्त हो गई।

Comments

के i=0,bzero(t,l)बजाय memset(t,i=0,l)और के *p-62?t[i]=*p^33?*p-48:t[i]^1:(i=~i+l?i+1:0)बजाय*p==62?i=i^l-1?i+1:0:*p^33?t[i]=*p-48:(t[i]^=1)

— छत 1