पहचान सैंडपाइल का पता लगाएं

Question

यह सवाल एबेलियन सैंडपिल के बारे में है । पिछली चुनौती को पढ़ें और अधिक जानने के लिए यह संख्यात्मक वीडियो देखें ।

---

आकार का एक अबेलियन sandpile एन से n संख्या 0, 1, 2 और 3 (रेत के कणों की संख्या का प्रतिनिधित्व) युक्त एक ग्रिड है। दो सैंडलपिल्स को जोड़कर पहले तत्व द्वारा तत्व को जोड़ने का काम करता है, और फिर ऊपर जाने वाले किसी भी तत्व को टॉगल करना 3. जिस क्रम में आप टॉपलेस होते हैं वह कोई फर्क नहीं पड़ता, अंतिम परिणाम समान है। जब एक कोशिका 4 से घटती है और उसके प्रत्येक प्रत्यक्ष पड़ोसी में 1 की वृद्धि होती है। यह एक चेन रिएक्शन का कारण बन सकता है। यदि कोई सेल ग्रिड के किनारे पर है, तो कोई भी अनाज जो गायब होने के दौरान ग्रिड से गिर जाता है।

उदाहरण के लिए, मैं दो 3 जोड़ रहा हूँ 3 सैंडपाइल्स (एक बल्कि चरम श्रृंखला प्रतिक्रिया देते हुए):

3 3 3   1 2 1   4 5 4    4 6 4    6 2 6    6 3 6    2 5 2    4 1 4    4 2 4    0 4 0    2 0 2    2 1 2
3 3 3 + 2 1 2 = 5 4 5 -> 6 0 6 -> 2 4 2 -> 3 0 3 -> 5 0 5 -> 1 4 1 -> 2 0 2 -> 4 0 4 -> 0 4 0 -> 1 0 1
3 3 3   1 2 1   4 5 4    4 6 4    6 2 6    6 3 6    2 5 2    4 1 4    4 2 4    0 4 0    2 0 2    2 1 2

इस चुनौती में हम n sandpiles द्वारा सभी संभव n के सबसेट में रुचि रखते हैं । इस उपसमुच्चय में कोई भी सैंडपाइल होता है जिसे आप n- सैंडपेपर द्वारा सभी -3 s n में एक मनमाना सैंडपाइल जोड़कर प्राप्त कर सकते हैं । उदाहरण के लिए, बस ऊपर हमने देखा कि सबसेट में है, क्योंकि हमने इसे सभी -3 सैंडपाइल में कुछ जोड़कर प्राप्त किया है।212 | 101 | 212

अब इस सबसेट का एक दिलचस्प तत्व है: पहचान तत्व। यदि आप इस तत्व को लेते हैं और इसे सबसेट में किसी अन्य तत्व में जोड़ते हैं , तो योग अपरिवर्तित होता है। दूसरे शब्दों में, यह सैंडपाइल इस उपसमुच्चय के शून्य की तरह काम करता है । यह सिर्फ इतना होता है कि 212 | 101 | 2123 के सबसेट के लिए शून्य तत्व है। 3. उदाहरण के लिए:

2 2 2   2 1 2   4 3 4    0 5 0    2 1 2    2 2 2
2 2 2 + 1 0 1 = 3 2 3 -> 5 2 5 -> 1 6 1 -> 2 2 2
2 2 2   2 1 2   4 3 4    0 5 0    2 1 2    2 2 2

: अब यह आपकी चुनौती है दी n , के उप-समूह की पहचान तत्व को खोजने एन से n ग्रिड । प्रत्येक के लिए अपनी पसंद के पर्याप्त विपरीत के साथ एक अद्वितीय रंग असाइन करके 0, 1, 2, 3और n छवि द्वारा n को आउटपुट करके इसे आउटपुट करें। आपका कोड एक उचित आधुनिक पीसी पर एक मिनट के भीतर 50 से 50 मामले का उत्पादन करने में सक्षम होना चाहिए।

---

उदाहरण के लिए, 500 द्वारा 500 पहचान तत्व:

