वायरवर्ल्ड सेल्युलर ऑटोमेटन का अनुकरण करें


24

वायरवर्ल्ड एक कोशिकीय ऑटोमोबोन है जिसे तारों के माध्यम से बहने वाले इलेक्ट्रॉनों के सदृश बनाया गया है। इसके सरल यांत्रिकी डिजिटल सर्किट के निर्माण की अनुमति देते हैं। इसने संपूर्ण कंप्यूटर के निर्माण की अनुमति भी दे दी है ।

आपका मिशन अपनी पसंद की भाषा में सबसे छोटा वायरवर्ल्ड कार्यान्वयन बनाना है।

ग्रिड की प्रत्येक कोशिका में चार में से एक अवस्था होती है। चार राज्य "रिक्त," "तांबा," "इलेक्ट्रॉन सिर," या "इलेक्ट्रॉन पूंछ" हैं।

  • एक रिक्त कक्ष हमेशा एक रिक्त कक्ष रहेगा
  • एक इलेक्ट्रॉन सिर हमेशा एक इलेक्ट्रॉन पूंछ बन जाएगा
  • एक इलेक्ट्रॉन पूंछ हमेशा तांबा बन जाएगी
  • एक तांबे की कोशिका इलेक्ट्रॉन सिर बन जाएगी यदि ठीक उसके आठ पड़ोसियों में से एक या दो इलेक्ट्रॉन प्रमुख हैं, अन्यथा यह तांबे का बना रहेगा

इस प्रतियोगिता में शॉर्टेस्ट गेम ऑफ लाइफ प्रतियोगिता के समान शैली होगी , लेकिन कुछ बदलावों के साथ।

  • ग्रिड 40 कोशिकाओं द्वारा कम से कम 40 होना चाहिए
  • ग्रिड के किनारों को चारों ओर नहीं लपेटना चाहिए (टोरस नहीं)। लगातार "रिक्त" होने के रूप में क्षेत्र के बाहर कोशिकाओं का इलाज करें।
  • उपयोगकर्ताओं के लिए अपने स्वयं के शुरुआती कॉन्फ़िगरेशन को दर्ज करना संभव है।
  • खाली स्क्रीन पर घूरना मजेदार नहीं है। कार्यक्रम को अनुकरण के रूप में नेत्रहीन प्रदर्शित करना चाहिए।

यह कोड गोल्फ है, सबसे कम बाइट्स जीतता है।

जवाबों:


6

APL, Dyalog (131)

{h t c←1↓⍵∘=¨F←' htc'⋄⎕SM∘←1 1,⍨⊂N←F[1+⊃+/H h(t∨c≠H←c∧S↑1 1↓1 2∊⍨⊃+/+/K∘.⊖(K←2-⍳3)∘.⌽⊂¯1⌽¯1⊖h↑⍨2+S←25 79)ר⍳3]⋄∇N⊣⎕DL÷4}↑{79↑⍞}¨⍳25

आउटपुट ⎕SMविंडो में प्रदर्शित होता है । अनुकरण अंतहीन चलता है। ग्रिड 79x25 है क्योंकि यह ⎕SMविंडो का डिफ़ॉल्ट आकार है । इलेक्ट्रॉन सिर है h, पूंछ है t, तांबा है c। कार्यक्रम 25 लाइनों के रूप में कीबोर्ड से शुरुआती कॉन्फ़िगरेशन पढ़ता है।

