Biham-मिडलटन-लेविन यातायात मॉडल एक आत्म आयोजन सेलुलर automaton कि सरलीकृत यातायात मॉडल है।

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

आपका कार्य इस मॉडल को एक एनीमेशन के रूप में कल्पना करना है। यहाँ कुछ अच्छे प्रदर्शन हैं।

इनपुट

0 और 1 के बीच एक फ्लोटिंग पॉइंट नंबर, घनत्व का प्रतिनिधित्व करता है, और दो ग्रिडर्स जो प्रदर्शित ग्रिड ऊंचाई और चौड़ाई का प्रतिनिधित्व करते हैं। मान लें कि इनपुट मान्य हैं, और उपयोगकर्ता इनपुट से किसी फ़ंक्शन या रीडिंग के पैरामीटर दोनों ठीक हैं।

उदाहरण: 0.38 144 89 (ऊपर की छवि से मेल खाती है)

उत्पादन

एक ग्रिड, कम से कम 80x80, जो चल रहे इस मॉडल के एनीमेशन को प्रदर्शित करता है। शुरुआत में, कारों को ग्रिड पर बेतरतीब ढंग से रखा जाता है, जब तक कि ग्रिड इनपुट घनत्व तक नहीं पहुंच जाता है, आधे लाल और आधे नीले रंग के साथ (जो कि ग्रिड वर्गों की कुल संख्या का घनत्व है, हालांकि आपको पसंद है)। घनत्व होना चाहिए यह मान चाहिए, जिसका अर्थ है कि आप प्रत्येक सेल को घनत्व के साथ एक संभावना के रूप में नहीं भर सकते। प्रत्येक चरण के लिए, एक प्रकार की कार या तो नीचे की ओर जाती है या दाईं ओर घूमती है, यदि वे किनारे पर जाती हैं। जिस प्रकार की कार चलती है वह प्रत्येक चरण को आगे बढ़ाती है। एनीमेशन को देखने योग्य बनाने के लिए, प्रत्येक चरण के बीच कम से कम 10 एमएस होना चाहिए।

नियम

जब तक वे एक-दूसरे और पृष्ठभूमि से अलग होते हैं, तब तक कारें किसी भी रंग या प्रतीक की हो सकती हैं, और प्रत्येक कार का प्रकार एक ही रंग या प्रतीक है।
कंसोल और ग्राफिकल आउटपुट दोनों की अनुमति है। कंसोल आउटपुट के लिए, कोई प्रिंट करने योग्य प्रतीक ठीक है, लेकिन आउटपुट वर्णों के ग्रिड के रूप में होना चाहिए।
कृपया निर्दिष्ट करें कि यदि आपके पास स्क्रीनशॉट या जीआईएफ नहीं है तो आप किस तरह का उत्पादन करते हैं।
अनुकरण हमेशा के लिए चलना चाहिए।

आउटपुट थोड़ा जटिल है, इसलिए यदि आपके कोई प्रश्न हैं, तो कृपया टिप्पणी करें।

— qwr
स्रोत

एनीमेशन को धीरे-धीरे या जल्दी से कैसे चलाने पर कोई प्रतिबंध?

— xnor

शायद यह निर्दिष्ट करने के लायक है कि कार का प्रकार जो प्रत्येक चरण को स्थानांतरित करता है।

— ग्रेग मार्टिन

@ एक्सनोर मैं कम से कम 5 या 10 एमएस प्रति लूप सोच रहा था, लेकिन मुझे यकीन नहीं है कि अगर इसे मापना मुश्किल होगा।

— qwr

3

क्या घनत्व का मतलब यह है कि घनत्व का वह मान होना चाहिए, या सिर्फ इतना है कि प्रत्येक पिक्सेल में संभावना भरा होना चाहिए? इसके अलावा, क्या हमें कारों के रंग को बेतरतीब ढंग से असाइन करना है या नहीं? यदि बेतरतीब ढंग से, फिर से यह ठीक है अगर उनके पास सिर्फ 50-50 रंग होने की संभावना है?

— JAD

1

@JarkoDubbeldam घनत्व का मान होना चाहिए। उनके पास प्रत्येक रंग होने का 50-50 मौका है। हालाँकि मैंने उत्तर देर से दिया इसलिए उत्तर भिन्न हो सकते हैं। कारें ऊपर या बाईं ओर जा सकती हैं।

— qwr

5

आर, 350 338 293 291 273 268 264 बाइट्स