यहाँ नीला = 3, हरा = 2, लाल = 1, सफेद = 0. है, लेकिन आपको अपने उत्तर में इस रंग योजना का उपयोग करने की आवश्यकता नहीं है।

Comments

प्रतियोगियों को चेतावनी देने का एक शब्द: मैंने वर्णन किया कि समाधान क्या है, न कि इसकी गणना कैसे करें। आपका कोड एक मिनट से कम समय में 50 से 50 केस का उत्पादन करने में सक्षम होना चाहिए, इसलिए ब्रूट फोर्सिंग एक संभावना नहीं है। इसे हल करने के लिए एल्गोरिदम हैं, और मैं आपको उन्हें नहीं दे रहा हूं। यह जानबूझकर किया गया है। मुझे लगता है कि बहुत सी चुनौतियां आपको पहले से चबाए गए भोजन के साथ पेश करती हैं। मैं पहले जवाब में एक +100 का इनाम दूंगा जो मेरे विवेक पर एक बिल्डिन (आप, गणितज्ञ) की ओर देखते हुए समस्या का समाधान नहीं करता है।

— orlp

मुझे लगता है कि 500x500 पहचान की छवि यह कहने से लाभान्वित होगी कि प्रत्येक रंग किस संख्या से मेल खाता है।

— xnor

"पर्याप्त विपरीत" का गठन क्या है?

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

@ ConorO'Brien रंगों का कोई सेट जो पर्याप्त रूप से भिन्न हो। मैं इसे कुछ रंग माप के साथ 100% उद्देश्य बना सकता था, लेकिन मुझे लगता है कि यह ओवरकिल है। मुझे परवाह नहीं है अगर आप लाल, पीले, हरे, ग्रेस्केल या जो भी इस्तेमाल करते हैं, सिर्फ 4 रंगों के ग्रे का उपयोग न करें जो प्रत्येक% 1% के भीतर हैं (जैसे # 000000, # 000001, # 000002, # 000003)।

— 22

अहम मुझे विश्वास है कि यह प्रश्न अब इनाम के योग्य है। क्या मुझे +100 बोनस मिल सकता है? :)

— जंगहवान मिन

Answer 1

ऑक्टेव, 120 113 बाइट्स

function a=W(a);while nnz(b=a>3);a+=conv2(b,[t=[0 1 0];!t;t],'same')-b*4;end;end;@(n)imagesc(W((x=ones(n)*6)-W(x)))

अपने गणितज्ञ उत्तर में संदर्भ पत्र का लिंक प्रदान करने के लिए जंगवान मिन का धन्यवाद । स्टेवी ग्रिफिन
के लिए धन्यवाद मुझे 7 बाइट्स बचाए[any(any(x)) -> nnz(x)]

यहां दो फ़ंक्शन का उपयोग किया जाता है:

1. fमैट्रिक्स के स्थिरीकरण के लिए
2. एक अनाम फ़ंक्शन जो nइनपुट के रूप में लेता है और पहचान मैट्रिक्स दिखाता है।

इसे rextester पर आज़माएं! 50 * 50 मैट्रिक्स की पीढ़ी के लिए

मैट्रिक्स की गणना के लिए बीता हुआ समय 0.0844409 seconds:।

स्पष्टीकरण:

एक फ़ंक्शन पर विचार करें जो f मैट्रिक्स को स्थिर करता है पहचान पहचानने का कार्य बस है

