23

সেলুলার অটোমাতা সত্যই আকর্ষণীয়। সাধারণত যেগুলির বিষয়ে কথা হয় সেগুলি হ'ল বাইনারিগুলি, অর্থাত্ একটি সংখ্যার দ্বারা উপস্থাপনযোগ্য। যাইহোক, আমার মতে, তারা মৃত্যুর জন্য করা হয়েছে। টার্নারি সিএগুলি আরও আকর্ষণীয়, তবে আমাদের বিবেচনার জন্য সমস্ত ASCII আছে! কী মজা হতে পারে!

প্রতিটি চরিত্রের জন্য কোনও রুলসেট সিদ্ধান্ত নেওয়ার পরিবর্তে, আমি একটি সাধারণ সিদ্ধান্ত নেওয়ার নিয়ম ব্যবহার করব যা আমি শীঘ্রই আলোচনা করব। পরবর্তী প্রজন্মের সিদ্ধান্ত নেওয়ার জন্য, আমরা তিনটি "শীর্ষ" কোষের দিকে তাকাই, অনেকটা সেলুলার অটোমেটার মতো। একটি উদাহরণ পর্যবেক্ষণ করুন:

QWERTY
X Y Z

"শীর্ষ" Yহ'ল WER, উপরের এবং ডানদিকে, উপরের এবং উপরে এবং বাম কোষগুলি। ওয়াই আমি যে ফাংশনটি সংজ্ঞায়িত করতে চলেছি তার ফলাফল হবে যা তিন-চর স্ট্রিংয়ের একটি ফাংশন। এর "শীর্ষ" Xহয় QW, বা অবর্তমান / অনুপস্থিত কক্ষে একটি স্থান ভরাট ।

এখন, ~~মজা~~ ফাংশন জন্য! আমি এই ক্রমটি একটি কারণে XOROR ক্রম বলি। দিন Aউপরের-বামের charcode হও, Bউপরে সেল charcode কর এবং Cউপরের ডান সেল charcode হও। তারপর, ফলে সেল চরিত্র যার charcode হয় (A XOR B) OR C, যে (A^B)|C। (যদি ফলস্বরূপ মানটি 126 এর বেশি হয় তবে এটি সেট (CHARCODE % 127) + 32করা থাকে a 32 এর চেয়ে কম মান হলে কিছুই করা হয় না)) এখানে বীজের একটি উদাহরণ রয়েছে Hello, World!:

S: Hello, World!
0: mmmo/c_ z}~)e
   m = ( )^(H)|(e) = (32^72)|101 = 104|101 = 109 (m)
    m = (H)^(e)|(l) = (72^101)|108 = 45|108 = 109 (m)
    etc.
1: mmo/c_<   +wl
2: mo/c_<c< + |;
3: o/c_<c  ?+  g
4: oc_<c c??4+gg
5: 0_<c c  4+ o 
6: _<c ccc4??ooo
7:  c ccc4 ?o o 
8: ccccc4w? pooo
9: cccc4w h   o 
A: ccc4wc hh ooo
B: cc4wc4kh ooo 
C: c4wc4  #ooo o
D: wwc4w4#ooo oo
E: wc4wwc oo oo 
F: w4wwc4oo oo o
G: wwwc4   oo oo
H: wwc4w4 oo oo 
I: w4wwc4oooo oo
J: wwwc4  oo oo 
K: wwc4w4oo oo o
L: wc4wwo  oo oo
M: w4wwo8ooo oo 
N: wwwo8  o oo o
O: wwo8w8oooo oo

এবং আমরা এরপরে কিছুক্ষণ এগিয়ে যেতে পারি। স্ট্রিংয়ের এই পরিবর্তনটিকে XOROR ক্রম বলা হয়।

উদ্দেশ্য আপনি একটি প্রোগ্রাম বা ফাংশন লিখতে যা নিম্নলিখিত কাজগুলির মধ্যে একটি করে:

