सैंडपाइल को टॉप करें

Question

^{( अनंत सैंडपेपर के बारे में संबंधित प्रश्न हैं , और सैंडपील के पहचान तत्वों को ढूंढना है ।)}

गैर-नकारात्मक पूर्णांक के एक मैट्रिक्स को देखते हुए, समान आयामों का एक मैट्रिक्स लौटाएं, लेकिन टॉपलेस :

1. यदि मैट्रिक्स में 4 से बड़ा कोई मान नहीं है, तो उसे लौटा दें।
2. प्रत्येक "सेल" जो 3 से बड़ा है, 4 से कम हो जाता है, और सभी सीधे पड़ोसी कोशिकाएं (ऊपर, नीचे, बाएं और दाएं) बढ़ जाती हैं, अगर वे मौजूद हैं।
3. गोटो १।

उदाहरण:

0 1 0        0 2 0
2 4 0   ->   3 0 1
0 0 3        0 1 3

1 2 3    2 3 4    2 5 1    4 1 2    0 3 3    0 3 3    0 3 3
4 5 6 -> 2 4 4 -> 4 2 3 -> 0 5 4 -> 3 2 1 -> 3 3 1 -> 3 3 2
7 8 9    5 7 7    2 6 5    4 3 2    0 5 3    1 1 4    1 2 0

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

एक गहरी व्याख्या और कुछ प्रेरणा के लिए इस नंबरफाइल वीडियो या एबेलियन सैंडपाइल मॉडल पर विकिपीडिया लेख देखें ।

नियम:

• आप किसी भी मानक तरीके से इनपुट और आउटपुट ले सकते हैं
• लूपोल्स वर्जित हैं
• इनपुट और आउटपुट हो सकता है:
  • एक नेस्टेड सूची: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  • एक साधारण सूची: [1, 2, 3, 4, 5, 6, 7, 8, 9]और आकार
  • देशी मैट्रिक्स प्रकार के कुछ प्रकार
  • a string, उदा 1 2 3\n4 5 6\n7 8 9
  • या जो कुछ भी आपकी भाषा में काम करता है।
• इनपुट और आउटपुट एक ही फॉर्म में होना चाहिए
• इनपुट में यहां दिखाए गए लोगों की तुलना में बड़ी संख्या हो सकती है, लेकिन आकार आपकी भाषा की सीमाओं से बाध्य हो सकता है (MAXINT समकक्ष, यदि लागू हो)
• मैट्रिक्स का कोई भी आकार हो सकता है (जैसे 1x1, 2x2, 3x3, 4x4, 2x7, 11x3, ...)
• आपको उस मामले को संभालने की आवश्यकता नहीं है जहां आकार 0xN या Nx0 है।

परीक्षण के मामलों

[[2, 5, 4], [8, 6, 4], [1, 2, 3]] -> [[3, 3, 0], [1, 2, 2], [1, 3, 2]]
[[0, 0, 2], [1, 3, 3], [0, 0, 0]] -> [[0, 0, 2], [1, 3, 3], [0, 0, 0]]
[[9, 9, 9], [9, 9, 9], [9, 9, 9]] -> [[1, 3, 1], [3, 1, 3], [1, 3, 1]]
[[4, 5], [2, 3]] -> [[2, 3], [0, 1]]
[[2, 3, 5], [2, 2, 0]] -> [[3, 0, 2], [2, 3, 1]]
[[7]] -> [[3]]

यह कोडगोल्फ है , सबसे छोटा कोड (प्रति भाषा) जीतता है।

Comments

क्या सभी मध्यवर्ती परिणाम प्रदर्शित करना ठीक है?

— feersum

@ फैर्सम मैं ऐसा अनुमान लगाता हूं, जब तक यह स्पष्ट है कि अंतिम परिणाम क्या है।

— L3viathan

Answer 1

MATL , 17 बाइट्स

tss:"t3>t1Y6Z+w4*-+

MATL ऑनलाइन पर यह कोशिश करो ! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

कार्यक्रम इनपुट के योग के रूप में कई बार के लिए पुनरावृति करता है। यह पुनरावृत्तियों की आवश्यक संख्या पर एक ढीली ऊपरी सीमा है।