स्पष्टीकरण:

  • ↑{79↑⍞}¨⍳25: 79x25 ग्रिड पढ़ें
  • h t c←1↓⍵∘=¨F←' htc': तीन मेट्रिसेस प्राप्त करें, एक सिर के साथ, एक पूंछ के साथ और एक तांबे के साथ। इसके अलावा F को स्ट्रिंग पर सेट करें ' htc'

  • ⎕SM∘←1 1,⍨⊂N←F[1+⊃+/... ר⍳3]: "..." भाग तीन लंबाई का एक सदिश है, जहां तत्व क्रमशः नए सिर, पूंछ और तांबे को दर्शाने वाले मैट्रिक्स हैं। सिर 1 से गुणा किए जाते हैं, 2 से पूंछ, और तांबा 3 से, फिर हम इन मैट्रिसेस को एक साथ जोड़ते हैं और एक जोड़ते हैं, सूचकांकों का एक मैट्रिक्स देते हैं FNनया राज्य बन जाता है, इनपुट के समान प्रारूप में, और इसे ⎕SMऊपरी-बाएँ कोने से शुरू होने वाली स्क्रीन पर दिखाया जाता है ।

  • ¯1⌽¯1⊖h↑⍨2+S←25 79: hइसे दो पंक्तियों और स्तंभों द्वारा बढ़ाकर , फिर इसे एक दाईं ओर और एक नीचे घुमाकर रिक्त स्थान की सीमा जोड़ें ।

  • ⊃+/+/K∘.⊖(K←2-⍳3)∘.⌽⊂: मैट्रिक्स को सभी आठ दिशाओं में घुमाएं और फिर परिणामी मेट्रिसेस को एक साथ जोड़ते हुए, पड़ोसियों की राशि दें जो प्रत्येक स्थिति में प्रमुख हैं।

  • 1 2∊⍨: केवल उन पदों को 1 पर सेट करें जिनमें 1 या 2 पड़ोसी हैं।

  • S↑1 1↓: हमने जो सीमा पहले जोड़ी थी, उसे हटा दें।

  • H←c∧: नए प्रमुख वे सभी तांबे की कोशिकाएँ हैं जिनमें 1 या 2 सिर पड़ोसी हैं।

  • t∨c≠H: नई तांबे की कोशिकाएं सभी पुरानी पूंछ हैं, और सभी पुरानी तांबे की कोशिकाएं जो सिर नहीं बन गई हैं।

  • H h(... ): नए शीर्षों की Hगणना ऊपर की गई है, नई पूंछ पुराने प्रमुख हैं, और नए तांबे की कोशिकाओं की गणना ऊपर की गई है।

  • ∇N⊣⎕DL÷4: एक सेकंड का 1 / 4th इंतजार करें, फिर फ़ंक्शन को फिर से चलाएं N


मुझे लगता है कि यह बेहतर होगा यदि इसमें 40 से 40 ग्रिड हो सकते हैं।
mbomb007

6

ALPACA, 82 वर्ण

ALPACA एक भाषा है जिसे विशेष रूप से सेलुलर ऑटोमेटोन के लिए डिज़ाइन किया गया है।

ओ कुछ भी नहीं है; सी कंडक्टर है; ई इलेक्ट्रॉन है; टी इलेक्ट्रॉन की पूंछ है।

state o " ";
state c "c" to e when 1 e or 2 e;
state e "e" to t;
state t "t" to c.

इस भाषा को कब जारी किया गया था? क्या भाषा के लिए कोई लिंक हैं?
ऑप्टिमाइज़र

@Optimizer यहाँ तुम जाओ! मैंने भाषा नहीं बनाई।
DanTheMan

4
ठंडा। सही चुनौती के लिए सही भाषा ..
ऑप्टिमाइज़र

4

गोल्फस्क्रिप्ट ( 125 120 105 100 चार्ट )