একটি স্ট্রিং দেওয়া sএবং একটি সংখ্যা n >= 0, আউটপুট nবীজ সঙ্গে XOROR ক্রম উপর তম স্ট্রিং sসঙ্গে n = 0স্ট্রিং এর প্রথম রূপান্তর হচ্ছে।
একটি স্ট্রিং প্রদত্ত s(ফাংশন / জেনারেটর জন্য) আউটপুট (প্রোগ্রামের জন্য) অথবা উৎপন্ন বীজ সঙ্গে XOROR ক্রম অসীম প্রবাহ s। যদি ক্রমটি পুনরাবৃত্তি করে তবে আপনি থামতে বেছে নিতে পারেন, তবে এটি প্রয়োজনীয় নয়।

s সর্বদা কেবল স্থান থেকে টিলডে প্লাস ট্যাবগুলিতে মুদ্রণযোগ্য ASCII অক্ষর সমন্বিত থাকবে (কোনও নতুন লাইন নেই))

এটি একটি কোড-গল্ফ , তাই বাইটের মধ্যে সংক্ষিপ্ততম প্রোগ্রামটি জিতে।

— কনর ও ব্রায়ান
সূত্র

"সুতরাং, আমি তিন-চর স্ট্রিংয়ের সাথে যে কোনও ফাংশন সংজ্ঞায়িত করতে চাই, ওয়াই হয়ে যাবে" বাক্যটি বিশ্লেষণ করতে আমার সমস্যা হচ্ছে। এটির অর্থ কী: "ওয়াই হ'ল আমি যে ফাংশনটি সংজ্ঞায়িত করতে চলেছি তার ফলাফল, থ্রি-চর স্ট্রিংয়ের একটি ক্রিয়াকলাপ?"

— hYPotenuser

3

এস এর সমস্ত oএটিকে জির্গের ভিড়ের মতো দেখায় ।

— mbomb007

3

পর্যবেক্ষণ: যেহেতু XOR এবং OR বিটের সংখ্যা সংরক্ষণ করে এবং সমস্ত ASCII b বিট হয়, কেবলমাত্র যখন একটি চারকোড> 126 হয় তবে এটি 127 হয় for অতএব, আপনি কেবল এটির স্থান (32) দিয়ে প্রতিস্থাপন করতে পারেন 127%127+32==32।

— CAD97

2

কেন n=0আসল স্ট্রিং না ?

— নীল

3

@ ফ্যাটাল স্লিপ আপনার প্রথম অভিযোগ হিসাবে, আমি বলেছি যে, কোনও কক্ষ উপস্থিত না থাকলে ফলাফলটি একটি স্থান, তাই এটির পরিবর্তে হবে (d^!)|(space)। আপনি দ্বিতীয় প্রশ্ন হিসাবে, আপনি XOROR সঞ্চালনের (CHAR%127)+32 পরে সঞ্চালন ।

— কনর ও ব্রায়ান

4

এমএটিএল , 33 31 বাইট

Q:"32XKhKwh3YCPo2$1Z}Z~Z|127KYX

এটি ভাষা / সংকলকের 13.1.0 প্রকাশে কাজ করে যা চ্যালেঞ্জের পূর্বাভাস দেয়।

প্রথম ইনপুটটি হল নম্বর, দ্বিতীয়টি স্ট্রিং।

এটি অনলাইন চেষ্টা করুন!

Q           % take input (number) implicitly and add 1
:"          % repeat that many times
  32XK      %   push 32 (space). Copy to clipboard K.
  h         %   concatenate. Takes input (string) implicitly the first time
  Kwh       %   push space, swap, concatenate
  3YC       %   overlapping blocks of length 3 as columns of 2D array
  P         %   flip upside-down 
  o         %   convert to numbers
  2$1Z}     %   separate the three rows and push them
  Z~        %   bitwise XOR (note the rows are in reverse order)
  Z|        %   bitwise OR
  127KYX    %   replace 127 by space using regexprep, which converts to char
            % end loop
            % implicitly display

— লুইস মেন্ডো
সূত্র

21

গণিত, 133 বাইট