प्रत्येक पुनरावृत्ति के लिए, सैंडपाइल मैट्रिक्स से अधिक की प्रविष्टियों का 3पता लगाया जाता है, जो मैट्रिक्स देता है 1और 0, जिसे 4-पड़ोसी मास्क के साथ सजाया जाता है। 3सैंडपाइल मैट्रिक्स में पार करने वाली प्रविष्टियाँ कम हो जाती हैं 4, और कनवल्शन का परिणाम जुड़ जाता है।

अंतिम पुनरावृत्तियों के लिए, जिसमें सैंडपाइल मैट्रिक्स की संख्या अधिक नहीं है 3, शून्य को इससे घटाया जाता है और इसे जोड़ा जाता है, इसलिए यह अप्रभावित है।

t       % Implicit input (matrix). Duplicate
ss      % Sum of matrix entries
:"      % Repeat that many times
  t     %   Duplicate
  3>    %   True for matrix entries that exceed 3
  t     %   Duplicate
  1Y6   %   Push predefined literal [0, 1, 0; 1, 0, 1; 0, 1, 0]
  Z+    %   2D convolution, keeping size
  w     %   Swap
  4*    %   Multiply by 4
  -     %   Subtract
  +     %   Add
        % Implicit end. Implicit display

Comments

कन्वेंशन हाई फाइव।

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

@MartinEnder आह, आपने भी इस्तेमाल किया है कि :-) एक साथी अपराधी को देखकर अच्छा लगा! मुझे यकीन है कि दोष जल्द ही हमारे साथ जुड़ जाएगा

— लुइस

@LuisMendo Convolutionista

— Suever

Answer 2

मैथेमेटिका, 65 बाइट्स

#//.s_:>s+ListConvolve[{v={0,1,0},1-v,v},x=UnitStep[s-4],2,0]-4x&

व्याख्या

#//.s_:>...&

बार-बार 3 से अधिक सभी बवासीर को गिराकर इनपुट को रूपांतरित करें। यह परिवर्तन स्वचालित रूप से बंद हो जाता है जब परिवर्तन मैट्रिक्स को बदलने में विफल रहता है (यानी जब कोई बड़ा ढेर मौजूद नहीं है)। निम्नलिखित अभिव्यक्ति में मैट्रिक्स को कहा जाता है s।

...x=UnitStep[s-4]...

एक मैट्रिक्स बनाएं, जिसमें 1जब भी वर्तमान मैट्रिक्स में एक 4या अधिक हो, और एक शून्य अन्यथा। यह अनिवार्य रूप से एक मुखौटा है जो इंगित करता है कि कौन से बवासीर को टॉप करने की आवश्यकता है। मास्क को बुलाओ x।

ListConvolve[{v={0,1,0},1-v,v},x=UnitStep[s-4],2,0]

पहले हम रेत की संख्या की गणना करते हैं जो कि पड़ोसी के ढेर के कारण प्रत्येक ढेर में जोड़ा जाता है। यह निम्नलिखित मैट्रिक्स ओवर के एक दृढ़ संकल्प के साथ किया जाता है x:

0 1 0
1 0 1
0 1 0

अनिवार्य रूप से, यह मास्क में अपने प्रत्येक वॉन-न्यूमैन पड़ोसियों के लिए वर्तमान सेल में एक जोड़ता है।

s+...-4x

हम पिछले परिणाम को इसमें जोड़ते हैं sऔर फिर हम इसमें से चार गुना मुखौटा घटाते हैं, जिससे पपड़ी के ढेर को कम किया जा सके।

Answer 3

ऑक्टेव, 65 बाइट्स

यह बहुत अच्छा नहीं लगता, मुझे कुछ ट्रिक्स याद आ रही हैं ...

m=input(0);do;m+=conv2(m>3,[0 1 0;1 -4 1;0 1 0],"same")
until m<4

Comments

ऑक्टेव के कौन से संस्करण का आप उपयोग कर रहे हैं input(0)?

— Suever

@ सेवर>> version ans = 4.0.1

— मर्स

Answer 4

जावास्क्रिप्ट (ईएस 6), 101 95 बाइट्स

मैट्रिक्स की चौड़ाई wऔर aसिंटेक्स में करीकरण में मूल्यों की एक सरणी लेता है (w)(a)। मानों की एक सरणी देता है।