f(ones(n)*6 - f(ones(n)*6)।

ones(n)*6इसका मतलब है कि 6 का * n मैट्रिक्स।

इसके लिए n=3:

M = [6 6 6
     6 6 6
     6 6 6];

परिणाम होगा f(M-f(M))

स्थिरीकरण समारोह के लिए 2 डी दृढ़ संकल्प का उपयोग कार्य को गति देने के लिए किया जाता है; प्रत्येक पुनरावृत्ति में हम bइनपुट मैट्रिक्स के समान आकार के साथ एक बाइनरी मैट्रिक्स बनाते हैं और इनपुट मैट्रिक्स के संगत तत्व> 3 होने पर इसे 1 पर सेट करते हैं। फिर हम निम्नलिखित मुखौटा के साथ बाइनरी मैट्रिक्स का 2 डी कनवल्शन लागू करते हैं

0 1 0
1 0 1
0 1 0

चार प्रत्यक्ष पड़ोसियों का प्रतिनिधित्व करना।
कनवल्शन का परिणाम मैट्रिक्स में जोड़ा जाता है और इससे 4 गुना बाइनरी मैट्रिक्स को घटाया जाता है।

मैट्रिक्स के सभी तत्व <= 3 होने तक लूप जारी रहा

Ungolfed संस्करण :

function a=stabilize(a)
    mask = [t=[0 1 0];!t;t];
    while any(any(b=a>3))
        a+=conv2(b,mask,'same')-b*4;
    end
end
n= 50;
M = ones(n)*6;
result = stabilize(M-stabilize(M));
imagesc(result);

Answer 2

मैथमेटिका, 177 157 135 133 बाइट्स

Colorize[f=BlockMap[⌊{l={0,1,0},1-l,l}#/4⌋~Total~2+#[[2,2]]~Mod~4&,#~ArrayPad~1,{3,3},1]&~FixedPoint~#&;k=Table[6,#,#];f[k-f@k]]&

एक नंबर लेता है n। आउटपुट पहचान सैंडपाइल है। 0 काला है, 1 हल्का ग्रे है, 2 मैजेंटा है, और 3 ब्लू-ग्रे है।

अफसोस की बात यह है कि, गणितज्ञ के पास इसके लिए बिलिन नहीं है ...

स्कॉट कोरी और डेविड पर्किंसन के पेपर में बताए गए एल्गोरिदम का उपयोग करता है ।

50x50 पहचान सैंडपाइल की गणना करने के लिए मेरे 5 वर्षीय लैपटॉप पर 91.7 सेकंड लगते हैं। मुझे विश्वास है कि एक उचित आधुनिक डेस्कटॉप कंप्यूटर 50% से अधिक तेज है। (मेरे पास अंत में एक तेज़ कोड भी है)।

व्याख्या

f= ...

फ़ंक्शन को परिभाषित करें f(इनपुट एक सैंडपाइल मैट्रिक्स है): एक फ़ंक्शन जो ...

BlockMap[ ... ]~FixedPoint~#&

... BlockMapऑपरेशन को दोहराता है जब तक कि आउटपुट नहीं बदलता है। BlockMapऑपरेशन: ...

---

#~ArrayPad~1

... 0 की एक परत के साथ इनपुट सरणी पैड ...

{3,3},1

... इसे 3x3 मैट्रिक्स में विभाजित करें, ऑफसेट 1 के साथ ...

⌊{l={0,1,0},1-l,l}#/4⌋~Total~2+#[[2,2]]~Mod~4&

... और प्रत्येक विभाजन के लिए, केंद्र सेल और केंद्र सेल वैल्यू मॉड 4 पर टॉप सैंड रेत अनाज की संख्या जोड़ें।

यानी का आउटपुट fइनपुट के स्थिर संस्करण है।

---

k=Table[6,#,#]

परिभाषित kएक के रूप में एन से n 6s की सरणी।

f[k-f@k]]

कंप्यूट f (k - f (k))।

Colorize[ ... ]

परिणाम पर रंग लागू करें।

तेज़ संस्करण (142 बाइट्स)

Colorize[r=RotateLeft;a=ArrayPad;f=a[b=#~a~1;b+r[g=⌊b/4⌋,s={0,1}]+g~r~-s+r[g,1-s]+r[g,s-1]-4g,-1]&~FixedPoint~#&;k=Table[6,#,#];f[k-f@k]]&

समान कोड, लेकिन इसके बजाय अंतर्निहित सूची रोटेशन का उपयोग करता है BlockMap। मेरे लैपटॉप पर 4.0 सेकंड में n = 50 की गणना करता है।

Comments

यह देखते हुए कि आपने समय सीमा की भावना का पालन किया (जानवर बल के बजाय एक वास्तविक एल्गोरिदम को लागू करना), और यह बहुत प्रशंसनीय है कि एक शक्तिशाली डेस्कटॉप कंप्यूटर 50% तेज है, मैं इसे अनुमति दूंगा। चूंकि यह बिल्ट-इन के बिना एक वास्तविक एल्गोरिथ्म को लागू करता है, इसलिए यह +100 बोनस के लिए योग्य है। हालांकि आपको इसके लिए इंतजार करना होगा, क्योंकि मैं अभी तक एक इनाम शुरू नहीं कर सकता।

— orlp

यह कहा जा रहा है, पायथन (एक कुख्यात धीमी भाषा) में इसे काफी तुच्छ तरीके से लागू करते हुए, केवल n = 50 के लिए ~ 2s लेता है। शायद आप इसे थोड़ा गति दे सकते हैं?

— orlp

@orlp पूरा हो गया, लेकिन यह मूल कोड से अधिक लंबा है। क्या मुझे तेज संस्करण को अपना मुख्य उत्तर बनाना चाहिए या क्या मैं इसे अंत में रख सकता हूं?

— जंगहवान मिन

जैसे यह ठीक है मुझे लगता है।

— orlp

Answer 3

पायथन 3 + नेम्पी + पीआईएल, 385 370 364 बाइट्स

import numpy as q,PIL.Image as w
n=int(input())
z=n,n
def r(p):
 while len(p[p>3]):
  for x,y in q.ndindex(z):
   if p[x,y]>3:
    p[x,y]-=4;p[x-1,y]+=x>0;p[x,y-1]+=y>0
    if~-n>x:p[x+1,y]+=1
    if~-n>y:p[x,y+1]+=1
s=q.full(z,6)
t=s.copy()
r(t)
i=s-t
r(i)
w.fromarray(q.uint8(q.array(q.vectorize(lambda x:[x//1*65]*3,otypes=[object])(i).tolist()))).save('i.png')

STDIN पर इनपुट लेता है। छवि को greyscale के रूप में आउटपुट करता है i.png। काला 0 से मेल खाता है, 1 से गहरा ग्रे, 2 से हल्का ग्रे, और 0 से सफेद है।

सूत्र का उपयोग करता है I = R(S - R(S)), जहां Iपहचान तत्व है, Sछक्के से भरा मैट्रिक्स है, और Rकमी फ़ंक्शन है।

मैं शायद कुछ बाइट्स को पायथन 2 पर स्विच करके बचा सकता हूं और कर from numpy import*रहा हूं, लेकिन (1) मेरे पास नम्पी को पायथन 2 पर स्थापित नहीं किया गया है और (2) कार्यक्रम को समाप्त नहीं कर रहा है from numpy import*।

Ungolfed:

import numpy as np
from PIL import Image

# Compute the identity element

n = int(input('Size of the sandpile: '))

def reduce_pile(sandpile):
  while any(element >= 4 for element in np.nditer(sandpile)):
    for x, y in np.ndindex((n, n)):
      if sandpile[x, y] >= 4:
        sandpile[x, y] -= 4
        if x > 0: sandpile[x - 1, y] += 1
        if y > 0: sandpile[x, y - 1] += 1
        if x < n - 1: sandpile[x + 1, y] += 1
        if y < n - 1: sandpile[x, y + 1] += 1

s = np.full((n, n), 6, dtype=np.int32)
s_prime = np.copy(s)

reduce_pile(s_prime)

identity = s - s_prime
reduce_pile(identity)

# Output it to identity.png as an image

colours = [[255, 255, 255], [255, 0, 0], [0, 255, 0], [0, 0, 255]]
img_array = np.vectorize(lambda x: colours[x], otypes=[object])(identity)
img_array = np.array(img_array.tolist(), dtype=np.uint8)

img = Image.fromarray(img_array)
img.save('identity.png')

Comments

आप पीआईएल के साथ एक छवि बनाने के बजाय डेटा का उपयोग करके scipyया matplotlibडेटा प्रदर्शित करने के लिए बाइट्स को बचाने में सक्षम हो सकते हैं ।

— orlp