FromCharacterCode@Nest[BlockMap[If[#>126,#~Mod~127+32,#]&[BitXor[#,#2]~BitOr~#3]&@@#&,ArrayPad[#,1,32],3,1]&,ToCharacterCode@#,#2+1]&

CellularAutomaton[]সমাধানের কাজটি করা ভাল লাগবে তবে আমি সংক্ষেপে সামনে আসতে থাকি। যে কেউ?

সম্পাদনা করুন: বেশ কয়েকটি সুন্দর ছবি (বড় করার জন্য ক্লিক করুন)

plotCA[str_, n_] := ArrayPlot[NestList[foo[str],n], ColorFunction -> "Rainbow"]

plotCA["Hello, World!", 60]:

plotCA[bXORnotb, 100]:

plotCA[raven, 100]:

— hYPotenuser
সূত্র

1

আপনি কি CellularAutomatonআপনার আপডেট ফাংশন দিতে পারবেন না ? (127 টি বৈধ রাষ্ট্রের সাথে আসল বিধি সংখ্যাটি উন্মাদ হবে))

— মার্টিন এন্ডার

@ মার্টিনব্যাটনার আপনি এটি করতে পারেন, তবে এটি এমন একটি টানা যা প্রান্তে আচরণের জন্য অ্যাকাউন্টটি দেওয়ার চেষ্টা করছে, যাতে এটি অনুমানের সাথে সামঞ্জস্যপূর্ণ হয়। ব্লকম্যাপ [] কেবল ছোট ছিল।

— hYPotenuser

7

জাভা, 193 185 বাইট

কারণ জাভা

-8 বাইটগুলি এটি একটি বেনামি ফাংশন হিসাবে পুনরাবৃত্তি না করে লুপিংয়ে স্যুইচ করে

এস এর উপর XOROR এর n'তম পুনরাবৃত্তি প্রদান করে।

(s,n)->{String o=s;for(;n-->=0;){o="";for(int i=0;i<s.length();i++){char c=(char)((i>1?s.charAt(i-1):' ')^s.charAt(i)|(i<s.length()-1?s.charAt(i+1):' '));o+=c>126?' ':c;}s=o;}return o;}

পঠনযোগ্য সংস্করণ:

static BiFunction<String, Integer, String> f = (s,n)->{
    String o=s;
    for(;n-->=0;) {
        o = "";
        for (int i=0;i<s.length();i++) {
            char c=(char)((i>1?s.charAt(i-1):' ')^s.charAt(i)|(i<s.length()-1?s.charAt(i+1):' '));
            o+=c>126?' ':c;
        }
        s=o;
    }
    return o;
};

public static void main(String[]a) {
    System.out.println(f.apply("Hello, World",1));
}

অপারেশনটি এন বার প্রয়োগ করার জন্য একটি পুনরাবৃত্ত লুপ সহ চমত্কারভাবে স্পেকটির আক্ষরিক বাস্তবায়ন। কিছু বাইট সংরক্ষণ করা হয়েছিল, তবে আমার পর্যবেক্ষণের সাথে যে চারকোড> 126 ধারাটি কেবল চার্কোড == 127 দিয়েই ঘটবে, যার SPACEপরিবর্তে ফলাফল সংরক্ষণ করা হবে DEL।

আমি আমার কোডটি কয়েকটি ইচ্ছামত বেছে নেওয়া স্ট্রিংগুলিতে চালিয়েছি এবং এই দুর্দান্ত চক্রটি পেয়েছি:

oook$ok$ok$ok$
ook$ok$ok$ok$o
oo$ok$ok$ok$ok
oook$ok$ok$ok$

— CAD97
সূত্র

5

এই উত্তর দেখতে ok!

— কনর ও ব্রায়ান

3

esolangs.org/wiki/ook !

— ভি

5

সিজেম, 38 বাইট

lri){2S*\*3ew{)\:^|_'~>{i127%' +}&}%}*

এটি এখানে পরীক্ষা করুন।

ব্যাখ্যা

l                e# Read string.
ri               e# Read n.
){               e# Run this block n+1 times...
  2S*\*          e#   Wrap in two spaces.
  3ew            e#   Get all (overlapping) substrings of length 3.
  {              e#   Map this block over all those substrings...
    )\           e#     Pull off the third character and put it below the other two.
    :^           e#     Take XOR of the other two.
    |            e#     OR with the third one.
    _'~>         e#     Duplicate and check if it's greater than '~'.
    {i127%' +}&  e#     If so, mod 127, add to space.
  }%
}*

— মার্টিন ইন্ডার
সূত্র

আমি মনে করি আপনি এর সাথে কয়েকটি বাইট সংরক্ষণ করতে পারবেন lri){2S*\*3ew{)\:^|}%127c' er}*কারণ চরগুলি প্রাক-মডুলো অপারেশন কখনও 127 ছাড়িয়ে যায় না