w=>g=a=>(b=a.map((n,i)=>n%4+(F=d=>~m|i%w&&a[i+d]>>2)(m=w)+F(-w)+F(m=-1)+F(!++i)))+0==a+0?a:g(b)

प्रारूपित और टिप्पणी की गई

w =>                      // main function: takes w as input, returns g
  g = a =>                // recursive function g: takes a as input
    (                     //
      b = a.map((n, i) => // for each element n at position i in a:
        n % 4 + (         //   keep only n MOD 4
          F = d =>        //   define F(): function that takes d as input
            ~m |          //     if m is not equal to -1
            i % w &&      //     or i MOD w is not null:
            a[i + d] >> 2 //       return a fourth of the value of the cell at i + d
        )(m = w) +        //   test the cell below the current cell
        F(-w) +           //   test the cell above
        F(m = -1) +       //   test the cell on the left
        F(!++i)           //   test the cell on the right
      )                   // end of map(): assign the result to b
    ) + 0 == a + 0 ?      // if b is equal to a:
      a                   //   stop recursion and return a
    :                     // else:
      g(b)                //   do a recursive call with b

परीक्षण के मामलों

let f =

w=>g=a=>(b=a.map((n,i)=>n%4+(F=d=>~m|i%w&&a[i+d]>>2)(m=w)+F(-w)+F(m=-1)+F(!++i)))+0==a+0?a:g(b)

console.log(JSON.stringify(f(3)([2, 5, 4, 8, 6, 4, 1, 2, 3]))); // -> [3, 3, 0, 1, 2, 2, 1, 3, 2]
console.log(JSON.stringify(f(3)([0, 0, 2, 1, 3, 3, 0, 0, 0]))); // -> [0, 0, 2, 1, 3, 3, 0, 0, 0]
console.log(JSON.stringify(f(3)([9, 9, 9, 9, 9, 9, 9, 9, 9]))); // -> [1, 3, 1, 3, 1, 3, 1, 3, 1]
console.log(JSON.stringify(f(2)([4, 5, 2, 3]))); // -> [2, 3, 0, 1]
console.log(JSON.stringify(f(3)([2, 3, 5, 2, 2, 0]))); // -> [3, 0, 2, 2, 3, 1]
console.log(JSON.stringify(f(1)([7]))); // -> [3]

Answer 5

जावास्क्रिप्ट (ईएस 6), 118 114 104 बाइट्स

2 बाइट्स @Neil की बदौलत सहेजे गए

f=a=>a.find(b=>++y&&b.find(c=>++x&&c>3,x=0),y=0)?f(a.map(b=>b.map(c=>c+=--i|y?i*i+y*y==1:-4,i=x,--y))):a

Comments

(i-=x)|y-j?i*i+मदद करता है?

— नील

@ नील यह वास्तव में, धन्यवाद!

— ETHproductions

... मैं फोन पर था लेकिन मैं भी विचार कर रहा था a.find(...b.find(...c>3&&a.map(...)))&&f(a)।

— नील

@ नहीं मुझे नहीं लगता कि यह काम करेगा, क्योंकि .map

— म्यूट

ऐसा लगता है कि इसे म्यूट करने से लागत में बचत होती है और नक्शे को बचाने के लिए नक्शे के अंदर ले जाने से थोड़ा कम खर्च होता है:f=a=>a.find((b,x)=>b.find((c,y)=>c>3&&a.map(b=>b.map((_,j)=>b[j]+=x|(j-=y)?x*x+j*j==1:-4)&x--)))&&f(a)

— नील

Answer 6

सी ++, 261 258 250 बाइट्स

#import<vector>
#define S size()
void f(std::vector<std::vector<int>>&m){s:int i,j,r;for(i=r=0;i<m.S;++i)for(j=0;j<m[i].S;++j){if(m[i][j]>3){r=1;m[i][j]-=4;j>0&&m[i][j-1]++;i>0&&m[i-1][j]++;j<m[i].S-1&&m[i][j+1]++;i<m.S-1&&m[i+1][j]++;}}if(r)goto s;}

वैक्टर के एक वेक्टर के संदर्भ में इनपुट लेता है और इसे सीधे संशोधित करता है।

इसे ऑनलाइन आज़माएं!