বিজ্ঞপ্তি টেপ কি উত্তেজনাপূর্ণ?

Question

একটি ব্রেইনফাক ডেরিভেটিভ

আসুন একটি সাধারণ ব্রেইনফাক-এর মতো প্রোগ্রামিং ভাষার সংজ্ঞা দিন। এটিতে কোষগুলির একটি দ্বি-নির্দেশমূলক টেপ রয়েছে এবং প্রতিটি কক্ষ একটি বিট ধারণ করে। সমস্ত বিট শুরুতে 0 হয়। টেপটিতে একটি চলন্ত মাথা থাকে, প্রাথমিকভাবে পজিশনে 0 একটি প্রোগ্রাম হ'ল অক্ষরগুলির উপর একটি স্ট্রিং <>01!, বাম থেকে ডানদিকে চালিত হয়, নিম্নলিখিত শব্দার্থবিজ্ঞানের সাথে:

• < বাম দিকে মাথা এক পা বাড়ায়।
• > মাথাটি একপাশে ডান দিকে সরায়।
• 0 বর্তমান কক্ষে 0 রাখে।
• 1 1 বর্তমান কক্ষে রাখে।
• ! বর্তমান সেলটি ফ্লিপ করে।

কোনও লুপ নেই, সুতরাং এন অক্ষরের একটি প্রোগ্রাম ঠিক এন পদক্ষেপের পরে শেষ হয় । একটি কর্মসূচী বিরক্তিকর হয় যদি সমস্ত কক্ষের প্রয়োগের শেষে 0 থাকে এবং কমপক্ষে একটি থাকে তবে উত্তেজনাপূর্ণ 1 Note দ্রষ্টব্য যে টেপের আকার নির্দিষ্ট করা হয়নি, তাই প্রয়োগের উপর নির্ভর করে এটি দ্বিমুখী অসীম বা হতে পারে বিজ্ঞপ্তি।

একটি উদাহরণ প্রোগ্রাম

প্রোগ্রাম বিবেচনা করুন 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!?

— মিঃ এক্সকোডার

নির্দেশাবলীর একটি অ্যারে কি গ্রহণযোগ্য ইনপুট?

— আর্নল্ড

@ মিঃ এক্সকোডার নো, আপনার এই সঠিক অক্ষরগুলি ব্যবহার করা উচিত।

— Zgarb

@ আরনাউল্ড একটি অক্ষরের একটি অ্যারে যথেষ্ট পরিমাণে স্ট্রিং, আমি এটির অনুমতি দেব।

— Zgarb

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দ্বারা চালানো হয় folding #মধ্যে শুরু টেপ সঙ্গে p। প্রতিটি টেপের জন্য fনির্বাহ pকরে এবং যেখানে কোষগুলির যোগফল কমপক্ষে 1 হয় তাদের রাখে।

Comments

n<-[1..length p] ... 0<$[1..n]বেশ লম্বা মনে হচ্ছে, আরও একটি ছোট পথ থাকতে হবে।

— নিমি

আমি আরও ছোট উপায় দেখতে পাচ্ছি না। আমি যে সমস্যাটি দেখছি তা হ'ল nফলস্বরূপ আপনার প্রকৃত মান প্রয়োজন , সুতরাং আপনি যদি 0<$[1..n]অন্যভাবে নির্মাণ করেন (সাথে বলুন scanr(:)) তবে আপনার lengthএটি গ্রহণ করা দরকার । (আমিও ব্যবহার করার চেষ্টা 1(প্রতিস্থাপন lengthসঙ্গে sum) অথবা False(ব্যবহার করতে orপরীক্ষার জন্য) পরিবর্তে 0, কিন্তু এটা আউট খাটো আসেনি।)

— Orjan Johansen

@ এরজান জোহানসেন: হ্যাঁ, আমি চেষ্টা করেছিলাম n<-init$scanr(:)[]$0<$p ... nযা 2 বাইটের চেয়ে কম, তবে এটি তাদের দৈর্ঘ্যের পরিবর্তে টেপগুলি শুরু করার একটি তালিকা দেয়, যেমন [[0],[0,0,0]]। কিছুটা নিয়ম বাঁকানো দিয়ে টেপগুলি অবিচ্ছিন্ন সংখ্যা হিসাবে দেখতে পেল, তাই সম্ভবত এটি ঠিক আছে।

— নিমি

init$একটি [0]প্রাথমিক তালিকা হিসাবে স্থাপন করে প্রতিস্থাপন করা যেতে পারে , তবে এটি এখনও যথেষ্ট সংক্ষিপ্ত হয়নি। আমি মনে করি যে অ্যানারি কেবলমাত্র প্রাকৃতিক সংখ্যার উপস্থাপনা ছাড়াই ভাষার জন্য অনুমোদিত ।

— janrjan জোহানসেন

Answer 2

স্ট্যাক্স , 56 54 43 38 35 বাইট ^{সিপি 437}

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

আনপ্যাক করা হলে 42 বাইট,

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

চালান এবং অনলাইন ডিবাগ!

-2 bytes per comment by @recursive