— লুইস মেন্ডো

5

হাস্কেল, 123 বাইট

import Data.Bits
f s=toEnum.a<$>zipWith3(((.|.).).xor)(32:s)s(tail s++[32])
a x|x>126=32|1<2=x
tail.iterate(f.map fromEnum)

এটি XOROR ক্রমের একটি অসীম স্ট্রিম ফেরায়। ব্যবহারের উদাহরণ (বীজের প্রথম 5 উপাদান মুদ্রণ করুন "Hello, World!"):

*Main> mapM_ print $ take 5 $ (tail.iterate(f.map fromEnum)) "Hello, World!"
"mmmo/c_ z}~)e"
"mmo/c_<   +wl"
"mo/c_<c< + |;"
"o/c_<c  ?+  g"
"oc_<c c??4+gg"

কিভাবে এটা কাজ করে:

tail.iterate(f.map fromEnum)               -- repeat forever: convert to ASCII
                                           -- value and call f, discard the first
                                           -- element (the seed).

                                           -- one iteration is:
  zipWith3(   )(32:s) s (tail s++[32])     -- zip the elements from the three lists
                                           -- (space:s), s and tail of s ++ space,
                                           -- e.g. s = "Hello!":
                                           --   | Hello|
                                           --   |Hello!|
                                           --   |ello! |
                                           -- (shortest list cuts off)

         ((.|.).).xor                      -- the function to zip with is a
                                           -- point-free version of (x xor y) or z

toEnum.a<$>                                -- adjust every element >126 and convert
                                           -- back to characters

— nimi
সূত্র

4

পিএইচপি, 186 বাইট (এন সহ) | 177 বাইট (অসীম)

দেখা গেল যে অসীম মুদ্রণটি ছোট ...

// With n
function x($s,$n){while($n-->=0){for($i=0,$r='';$i<strlen($s);$i++){$b=ord($s[$i-1])or$b=32;$a=ord($s[$i+1])or$a=32;$t=($b^ord($s[$i]))|$a;$r.=chr($t>126?($t%127)+32:$t);}$s=$r;}echo$s;}

// Infinite
function i($s){while(true){for($i=0,$r='';$i<strlen($s);$i++){$b=ord($s[$i-1])or$b=32;$a=ord($s[$i+1])or$a=32;$t=($b^ord($s[$i]))|$a;$r.=chr($t>126?($t%127)+32:$t);}echo$s=$r;}}

এন দিয়ে অবরুদ্ধ:

function x($s, $n) { // $s - string to process; $n - which string to output
  while ($n-- >= 0) {
    for ($i = 0, $r = ''; $i < strlen($s); $i++) {
      $b = ord($s[$i - 1]) or $b = 32;
      $a = ord($s[$i + 1]) or $a = 32;
      $t = ($b ^ ord($s[$i])) | $a;
      $r .= chr($t > 126 ? ($t % 127) + 32 : $t);
    }
  $s = $r;
  }
  echo $s;
}

অব্যক্ত অসীম:

function x($s) { // $s - string to process
  while (true) {
    for ($i = 0, $r = ''; $i < strlen($s); $i++) {
      $b = ord($s[$i - 1]) or $b = 32;
      $a = ord($s[$i + 1]) or $a = 32;
      $t = ($b ^ ord($s[$i])) | $a;
      $r .= chr($t > 126 ? ($t % 127) + 32 : $t);
    }
    echo $s = $r;
  }
}

— daavko
সূত্র

1

এটি এখনও অনেক গল্ফ করা যেতে পারে। উদাহরণস্বরূপ,

function i($s){for(;;$i=0,print$s=$r)for($r='';$i<strlen($s);$r.=chr($t>126?32:$t))$t=((ord($s[$i-1])?:32)^ord($s[$i]))|(ord($s[++$i])?:32);}

141 বাইট দীর্ঘ (-36 বাইট)।

— ব্ল্যাকহোল

2

সি ++

নবম-সিকোয়েন্স (212)