function(d,x,y){f=function(w){v=length(w);for(j in which(w>0&!w[c(2:v,1)]))w[c(j,j%%v+1)]=0:1;w};m=matrix(sample(c(rep(1,q<-floor(d*y*x/2)),rep(-1,q),rep(0,x*y-2*q))),x);p=animation::ani.pause;o=image;a=apply;repeat{o(m<-t(a(m,1,f)));p();o(m<--1*a(-1*m,2,f));p()}}

Ungolfed:

function(d,x,y){
  q=floor(d*y*x/2)

  m=matrix(sample(c(rep(1,q),rep(-1,q),rep(0,x*y-2*q))),x)

  f=function(w){
    v=length(w)
    for(j in which(w>0&!w[c(2:v,1)])){
      w[c(j,j%%v+1)]=0:1
    }
    w
  }


  library(animation)
  repeat{
    m=t(apply(m,1,f))
    image(m)
    m=-1*apply(-1*t(m),2,f))
    ani.pause()
    image(m)  
    ani.pause()
  }
}

फ़ंक्शन जो 3 तर्क लेता है: dघनत्व और आयाम के रूप में x,y। qप्रत्येक रंग में कारों की संख्या है। mकारों के साथ मैट्रिक्स है, जो शुरू में कारों और खाली स्थानों की संख्या का एक यादृच्छिक प्रकार लेकर भरा जाता है। कारें 1या तो हैं -1, खाली जगह है 0।

fएक फ़ंक्शन है जो कारों को एक पंक्ति में ले जाता है, कारों को कोडित के रूप में देखता है 1। यह जाँच करता है कि कार 1एस द्वारा पीछा करने से आगे बढ़ सकती है या नहीं 0। हम प्रत्येक पंक्ति या स्तंभ पर applyचलने के लिए उपयोग करते हैं f, जो कारों पर निर्भर करता है।

fहैंडल चलती 1कारों स्थानांतरित करने के लिए, -1, कारों, हम मैट्रिक्स स्थानांतरित चाल की दिशा chaninging द्वारा मैट्रिक्स गुणा -1, इसलिए -1कारों बन1 हैं, और vv और परिणामस्वरूप मैट्रिक्स फिर से बदल जाता है।

यह imageतीन मानों के लिए 3 डिफ़ॉल्ट रंगों का उपयोग करके, प्लॉट बनाने के लिए उपयोग करता है। animationडिफ़ॉल्ट विकल्प का उपयोग करके एनिमेशन को संभालने के लिए पैकेज का उपयोग करता है , जो कि 1 एफपीएस है।

0.38, 144, 89:

0.2, 144, 89:

0.53, 144, 89:

— JAD
स्रोत

आपका एनीमेशन वास्तव में अच्छा लग रहा है - आपने किस घनत्व का उपयोग किया? लगता है जैसे पूरी जगह बहुत खाली जगह के साथ बहुत जल्दी जाम हो गई

— qwr

@qwr वास्तव में ऐसा कुछ था जो मुझे परेशान कर रहा था। मेरे कार्यक्रम में पूरी बात आपके द्वारा जुड़े उदाहरण की तुलना में कम घनत्व पर जाम हो जाती है। मुझे प्लॉट के लिए उपयोग किए गए सटीक पैरामीटर याद नहीं हैं, हालांकि यह 0.38 144 89उदाहरण से बहुत अच्छी तरह से हो सकता है ।

— JAD

चौकोर ग्रिडों के साथ खेलने पर मुझे जैसॉन्डावीज़ / बीएमएल /#0.35/100/100 को जाम करने के लिए 0.35 का घनत्व मिला, लेकिन यह पतली तिरछी रेखाओं के बजाय लगभग हमेशा एक मोटी 45 डिग्री लाइन है। चूँकि आपकी लाइनें अधिक खड़ी दिखती हैं इसलिए मुझे लगता है कि दो प्रकार की कारों के साथ कुछ बंद है

— qwr

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

— qwr

आह, यह करना होगा।

— JAD

5

गणितज्ञ, 237 228 203 198 181 बाइट्स

