셀룰러 오토마타는 정말 매력적입니다. 일반적으로 이야기되는 것은 이진, 즉 숫자로 표현할 수있는 것입니다. 그러나 제 생각에는 그것들이 죽었습니다. 3 차 CA는 더 흥미롭지 만 모든 ASCII를 고려해야합니다! 얼마나 재밌 겠어요!

각 캐릭터에 대한 규칙 집합을 결정하는 대신 곧 이야기 할 간단한 결정 규칙을 사용합니다. 다음 세대를 결정하기 위해, 우리는 셀룰러 오토마타처럼 세 개의 "최상위"셀을 살펴 봅니다. 예를 살펴보십시오.

QWERTY
X Y Z

'상단은 "의이 Y인 WER상기 및 오른쪽, 위, 및 상기 좌우되는 세포. Y는 내가 정의하려는 함수의 결과이며, 이는 3 문자 문자열의 함수입니다. 은 "최고"의 X이다 QW, 또는 존재하지 않는 / 실종 셀의 공간 충전 .

이제 재미있는 기능을 위해 ! 이유를 위해이 시퀀스를 XOROR 시퀀스라고합니다. A왼쪽 B위 셀 문자 코드, 위 셀 문자 코드 및 C오른쪽 위 셀 문자 코드를 보자 . 그런 다음 결과 셀은 문자가 (A XOR B) OR C, 즉 인 문자입니다 (A^B)|C. 결과 값이 126보다 크면 값이로 설정됩니다 (CHARCODE % 127) + 32. 값이 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 시퀀스라고합니다.

목적 다음 작업 중 하나를 수행하는 프로그램이나 기능을 작성해야합니다.

1. 문자열이 주어 s와 숫자 n >= 0, 출력 n시드와 XOROR 번째 시퀀스에 문자열을 s가진 n = 0스트링의 변형 인 제.
2. 문자열이 주어지면 sseed를 사용하여 XOROR 시퀀스의 무한 스트림을 출력 (프로그램) 또는 생성 (함수 / 생성기)하십시오 s. 시퀀스가 반복되면 중지하도록 선택할 수 있지만 반드시 그럴 필요는 없습니다.

s 공백에서 물결표 + 탭 (줄 바꿈 없음)에 이르기까지 항상 인쇄 가능한 ASCII 문자로만 구성됩니다.

이것은 code-golf 이므로 바이트 단위의 가장 짧은 프로그램이 승리합니다.

MATL , 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

수학, 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]:

자바, 193 185 바이트

자바 때문이다.

익명 함수로 만들기 위해 되풀이하지 않고 반복으로 전환하여 -8 바이트

s에서 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));
}

연산을 n 번 적용하기 위해 재귀 루프가있는 스펙의 문자 그대로 구현. 그러나 일부 바이트는 저장되었지만 CHARCODE> 126 절은 CHARCODE == 127에서만 발생하므로 SPACE대신 저장 됩니다 DEL.

임의로 선택한 문자열을 통해 코드를 실행 하고이 멋진주기를 발견했습니다.

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

CJam, 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.
  }%
}*

하스켈, 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

PHP, 186 바이트 (n 포함) | 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;}}

n으로 ungolfed :

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

C ++

N 시퀀스 (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;}}

언 골프

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

배열 구문 대신 포인터 구문을 사용하여이 모든 것을 더 혼란스럽게 만드는 N- 시퀀스 : (231)

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

언 골프

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

디버그 기능 (Fun)

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

자바 240/280 바이트

필자가 작성한 당시 인기있는 Java 버전은 185 바이트라고 주장했지만 두 가지 중요한 퍼지 포인트가 있습니다. 첫째, 측정은 전체 작업 소스가 아닌 기능에 대해서만 수행됩니다. 아마도 그런 문제는 아닙니다. 둘째, 가져 오기 또는 정규화 된 이름없이 BiFunction을 사용합니다. 필요한 비트를 추가하여 그대로 실행하면 (그러면 최소화) 348 바이트가됩니다. BiFunction 클래스의 완전한 이름 만 추가하면 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];}

펄, 47 바이트

에 +2 포함 -lp

STDIN의 입력으로 실행 perl -lp xoror.pl <<< "Hello, World!" | head -26

xoror.pl:

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

이것은 그대로 작동하지만 \x7f주어진 점수를 얻으려면 해당 이진 값으로 바꿉니다.

스위프트 : 273 자

와우, 스위프트는 자바보다 나쁘다! (긴 이름을 가진 모든 API! : P)

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

언 골프 드 :

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는 127 일 때 126보다 클 수 있습니다.

또한 ORing 전에 XORing이 수행되므로 A ^ B | C 주위에 괄호가 필요하지 않으므로 몇 바이트를 절약 할 수 있습니다.