void x(char*s,int l,int n){for (;n-->0;) {char*t=new char[l-1](),w;for(int i=0;i<l-1;i++)t[i]=((w=(((i-1>= 0)?s[i-1]:32)^s[i])|((i+1<l-1)?s[i+1]:32))>126)?((w%127)+32):w;for(int i=0;i<l-1;i++)s[i]=t[i];delete[]t;}}

আন Golfed

void x(char*s, int l, int n){
    for (;n-- > 0;) {
        char*t=new char[l-1](),w;
        for(int i = 0;i < l-1; i++)
            t[i] = ((w = (((i-1>= 0) ? s[i-1] : 32)^s[i]) | ((i+1 < l-1) ? s[i+1] : 32)) > 126) ? ((w % 127) + 32) : w;

        for(int i = 0; i < l-1; i++)
            s[i] = t[i];
        delete[]t;
    }
}

এগুলি আরও বিভ্রান্ত করার জন্য অ্যারে সিনট্যাক্সের পরিবর্তে পয়েন্টার সিনট্যাক্স ব্যবহার করে এনথ-সিকোয়েন্স: (২৩১)

void x(char*s,int l,int n){for(int x=0;x++<n;) {char*t=new char[l-1](),w;for(int i=0;i<l-1; i++)*(t+i)=((w=(((i-1>= 0)?*(s+i-1):32)^*(s+i))|((i+1<l-1)?*(s+i+1):32))>126)?((w%127)+32):w;for(int i=0;i<l-1;i++)*(s+i)=*(t+i);delete[]t;}}

আন Golfed

void x(char* s, int l, int n){
    for (;n-- > 0;) {
        char*t = new char[l-1](),w;
        for(int i = 0; i < l-1; i++)
            *(t+i) = ((w = (((i-1>= 0) ? *(s+i-1) : 32)^ *(s+i)) | ((i+1<l-1) ? *(s+i+1) : 32)) > 126) ? ((w%127)+32) : w;

        for(int i = 0;i < l-1; i++)
            s[i] = t[i];
        delete[]t;
    }
}

ডিবাগ ফাংশন (মজাদার জন্য)

void d(char* seed, int len, int nth) {
    for (int n = 0; n++ < nth;) {
        char* tout = new char[len - 1]();
        for (int i = 0; i < len - 1; i++) {
            char x, y, z;
            x = ((--i >= 0) ? seed[i] : 32);
            y = seed[++i];
            z = ((++i < len - 1) ? seed[i] : 32);
            char w = (x ^ y) | z;
            tout[--i] = (w > 126) ? ((w % 127) + 32) : w;

            cout << "[" << x << " " << y << " " << z << "] " << w << endl;
        }

        for (int i = 0; i < len - 1; i++)
            seed[i] = tout[i];
        delete[] tout;
        cout << endl;
    }
}

— FatalSleep
সূত্র

1

অত্যন্ত নিশ্চিত যে ফলাফলগুলি বলেছে আপনাকে অবশ্যই ফলাফলটি আউটপুট করতে হবে , কেবল এটি ফেরত দেওয়া হবে না।

— মাকিং হাঁস

1

আমি আপনার তুলনায় স্ক্র্যাচ থেকে একটি সি ++ সংস্করণ লিখেছিলাম এবং তারপরে সেগুলি একীভূত করেছি এবং এটি পেয়েছি, 158 বাইটে: coliru.stacked-crooked.com/a/838c29e5d496d2a6

— মূক হাঁস

নিবন্ধন করুন সংকলক দ্বারা

— সিটিতে

অবশ্যই, এগিয়ে যান! আপনি ইতিমধ্যে সেই কোডটির অর্ধেক লিখেছেন

— কোডটির মাকিং হাঁস

2

জাভা 240/280 বাইট

আমি এটি লেখার সময় জনপ্রিয় জাভা সংস্করণটি 185 বাইট বলে দাবি করেছে, তবে দুটি উল্লেখযোগ্য ফজ পয়েন্ট রয়েছে। প্রথমত, পরিমাপটি সম্ভবত কার্যকারণের জন্য, সম্পূর্ণ কার্যক্ষম উত্সের জন্য নয়। এ জাতীয় সমস্যা নাও হতে পারে। দ্বিতীয়ত, এটি আমদানি বা সম্পূর্ণরূপে যোগ্যতাসম্পন্ন নাম ব্যতীত BiFunction ব্যবহার করে। এটি যেমন রয়েছে তে চালানোর জন্য প্রয়োজনীয় বিট যুক্ত করা (তারপরে এটি হ্রাস করুন, মোটামুটি) এটিকে 348 বাইটে এনেছে। বায়ফিউশন ক্লাসের কেবলমাত্র যোগ্যতাসম্পন্ন যোগ্যতাসম্পন্ন নাম যুক্ত করা এটি 248 বাইটে নিয়ে আসে।

