23

सेलुलर ऑटोमेटा वास्तव में आकर्षक हैं। आमतौर पर जिन लोगों के बारे में बात की जाती है, वे द्विआधारी होते हैं, यानी, एक संख्या द्वारा प्रतिनिधित्व करने योग्य। हालांकि, मेरी राय में उन लोगों को मौत के घाट उतार दिया गया है। टर्नेरी सीए अधिक दिलचस्प हैं, लेकिन हमारे पास सभी ASCII पर विचार करने के लिए है! क्या मज़ा हो सकता है!

प्रत्येक चरित्र के लिए एक नियम तय करने के बजाय, मैं एक साधारण निर्णायक नियम का उपयोग करूंगा, जिसके बारे में मैं जल्द ही बात करूंगा। अगली पीढ़ी को तय करने के लिए, हम तीन "शीर्ष" कोशिकाओं को देखते हैं, एक सेलुलर ऑटोमेटा की तरह। एक उदाहरण देखें:

QWERTY
X Y Z

"ऊपर" Yहै WER, ऊपर-दाएं, ऊपर, और ऊपर-और बाईं ओर कोशिकाएं हैं। Y उस फ़ंक्शन का परिणाम होगा जो मैं परिभाषित करने वाला हूं, जो तीन-चार तारों पर एक फ़ंक्शन है। "शीर्ष" Xहै QW, या गैर-मौजूद / अनुपस्थित सेल में भरने वाला स्थान है ।

अब, ~~मज़ा~~ समारोह के लिए! मैं इस अनुक्रम को एक कारण के लिए XOROR अनुक्रम कहता हूं। चलो Aशीर्ष-बाएं सेल चारकोड Bहो, उपरोक्त सेल चारकोड हो, और Cशीर्ष-दाएं सेल चारकोड हो। फिर, जिसके परिणामस्वरूप सेल चरित्र जिसका charcode है (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 अनुक्रम कहा जाता है।

उद्देश्य आप एक प्रोग्राम या फ़ंक्शन लिखना चाहते हैं जो निम्नलिखित कार्यों में से एक है:

एक स्ट्रिंग sऔर एक संख्या को देखते हुए n >= 0, nस्ट्रिंग के पहले परिवर्तन होने के sसाथ, बीज के साथ XOROR अनुक्रम पर वें स्ट्रिंग को आउटपुट करें n = 0।
एक स्ट्रिंग s, आउटपुट (कार्यक्रमों के लिए) या उत्पन्न (कार्यों / जनरेटर के लिए) बीज के साथ XOROR अनुक्रम की एक अनंत धारा को देखते हुए s। यदि अनुक्रम दोहराता है तो आप रोकना चुन सकते हैं, लेकिन यह आवश्यक नहीं है।

s हमेशा प्रिंट करने योग्य ASCII वर्णों से मिलकर बनेगा, अंतरिक्ष से लेकर टिल्ड प्लस टैब (कोई नया अंक नहीं)।

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

— कोनोर ओ ब्रायन
स्रोत

मुझे वाक्य को पार्स करने में परेशानी हो रही है "तो, जो भी फ़ंक्शन मैं तीन-चार स्ट्रिंग पर परिभाषित करने वाला हूं, वह वाई बन जाएगा।" क्या इसे पुन: प्रस्तुत किया जा सकता है: "Y उस फ़ंक्शन का परिणाम होगा जिसे मैं परिभाषित करने वाला हूं, तीन-चार तार पर एक फ़ंक्शन।"

— १:59:59 बजे hYPotenuser

3

सभी oएस इसे एक ज़गुर रश की तरह बनाते हैं ।

— mbomb007

3

अवलोकन: चूँकि XOR और OR बिट्स की संख्या को संरक्षित करते हैं और सभी ASCII 7 बिट्स हैं, केवल एक मामला जब CHARCODE होता है> 126 है यदि यह 127 है। इसके बाद से, आप इसे एक स्थान (32) से बदल सकते हैं 127%127+32==32।

— सीएडी 97

2

n=0मूल स्ट्रिंग क्यों नहीं है?

— नील

3

@FatalSleep जैसा कि आप पहले शिकायत करते हैं, मैंने कहा कि, यदि कोई सेल मौजूद नहीं है, तो परिणाम एक स्थान है, इसलिए यह नहीं होगा (d^!)|(space)। जैसा कि आप दूसरे प्रश्न के लिए, आप XOROR के प्रदर्शन के (CHAR%127)+32 बाद करते हैं।

— कॉनर ओ'ब्रायन

4

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

— लुइस मेंडो
स्रोत

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 वैध राज्यों के साथ वास्तविक नियम संख्या पागल हो जाएगी।)

— मार्टिन एंडर

@ मार्टिनबटनर आप कर सकते हैं, लेकिन यह किनारों पर व्यवहार के लिए खाते में लाने की कोशिश कर रहा है, ताकि यह कल्पना के अनुरूप हो सके। BlockMap [] अभी छोटा था।

— hyPotenuser

7

जावा, 193 185 बाइट्स

क्योंकि जावा।

-8 बाइट्स को एक अनाम फ़ंक्शन बनाने के लिए बार-बार लूपिंग पर स्विच करने से

XOROR की n'th पुनरावृत्ति को s पर लौटाता है।

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

ऑपरेशन के एन बार लागू करने के लिए एक पुनरावर्ती लूप के साथ कल्पना का बहुत शाब्दिक कार्यान्वयन। कुछ बाइट्स बचाए गए थे, हालाँकि, मेरे अवलोकन से कि CHARCODE> 126 क्लॉज केवल CHARCODE == 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 !

— Vee

5

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

— मार्टिन एंडर
स्रोत

मुझे लगता है कि आप कुछ बाइट्स बचा सकते हैं 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

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

एन के साथ अनगढ़

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

सी ++

Nth-Sequence (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;
    }
}

यह सब और अधिक भ्रमित करने के लिए सरणी सिंटैक्स के बजाय सूचक सिंटैक्स का उपयोग करते हुए Nth-Sequence: (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;}}

संयुक्त राष्ट्र के 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-croched.com/a/838c29e5d496d2a6

— डक

@MooingDuck अच्छा लगा! सी। के माध्यम से संकलक द्वारा अंतर्निहित int के साथ संभवतः इसे और कम कर सकते हैं

— FatalSleep

बेशक, आगे बढ़ो! आपने पहले ही उस कोड का आधा भाग लिख दिया था

— मूइंग डक

2

जावा 240/280 बाइट्स

मैंने जिस समय यह लिखा था, उसमें लोकप्रिय जावा संस्करण 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];}

— 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 से अधिक हो सकता है जब यह 127 हो।

मुझे यह भी एहसास हुआ कि आपको A ^ B | C के आसपास कोष्ठक की आवश्यकता नहीं है क्योंकि XORing ओरिंग से पहले किया जाता है, जिससे मुझे कुछ बाइट्स की बचत हुई।

— आप
स्रोत