ব্যাখ্যা

I will use the version with a prefix i(i.e. i%fz(y{{|(}{|)}{B!s+}{0_]e&}4ls"><! "I@!F|a) to explain and I will explain why the i can be removed

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

Code for running the program:

{|(}                                 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 added a test case of all digits to validate your i check.

— Zgarb

0]* can be replaced with z(. Also, if you change the string to "<>!", then 0 and 1 will give index -1, so that way your block list only needs 4 blocks, instead of 5. This will work since the 0 and 1 handlers are identical anyway.

— recursive

@recursive Good point taken.

— Weijun Zhou

Answer 3

CJam, 57 56 49 46 bytes

^{-7 thanks to @MartinEnder}

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

Try it online!

Answer 4

Perl 5, 83 82 79 77 bytes

Includes +3 for -F

Give instructions as one line on STDIN

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

Try it online!

Comments

Flags now count as part of the language instead of scoring.

— Ørjan Johansen

Answer 5

Perl 5 (-F), 101 bytes

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

Try it online!

Answer 6

Red, 243 bytes

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]]]

Try it online!

Prety verbose and straightforward implementation. Red's 1-indexing doesn't allow me to reduce the byte count by using modular arithmetic for looping through the circular tapes.

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

Python 2, 139 135 133 132 131 bytes

-3 bytes thanks to Mr. Xcoder

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)

Try it online!

Comments

131 bytes?

— Mr. Xcoder

Answer 8

Retina, 121 bytes

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

Try it online! Explanation:

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

Create an array of tapes of each length up to the length of the input program.

{

Loop until the program is consumed.

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

If the next character in the program is a 0 or 1, change the first character on each line to that character.

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

If it is a ! then toggle the first character on each line.

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

If it is a > or < then rotate the line. (Easier than moving the head.)

)`¶¶.
¶¶

Delete the instruction and end the loop.

G`1

Keep only the exciting lines.

%`.

Count the length of each line.

Answer 9

JavaScript (ES6), 126 118 bytes

Saved 3 bytes thanks to @user71546

Takes input as an array of 1-character strings.

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):[]

Try it online!

Comments

Replacing t.some(x=>x)? by +t.join``? instead check the array as digits (and 0 indicates an all-zero tape), but 3 bytes less.

— Shieru Asakoto

Answer 10

APL (Dyalog Unicode), 79 64 54 bytes (Adám's SBCS)

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

Try it online!

-15 thanks to Adám (forgot about monadic ⍸).
-10 thanks to ngn.

Comments

64

— Adám

@Adám Hm, looks like that's not optimal (for example you don't need the ↓). I'll look into it and update. :)

— Erik the Outgolfer

But if you remove the ↓ you'll need a ;, no?

— Adám

@Adám no, why would you?

— Erik the Outgolfer

Because rank-2 arrays need two index parts.

— Adám

Answer 11

MATL, 46 39 bytes

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

Try it online! Or verify all test cases.

How it works

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

APL (Dyalog Unicode), 192 78 bytes

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

Try it online! (non-flattened result)

Try it online! (flattened)

After some time spent banging my head against the wall, I decided to make a Tradfn instead of a Dfn. This is the result. Smarter people than me may be able to golf the heck out of this.

Surprise, surprise, someone smarter than me did golf the heck out of this. Thank you Adám for 114 bytes.

He said:

Notice that it is your exact program, except using indexing instead of the inner :Ifs and collapsing :For-loops to {_}¨ while giving a left argument to replace the global.

The function assumes ⎕IO←0.

---

How?

(This explanation uses an "ungolfed" version to facilitate reading)

⊂{                                  ⍝ 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

Save one byte by making t←l⍴0 be t←l⍴i←0, and removing the line above it. You can also save another by changing t[i|⍨≢t]←1-t[i|⍨≢t] to t[i|⍨≢t]←~t[i|⍨≢t].

— Zacharý

@Zacharý right, and further save an additional 112 bytes. Exactly same code, just golfed a bit.

— Adám

Yeah, it's just goled "a bit". Don't you need the ∇s?

— Zacharý

@Zacharý What ∇s? It is a tacit function.

— Adám

@Zacharý I would consider this one pretty Adám'd, wouldn't you?

— J. Sallé

Answer 13

Jelly, 41 bytes

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

Try it online!

Answer 14

C (clang), 171 bytes

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);}

Try it online!

Had to use clang, since using char*p,t[l=strlen(S)] as the initialisation expression for some reason makes GCC think I want to declare strlen instead of calling it.

Pretty straight-forward: Runs the program on circular tapes of decreasing length, outputting any length that resulted in a 1 somewhere on the tape.

Tried shortening the tangle of the ternary operators, but ended up needing more parenthesis than was healthy.

Comments

Suggest i=0,bzero(t,l) instead of memset(t,i=0,l) and *p-62?t[i]=*p^33?*p-48:t[i]^1:(i=~i+l?i+1:0) instead of *p==62?i=i^l-1?i+1:0:*p^33?t[i]=*p-48:(t[i]^=1)

— ceilingcat