বিপরীতে, আমি বিশ্বাস করি যে একই নিয়মগুলি (কোনও শ্রেণি, কোনও আসল আউটপুট নয়, কেবল মাংস নয়) খেলে আমার খনি 240 বাইট। পূর্ণ রান্নেবল ক্লাসটি 280 বাইট, এবং দেখতে এটি (অবিস্মরণিত):

class z{
  public static void main(String[] s){
    int L=s[0].length();
    for(int G=Integer.valueOf(s[1]);G-->0;){
      s[1]="";
      for(int N=0;N<L;N++){
        char C=(char)((N>0?s[0].charAt(N-1):' ')^(s[0].charAt(N))|(N<L-1?s[0].charAt(N+1):' '));
        s[1]+=C>126?' ':C;
      }
      System.out.println(s[1]);
      s[0] =s[1];
    }
  }
}

বা, মাইনযুক্ত:

void m(String[] s){int L=s[0].length();for(int G=Integer.valueOf(s[1]);G-->0;){s[1]="";for(int N=0;N<L;N++){char C=(char)((N>0?s[0].charAt(N-1):' ')^(s[0].charAt(N))|(N<L-1?s[0].charAt(N+1):' '));s[1]+=C>126?' ':C;}s[0]=s[1];}return s[0];}

— vrmxm
সূত্র

2

পার্ল, 47 বাইট

জন্য +2 অন্তর্ভুক্ত -lp

STDIN এ ইনপুট দিয়ে চালান, যেমন perl -lp xoror.pl <<< "Hello, World!" | head -26

xoror.pl:

/./s;$_=$_.chop^" $_"|"$' ";y/\x7f/ /;print;redo

এটি যেমন রয়েছে তেমন কাজ \x7fকরে তবে প্রদত্ত স্কোর পেতে সংশ্লিষ্ট বাইনারি মান দ্বারা প্রতিস্থাপন করুন

— টন হসপেল
সূত্র

1

সুইফট: 273 অক্ষর

বাহ, সুইফট জাভা থেকেও খারাপ! (দীর্ঘ নামের এই সমস্ত এপিআই! পি)

func c(s:String,n:Int=0-1){var a=[UInt8](s.utf8);for i in 0...(n>=0 ?n:Int.max-1){var z="";for i in 0..<a.count{let A=i-1<0 ?32:a[i-1],B=a[i],C=i+1<a.count ?a[i+1]:32;var r=A^B|C;r=r<32 ?32:r>126 ?32:r;z+=String(UnicodeScalar(r))};if n<0||i==n{print(z)};a=[UInt8](z.utf8)}}

Ungolfed:

func cellularAutoma(s: String,n: Int = -1)
{
    var array = [UInt8](s.utf8)
    for i in 0...(n >= 0 ? n : Int.max - 1)
    {
        var iteration = ""
        for i in 0..<array.count
        {
            let A = i - 1 < 0 ? 32 : array[i - 1], B = array[i], C = i + 1 < array.count ? array[i + 1] : 32
            var r = A ^ B | C
            r = r < 32 ? 32 : r > 126 ? 32 : r
            iteration += String(UnicodeScalar(r))
        }
        if n < 0 || i == n
        {
            print(iteration)
        }
        array=[UInt8](iteration.utf8)
    }
}

@ CAD97 ধন্যবাদউল্লেখ (A ^ B) | C কেবল 126 এর চেয়ে বড় হতে পারে it's

আমি আরও বুঝতে পেরেছিলাম যে আপনাকে A ^ B | C এর আশেপাশে প্রথম বন্ধনী প্রয়োজন নেই কারণ ওওরিংয়ের আগে এক্সওরিং করা হয়ে গেছে, যাতে আমার কয়েকটা বাইট সংরক্ষণ হয়।

— আপনি
সূত্র