n%{.,,{1${.0=,:w[1,*]\+2*>3<}:^~`{zip^''+.4=5%'`X '@{+}*(7&1>'iX'>+=}+w,%}%"\033[H\033[J"@n*+puts 6.?.?}do

ध्यान दें कि मैं \033प्रत्येक के रूप में एक वर्ण गिन रहा हूं , क्योंकि वे एक शाब्दिक ESCचरित्र द्वारा प्रतिस्थापित किए जा सकते हैं । यह एएनएसआई नियंत्रण कोड का उपयोग करता है, इसलिए एक संगत ट्टी पर निर्भर करता है। यह भी ध्यान दें कि फ़्रेम इनपुट ग्रिड से शुरू होता है।

जनरेट ऑफ सोम्स के साथ कुछ ओवरलैप है , जो मूर पड़ोस का भी उपयोग करता है।

एन्कोडिंग: रिक्त स्थान => ; इलेक्ट्रॉन सिर => i; इलेक्ट्रॉन पूंछ => `; तांबा => X

पुनरावृत्तियों के बीच ठहराव 46656 46656 की गणना के लिए आवश्यक समय है । 6.?.?दूसरी अभिव्यक्ति में परिवर्तन करने से आप गति को नियंत्रित कर सकते हैं; उसी वर्ण गणना के लिए अगला सबसे धीमा है 7.?.?, जो बहुत धीमा है (आउटपुट 22 गुना बड़ा है, और यह रैखिक जटिलता गणना नहीं है)।

एक परीक्षण मामले के लिए, मैं उपयोग कर रहा हूं

`iXXXXXXXXX
X   X      
   XXX     
X   X      
i`XX XXXXXX

रोसेटा कोड वायरवर्ल्ड चुनौती से।


3

पायथन 371 341 चार

हाँ, यह छोटा नहीं है, लेकिन इसमें एक इंटरैक्टिव गुई है!

import matplotlib.pylab as l,scipy.ndimage as i
r=round
w=l.zeros((40,40),int)-1
p=l.matshow(w,vmax=2)
c=p.figure.canvas
def h(e):
 try:w[r(e.ydata),r(e.xdata)]=[0,2,-1][e.button-1]
 except:x=i.convolve(w==2,l.ones((3,3)),int,'constant');w[:]=w/2+((w==0)&(x>0)&(x<3))*2
 p.set_data(w);c.draw()
c.mpl_connect('button_press_event',h)
l.show()

निर्देश:

तार लगाने के लिए बाईं माउस बटन के साथ क्लिक करें

साफ़ करने के लिए दाएं माउस बटन के साथ क्लिक करें

इलेक्ट्रॉन सिर रखने के लिए मध्य माउस बटन के साथ क्लिक करें

ऑटोमेटन को स्थानांतरित करने के लिए कुल्हाड़ियों के बाहर क्लिक करें


(x>0)&(x<3)-> (0<x<3)। :)
भालू ५०५

3

पायथन ( 243 214)

प्रयोज्य और पात्रों के बीच एक क्रॉस बनाने की कोशिश की। ग्रिड 40x40 है। स्टड पर इनपुट दिया गया है। एक इलेक्ट्रॉन सिर है h, इलेक्ट्रॉन पूंछ है t, तांबा है cऔर कुछ भी खाली है।

import os
f=raw_input()
while 1:f=''.join('h'if(i=='c')&(0<sum(1 for i in[-1,1,-39,-40,-41,39,40,41]if f[e+i:e+i+1]=='h')<3)else't'if i=='h'else'c'if i=='t'else f[e]for e,i in enumerate(f));os.system('cls');print f

लूप (पंक्ति 3) असम्पीडित (कोड में रखे जाने पर काम नहीं करेगा):

while 1:
 for e,i in enumerate(f):
  if(i=='c')&(0<sum(1 for i in[-1,1,-39,-40,-41,39,40,41]if f[e+i:e+i+1]=='h')<3):f[e]='h'
  elif i=='h':f[e]='t'
  elif i=='t':f[e]='c'
  else:f[e]=f[e]  #redundant, but Python needs this to run
 os.system('cls') #cls is shorter than clear, so I used that
 print f

मुझे लगता है कि आप एक ही अभिव्यक्ति के साथ लाइनों को 5-7 बदल सकते हैं g[e]='h'if(t=='c')&...else't'if i=='h'else'c'if i=='t'else i:। यकीन नहीं है कि अगर यह बिल्कुल वैसा ही काम करता है, लेकिन उन पंक्तियों के साथ कुछ काम करना चाहिए
स्ट्राइगोइड्स

2

सी, 355 347 300 294 चार्ट

संपादित करें: एहसास हुआ कि मुझे ज़रूरत नहीं है feof()

संपादित करें: सहेजे गए 47 वर्ण! नींद को हटा दिया, लगभग सभी ब्रेसिज़ से छुटकारा पा लिया, बहुत सारे ऑपरेशनों को मिला दिया।

संपादित करें: पिछले एक आज, जब से मैंने 300 चरों को तोड़ दिया। बदल printfगया puts, पहली तुलना के साथ एक प्यारा सा अनुकूलन मिला।

सी खुद को इस तरह की समस्या के लिए अच्छी तरह से उधार नहीं देता है, लेकिन हे, यह मजेदार है। यह एक बहुत ही क्रूर बल कार्यान्वयन है, लेकिन मैं यह देखना चाहता था कि मैं इसे कितना आगे बढ़ा सकता हूं।

इनपुट एक टेक्स्ट फाइल है जिसका नाम है i। इसमें प्रारंभिक अवस्था का प्रतिनिधित्व होता है, जिसमें *तांबे के लिए, +इलेक्ट्रॉन सिर के लिए, -इलेक्ट्रॉन पूंछ के लिए, खाली कोशिकाओं के लिए रिक्त स्थान होता है। मैं परीक्षण के लिए विकी पृष्ठ से XOR गेट का उपयोग कर रहा हूं।

   ****-+**
  +        ******
   -*******      *
                ****
                *  *****
                ****
   ********      *
  +        ******
   -****+-*

char*p,t[42][42],s[42][42];
main(i,r,c,n,j)
{
  for(p=fopen("i","r");fgets(s[i++]+1,40,p););

  for(;;getch(),memcpy(s,t,1764))
    for(j=1;j<41;puts(s[j++]+1))
      for(i=1;i<41;)
      {
        p=t[j]+i;
        r=s[j][i++];
        *p=r==43?45:r;
        if(r==45)
          *p=42;
        if(r==42)
          for(r=-1,n=0;r<2;++r,*p=n&&n<3?43:42)
            for(c=-2;c<1;)
              n+=s[j+r][i+c++]==43;
      }
}

cond?43:42लिखा जा सकता है 42+(cond)? और मुझे यकीन है कि नहीं तो r=s[j][i++];*p=r==43?45:r;if(r==45)*p=42;कम किया जा सकता r=s[j][i++];*p=r==43?45:r==45?42:r;हैr=s[j][i++]-43;*p=!r?45:r==2?42:r;
पीटर टेलर

1

पायथन, 234 218 वर्ण

import time
I=input
C=I()
H=I()
T=I()
R=range(40)
while 1:
 for y in R:print''.join(' CHT'[(C+H+2*T).count(x+y*1j)]for x in R)
 H,T=[c for c in C if 0<sum(1 for h in H if abs(c-h)<2)<3and c not in H+T],H;time.sleep(.1)

आप बोर्ड को तांबे की कोशिकाओं के निर्देशांक का प्रतिनिधित्व करने वाली जटिल संख्याओं की तीन सूची के रूप में इनपुट करते हैं (जिसमें हेड और टेल लिस्ट शामिल होना चाहिए), हेड और टेल। यहाँ एक उदाहरण है:

[3+2j+x for x in range(8)] + [3+4j+x for x in range(8)] + [11+3j+x for x in range(6)] + [2+3j]
[3+2j]
[2+3j]

ध्यान दें कि हम evalइनपुट करते हैं, ताकि आप जटिल संख्याओं की सूचियों के लिए मनमाने ढंग से जटिल अभिव्यक्तियों का उपयोग कर सकें।


1

QBasic, 309 बाइट्स

चेतावनी: गोल्फ संस्करण उपयोगकर्ता के अनुकूल नहीं है: इसमें एक अजीब इनपुट विधि है, एक अनंत लूप के रूप में चलती है, और इसमें कोई देरी नहीं है (इस प्रकार, कुछ प्रणालियों पर बहुत तेजी से चलता है)। इसे तभी चलाएं जब आप अपने QBasic वातावरण में किसी प्रोग्राम को समाप्त करना जानते हों। अनगुल्ड संस्करण की सिफारिश की जाती है (नीचे देखें)।

INPUT w,h
SCREEN 9
FOR y=1TO h
FOR x=1TO w
PSET(x,y),VAL(INPUT$(1))
NEXT
NEXT
DO
FOR y=1TO h
FOR x=1TO w
SCREEN,,0
c=POINT(x,y)
d=c
IF c=7THEN d=1
IF c=1THEN d=6
IF c=6THEN
n=0
FOR v=y-1TO y+1
FOR u=x-1TO x+1
n=n-(POINT(u,v)=7)
NEXT
NEXT
d=7+(n=0OR n>2)
END IF
SCREEN,,1,0
PSET(x,y),d
NEXT
NEXT
PCOPY 1,0
LOOP

चलाने के लिए, इनपुट पर निर्दिष्ट करें आपके कॉन्फ़िगरेशन की चौड़ाई wऔर ऊँचाई को संकेत दें h1 फिर w*hकोशिकाओं के लिए एकल-अंकीय कोड टाइप करें (बाएं से दाएं, फिर ऊपर से नीचे)

  • 0 = खाली
  • 6 = तार
  • 7 = संकेत प्रधान
  • 1 = सिग्नल टेल

एक बार जब आप सभी कोशिकाओं में प्रवेश कर जाते हैं, तो सिमुलेशन शुरू हो जाएगा (और हमेशा के लिए जारी रहेगा, जब तक आप प्रोग्राम को नहीं मारते)।

Ungolfed

एक अधिक उपयोगकर्ता के अनुकूल संस्करण। लेआउट को संशोधित करने के लिए, DATAअंत में बयानों को संशोधित करें ।

कोड POINTफ़ंक्शन का लाभ उठाता है , जो स्क्रीन से पिक्सेल का रंग मूल्य पढ़ता है। इसका मतलब है कि हमें एक सरणी के रूप में कोशिकाओं को अलग से संग्रहीत करने की आवश्यकता नहीं है। यह सुनिश्चित करने के लिए कि सभी सेल एक साथ अपडेट होते हैं, हम एक दूसरे "पेज" पर अपडेट करते हैं। हम SCREENकथन के एक संस्करण का उपयोग करके सक्रिय पृष्ठ को टॉगल कर सकते हैं , और कथन का उपयोग करके एक पृष्ठ की सामग्री को दूसरे में कॉपी कर सकते हैं PCOPY

SCREEN 9

EMPTY = 0 ' Black
HEAD = 7  ' Light gray
TAIL = 1  ' Blue
WIRE = 6  ' Brown/orange

' First two data values are the width and height
READ w, h
' The rest are the initial configuration, row by row
' Read them and plot the appropriately colored pixels
FOR y = 1 TO h
  FOR x = 1 TO w
    READ state$
    IF state$ = "" THEN value = EMPTY
    IF state$ = "H" THEN value = HEAD
    IF state$ = "T" THEN value = TAIL
    IF state$ = "W" THEN value = WIRE
    PSET (x, y), value
  NEXT x
NEXT y

' Loop the simulation until user presses a key
DO UNTIL INKEY$ <> ""
  ' Store current time for delay purposes
  t# = TIMER

  FOR y = 1 TO h
    FOR x = 1 TO w
      ' Active page = display page = 0
      SCREEN , , 0
      ' Get the color value of the pixel at x,y
      oldVal = POINT(x, y)
      IF oldVal = EMPTY THEN
        newVal = EMPTY
      ELSEIF oldVal = HEAD THEN
        newVal = TAIL
      ELSEIF oldVal = TAIL THEN
        newVal = WIRE
      ELSEIF oldVal = WIRE THEN
        neighbors = 0
        FOR ny = y - 1 TO y + 1
          FOR nx = x - 1 TO x + 1
            IF POINT(nx, ny) = HEAD THEN neighbors = neighbors + 1
          NEXT nx
        NEXT ny
        IF neighbors = 1 OR neighbors = 2 THEN
          newVal = HEAD
        ELSE
          newVal = WIRE
        END IF
      END IF
      ' Active page = 1, display page = 0
      SCREEN , , 1, 0
      ' Plot the new value on page 1
      PSET (x, y), newVal
    NEXT x
  NEXT y

  ' Copy page 1 to page 0
  PCOPY 1, 0

  ' Delay
  WHILE TIMER >= t# AND t# + 0.2 > TIMER
  WEND
LOOP

DATA 8,5
DATA T,H,W,W,W,W,W,W
DATA W, , , ,W, , , 
DATA  , , ,W,W,W, , 
DATA W, , , ,W, , , 
DATA H,T,W,W, ,W,W,W

1 चौड़ाई और ऊंचाई के लिए अधिकतम मूल्य इस बात पर निर्भर करते हैं कि स्क्रीन मोड का उपयोग किस प्रकार किया जाता है। में SCREEN 9, चौड़ाई 638 तक और ऊँचाई 348 तक हो सकती SCREEN 7है। एक छोटा रिज़ॉल्यूशन (अधिकतम कॉन्फ़िगरेशन आकार 318 198 तक) है, लेकिन पिक्सेल बड़े हैं और इस प्रकार (डॉस QBasic या DOSBox एमुलेटर पर) देखना आसान है - दुर्भाग्य से QB64 एक छोटी सी खिड़की देता है)।

उदाहरण चलाते हैं

पर Ungolfed संस्करण archive.org , स्क्रीन मोड 7 के साथ:

QBasic में वायरवर्ल्ड

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.