(b=RandomSample@ArrayReshape[Table[{0,i=2},##/2],{1##2},1]~Partition~#2;Dynamic@Colorize[i=-i;b=CellularAutomaton[{193973693,{3,{a=0{,,},{3,9,1},a}},{1,1}},b];If[i>0,b,2-b]])&

आउटपुट एक गतिशील है Image। पृष्ठभूमि हल्के हरे रंग की है, और कारें उनकी दिशा के आधार पर काली या मैजेंटा हैं।

व्याख्या

b=RandomSample@ArrayReshape[Table[{i=1,2},##/2],{1##2},1]~Partition~#2

प्रारंभिक बोर्ड बनाएँ:

Table[{0,i=2},##/2]

को सेट iकरें 2। एक बनाएँ Listकी {0, 2}, जिसकी लंबाई है मंजिल (घनत्व * चौड़ाई * ऊंचाई / 2) (दो से विभाजित क्योंकि {0, 2}लंबाई-2 है)।

ArrayReshape[ ... ,{1##2},1]

परिणामी 2-D List(2 x कुछ) को 1-D List(लंबाई = चौड़ाई * ऊँचाई) पर फिर से आकार दें। पैड 1यदि पर्याप्त मान नहीं हैं।

RandomSample@ ...

(छद्म-) परिणाम को बेतरतीब ढंग से क्रमबद्ध करें।

... ~Partition~#2

विभाजन जो लंबाई (चौड़ाई) में परिणत होता है।

b= ...

इसमें स्टोर करें b।

Dynamic@Colorize[i=-i;b=CellularAutomaton[{193973693,{3,{a=0{,,},{3,9,1},a}},{1,1}},b];If[i>0,b,2-b]]

एक बनाएँ Dynamic Image:

i=-i;

का चिन्ह पलटें i।

b=CellularAutomaton[{193973693,{3,{a=0{,,},{3,9,1},a}},{1,1}},b]

शासन के साथ सेलुलर automaton लागू करें 193973693और पड़ोसी वजन {{0, 0, 0}, {3, 9, 1}, {0, 0, 0}}करने के लिए bस्थानांतरित कर। bउसके बराबर सेट करें ।

If[i>0,b,2-b]

यदि iसकारात्मक है, तो bअकेला छोड़ दें । यदि नहीं, तो स्थानांतरित करें b( 2-वहाँ है क्योंकि मैं CellularAutomatonथोड़ा सा गोल्फ है )। अनिवार्य रूप से, यह bहर दूसरे पुनरावृत्ति को स्थानांतरित करता है (ट्रांसपोशन को पूर्ववत करने के लिए)

Colorize[ ... ]

सरणी को रंगीन में परिवर्तित करें Image।

Dynamic@ ...

अभिव्यक्ति करें Dynamic । अर्थात उपरोक्त कार्य बार-बार चलाए जाते हैं।

उत्पादन

यहां एक नमूना आउटपुट (इनपुट: 0.35, 192, 108 2000 फ्रेम (बढ़ाई 2x) के लिए :) है।

https://i.imgur.com/zmSyRut.mp4

— जंगहवान मिन
स्रोत

हुह, निर्मित में इसका उपयोग नहीं करने की तुलना में लंबा है ?!

— आदम

3

डायलॉग एपीएल , 190 108 115 112 बाइट्स

समाधान

S←{⍉⍣⍺⊢d[⍺]↑d[⍺]↓⍉↑(⍺⊃'(↓+) ' '(→+) ')⎕R' \1'↓(,⍨,⊢)⍉⍣⍺⍉⎕←⍵⊣⎕DL÷4}
{1S 0S⍵}⍣≡' ↓→'[d⍴{⍵[?⍨⍴⍵]}c↑1 2⍴⍨⌊⎕×c←×/d←⎕]

TryAPL ऑनलाइन (ऑनलाइन प्रतिबंधों के कारण थोड़ा संशोधित):

सेट करें ⎕IO←0, फ़ंक्शन एस को परिभाषित करें , और फिर एक यादृच्छिक 38% 14 × 29 ग्रिड, जी को परिभाषित और प्रदर्शित करें ।
एक कदम नीचे करो।
एक कदम दाईं ओर करें।
चरण 2 पर जाएं।

^{पिछले एल्गोरिथ्म का एनीमेशन, जो घनत्व की गारंटी नहीं देता था।}

व्याख्या

S←{सीधा फ़ंक्शन S परिभाषित करें (यहाँ दाईं से बाईं ओर समझाया गया है):

÷4 4 का पारस्परिक (0.25)

⎕DL प्रतीक्षा करें कि कई सेकंड (वास्तविक समय समाप्त हो जाता है)

⍵⊣ कि ⍵ (सही तर्क; ग्रिड) के पक्ष में त्यागें

⎕← उत्पादन है कि

⍉ पक्षांतरित

⍉⍣⍺ यदि ⍺ (बाएं तर्क; 0 = नीचे, 1 = दाएं) फिर से वापस स्थानांतरित करें

( फ़ंक्शन ट्रेन लागू करें (यहां बाएं से दाएं समझाया गया है):

,⍨ तर्क अपने आप में संलग्न है

, के लिए संलग्न है

⊢ अपने आप

)

↓ सूची की सूची में मैट्रिक्स विभाजित

( खोज रेगेक्स (यहां बाएं से दाएं समझाया गया है):

⍺⊃ निम्नलिखित दो में से एक को on (0 = डाउन / फर्स्ट, 1 = राइट / सेकंड) के आधार पर चुनें

'(↓+) ' '(→+) ' एक स्थान के बाद नीचे और बाएँ तीर क्रम

)⎕R' \1' पाया अनुक्रम के बाद एक स्थान के साथ बदलें

↑ मैट्रिक्स में सूचियों की मिक्स सूची

⍉ पक्षांतरित

d[⍺]↓ ड्रॉप "ऊंचाई" पंक्तियाँ अगर ⍺ (बाएं तर्क) 0 (नीचे) या "चौड़ाई" पंक्तियाँ हैं अगर ⍺ 1 (दाएं)

d[⍺]↑ फिर उस कई पंक्तियों को लें

⊢ गुजरना (विभाजक के रूप में कार्य करता है)

⍉⍣⍺ यदि, (बाएं तर्क; 0 = नीचे, 1 = दाएं)

}

' ↓→'[ स्ट्रिंग को अनुक्रमणित करें (यहां दाएं से बाएं की ओर समझाया गया है):

⎕ संख्यात्मक इनपुट (आयाम)

d← असाइन करें कि d

×/ आयामों को गुणा करें (कोशिकाओं की गिनती पाता है)

c←सी को असाइन करें

⎕× संख्यात्मक इनपुट (घनत्व) के साथ गुणा करें

⌊ नीचे घूमो

1 2⍴⍨ चक्रीय रूप से उस लंबाई तक एक और दो को दोहराएं

c↑ लंबाई सी तक , शून्य के साथ पैडिंग तक का विस्तार करें

d⍴ उपयोग घ (आयाम) नयी आकृति प्रदान करने

{ इस अनाम फ़ंक्शन को उस पर लागू करें (यहां बाएं से दाएं समझाया गया है):

⍵[ सही तर्क (शून्य, लोगों की सूची, और दो) द्वारा अनुक्रमित

?⍨ घसीटना सूचक तक

⍴⍵ तर्क की लंबाई

]

}

]

{ निम्नलिखित अनाम फ़ंक्शन लागू करें (बाएं से दाएं समझाया गया है):

0S⍵एस लागू करें के साथ 0 बाईं तर्क के रूप में (नीचे) और सही तर्क के रूप में ग्रिड

1S उस सही तर्क के रूप में, S को 1 (दाएं) के साथ बाएं तर्क के रूप में लागू करें

}⍣≡ जब तक दो क्रमिक पुनरावृत्तियां समान नहीं होती हैं (ट्रैफ़िक जाम)

आवश्यकता है ⎕IO←0, जो कई प्रणालियों पर डिफ़ॉल्ट है।
(ऊंचाई, चौड़ाई), और फिर घनत्व के लिए संकेत।
किसी भी निर्मित ऑटोमेटन का उपयोग नहीं करता है।
अंतर्निहित regex समर्थन का उपयोग करता है।
ट्रैफिक जाम होने पर (कोई कार नहीं चल सकती) रुक जाती है।
आउटपुट कैरेक्टर मैट्रिसेस जहां →कारों को दायीं ओर ले जाने का ↓प्रतिनिधित्व करता है, नीचे जाने वाली कारों का प्रतिनिधित्व करता है, और रिक्त स्थान खाली सड़कें हैं।
ऊपर के रूप में, यह 4 हर्ट्ज पर सत्र के लिए आउटपुट करता है, लेकिन आवृत्ति को बदलकर समायोजित किया जा सकता है ÷4; उदा ÷33 हर्ट्ज है और .3z हर्ट्ज है।
यह देखना आसान है कि ]Box on -s=max -f=onपहले निष्पादित करने पर क्या चल रहा है ।
आवश्यक वितरण की अब गारंटी है, और दो प्रकार की कारें बिल्कुल 50-50 में होती हैं, गोलाई के लिए बचाती हैं।

— एडम
स्रोत

आपकी प्रारंभिक बोर्ड पीढ़ी इनपुट घनत्व वाले बोर्ड की गारंटी नहीं देती है। मुझे लगता है कि यह ओपी की पसंद है कि अनुमति दें या नहीं।

— जुन्गवान मिन

ओह, @JarkoDubbeldam ने पूछा कि पहले से ही।

— जंगवान मिन

@JungHwanMin कैसे? घनत्व डी होने दें। हर स्थिति को 0 और 1. के बीच मान मिलता है। यदि 0 और 0 के बीच यह a हो जाता है ↓। अगर d और d के बीच में हो तो a →। यदि d और 1 के बीच यह खाली रहता है।

— Adám

ठीक है, एक चरम मामला यह होगा: हर स्थिति किसी न किसी तरह से मान प्राप्त करती है 0(क्योंकि वे (छद्म) हैं) फिर आपका बोर्ड s से भरा हुआ है ↓।

— जंगहवान मिन

@JungHwanMin आह, मैं देख रहा हूं कि आपका क्या मतलब है।

— Adám

1

जावा (624 बाइट्स + जावा बाइट के लिए 18 बाइट्स। * = 642 बाइट्स)

static void k(double b,final int c,final int d){final int[][]a=new int[c+1][d+1];int i=0,j;for(;i<c;i++){for(j=0;j<d;j++){a[i][j]=Math.random()<b?Math.random()<0.5?1:2:0;}}Frame e=new Frame(){public void paint(Graphics g){setVisible(1>0);int i=0,j;for(;i<c;i++){for(j=0;j<d;j++){g.setColor(a[i][j]==2?Color.BLUE:a[i][j]==1?Color.RED:Color.WHITE);g.drawLine(i,j,i,j);}}for(i=c-1;i>=0;i--){for(j=d-1;j>=0;j--){if(a[i][j]==1&&a[i][(j+1)%d]==0){a[i][(j+1)%d]=1;a[i][j]=0;}else if(a[i][j]>1&&a[(i+1)%c][j]==0){a[(i+1)%c][j]=2;a[i][j]=0;}}}}};e.show();while(1>0){e.setSize(c,d+i++%2);try{Thread.sleep(400L);}catch(Exception f){}}}

Ungolfed:

static void k(double b,final int c,final int d){
        final int[][]a=new int[c+1][d+1];
        int i=0,j;
        for(;i<c;i++) {
            for(j=0;j<d;j++) {
                a[i][j]=Math.random()<b?Math.random()<0.5?1:2:0;
            }
        }

        Frame e=new Frame(){
            public void paint(Graphics g){
                setVisible(1>0);
                int i=0,j;
                for(;i<c;i++) {
                    for(j=0;j<d;j++) {
                        g.setColor(a[i][j]==2?Color.BLUE:a[i][j]==1?Color.RED:Color.WHITE);
                        g.drawLine(i,j,i,j);
                    }
                }
                for(i=c-1;i>=0;i--) {
                    for(j=d-1;j>=0;j--) {
                        if(a[i][j]==1&&a[i][(j+1)%d]==0){
                            a[i][(j+1)%d]=1;a[i][j]=0;
                        }else if(a[i][j]>1&&a[(i+1)%c][j]==0){
                            a[(i+1)%c][j]=2;a[i][j]=0;
                        }
                    }
                }
            }
        };
        e.show();
        while(1>0){e.setSize(c,d+i++%2);try{Thread.sleep(400L);}catch(Exception f){}}
    }

चित्र:

— जादू ऑक्टोपस Urn
स्रोत

जावा से परिचित नहीं हैं, लेकिन लाल, नीले और सफेद हैं जो आपके द्वारा उपयोग किए जाने वाले रंगों के सबसे छोटे नाम हैं? (शायद ग्रे एक विकल्प है, एक बाइट बनाम सफेद बचत)

— JAD

स्क्रीनशॉट उसी समस्या को प्रदर्शित करता है जैसा मैंने यहां बताया था कि codegolf.stackexchange.com/questions/104742/a-2d-traffic-jam/…

— qwr

एक 2 डी ट्रैफिक जाम

इनपुट

उत्पादन

नियम

आर, 350 338 293 291 273 268 264 बाइट्स

Ungolfed:

गणितज्ञ, 237 228 203 198 181 बाइट्स

व्याख्या

उत्पादन

डायलॉग एपीएल , 190 108 115 112 बाइट्स

समाधान

व्याख्या

टिप्पणियाँ

जावा (624 बाइट्स + जावा बाइट के लिए 18 बाइट्स। * = 642 बाइट्स)