गिरने वाली चट्टानों की भविष्यवाणी करें

Question

इस चुनौती में, आपको एक दो-आयामी इलाके का एक नक्शा दिया जाता है, जिसे किनारे से देखा जाता है। दुर्भाग्य से, इलाके के कुछ हिस्से हवा में तैर रहे हैं, जिसका मतलब है कि वे दुर्घटनाग्रस्त हो जाएंगे। आपका काम यह भविष्यवाणी करना है कि वे कहाँ उतरते हैं।

इनपुट

आपका इनपुट समान लंबाई का एक या एक से अधिक न्यूलाइन-सेपरेटेड स्ट्रिंग्स है, जिसमें केवल वर्ण #(एक संख्या चिह्न, एक रॉक को सूचित करना) या .(एक अवधि, खाली स्थान को दर्शाता है) है।

उत्पादन

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

उदाहरण

• इनपुट

  ..###.
  .##.#.
  .#....
  .##.#.
  

  इसमें कोई ढीली चट्टानें नहीं हैं, इसलिए आउटपुट इसके समान है।

• इनपुट

  ...#..
  .#..#.
  .#..##
  .#...#
  .#####
  .#...#
  

  शीर्ष पर एक ढीली चट्टान होती है, जो इसके नीचे दृढ़ चट्टान पर गिरती है। आउटपुट है

  ......
  .#..#.
  .#..##
  .#.#.#
  .#####
  .#...#
  

• इनपुट

  .#####....
  .#....####
  ###.###..#
  #.#...##..
  .####..#.#
  ......###.
  ..#...#..#
  ..#...#..#
  

  बाईं ओर ढीली चट्टानों का एक बड़ा समूह है। चट्टानों के गिरने से समूह टूट जाता है, इसलिए उत्पादन होता है

  ..........
  ....######
  ..#.###..#
  . #...##..
  .##....#..
  .##...####
  ####..#..#
  #####.#..#
  

स्पष्टीकरण

• आप या तो STDIN से इनपुट ले सकते हैं और आउटपुट को STDOUT में ले सकते हैं, या एक फ़ंक्शन लिख सकते हैं।
• यह कोड-गोल्फ है, इसलिए सबसे छोटा कार्यक्रम (बाइट्स में) विजेता है।
• मानक खामियों को अस्वीकार कर दिया जाता है।

Comments

संबंधित: codegolf.stackexchange.com/questions/25834/gravity-controls

— Mhmd

Answer 1

सीजाम, 180 ... 133 101 ... 94 90 87 बाइट्स

qN/~'#/S*_,):L;]N*_,_,*{:A1$='#={[W1LL~)]Af+{W>},1$f=S&,{ASct}*}*}/N/z{S/{$W%}%'#*}%zN*

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

देखो मा! स्क्रॉलबार नहीं!

STDIN से चट्टानों का ग्रिड ( एक अनुगामी और नई अनुरेखिका के बिना) बनाया जाता है .और #STDOUT को आउटपुट प्रिंट करता है

अद्यतन : एक अकुशल लेकिन कम आंशिक बाढ़ का उपयोग करके फर्म चट्टानों का पता लगाना।

अद्यतन 2 : चट्टानों को नीचे गिराने के लिए एल्गोरिथ्म को बदल दिया। अभी बहुत छोटा है!

अद्यतन 3 : कई छोटे अनुकूलन किए और अंत में मैं मूल कोड के आधे तक बाइट की संख्या को नीचे लाने में सक्षम था!

यह कैसे काम करता है :

qN/~'#/S*_,):L;]N*             "Preparations";
qN/~                           "Read the input, split by new line and expand the array";
    '#/S*                      "In the last row, replace # by space";
         _,):L                 "Copy the last row and store length + 1 in L";
              ;]N*             "Pop the length, wrap everything in array and join by \n";

_,_,*{ ... }/                  "Flood fill";
_,                             "Copy the array and calculate its length";
  _,                           "Copy the length and calculate [0 - length] array";
    *                          "Repeat the above array, length times";
     { ... }/                  "Run the code block on each element of the array";

:A1$='#={ ... }*               "Process only #";
:A1$                           "Store the number in A and copy the input array to stack";
    =                          "Get Ath index element from input array";
     '#={ ... }*               "Run the code block if Ath element equals #";

[W1LL~)]Af+{W>},1$f=S&,{ASct}* "Flood fill spaces";
[W1LL~)]Af+                    "Get the indexes of the 4 elements on the cross formed by"
                               "the Ath index";
           {W>},               "Filter out the negative values";
                1$f=           "For each of the index, get the char from input string";
                    S&,        "Check if space is one of the 4 chars from above step";
                       {    }* "Run the code block if space is present";
                        ASct   "Make the Ath character of input string as space";

N/z{S/{$W%}%'#*}%zN*           "Let the rocks fall";
N/z                            "Split the resultant string by newlines and"
                               "transpose the matrix";
   {           }%              "Run the code block for each row (column of original)";
    S/{   }%                   "Split by space and run the code block for each part";
       $W%                     "Sort and reverse. This makes # come down and . to go up";
            '#*                "Join by 3, effectively replacing back spaces with #";
                 zN*           "Transpose to get back final matrix and join by newline";

फ्लडफिल के लिए, हम पूरे ग्रिड लंबाई (ग्रिड) के समय से पुनरावृति करते हैं। प्रत्येक पुनरावृत्ति में, हम कम से कम 1 को बदलने की गारंटी देते हैं #जो सीधे एक स्थान (स्पेस) को छू रहा है । यहां अंतरिक्ष एक दृढ़ चट्टान समूह का प्रतिनिधित्व करता है। इस प्रकार लंबाई (ग्रिड) पुनरावृत्तियों के अंत में, हमें रिक्त स्थान द्वारा दर्शाए गए सभी फर्म चट्टानों की गारंटी है।

इसे यहाँ ऑनलाइन आज़माएँ

Answer 2

पर्ल 5: 98

2 कमांड लाइन के झंडे सहित 98।

#!perl -p0
1while/
/,($x="($`)")=~y!#!.!,s/#(.*
$)/%$1/+s/#$x?%|%$x?#/%$1$2%/s;1while s/#$x\./.$1#/s;y!%!#!

स्पष्टीकरण:

#!perl -p0 #read entire input to $_ and print at the end
/\n/;($x="($`)")=~y!#!.!; #calculate pattern matching space
                          #between two characters in the same column
                          #looks like "(......)" 
1 while s/#(.*\n$)/%$1/+s/#$x?%|%$x?#/%$1$2%/s;
                          #flood fill solid rock with %
1 while s/#$x\./.$1#/s;   #drop loose rock
y!%!#!                    #change % back to #

Comments

@ ओप्टिमाइज़र I इनपुट की अंतिम पंक्ति पर निर्भर करता है ठीक से देखा जा रहा है: ideone.com/7E3gQh इस निर्भरता के बिना यह एक चार कुंवारा होगा (या अंतिम ईओएल की कमी के विपरीत एक छोटा भरोसा है)।

— नटकी

लगभग 30% से CJam की पिटाई? गजब का। मेरी ओर से आपको बधाई हो।

— DLosc

@ डलास अब और नहीं: पी

— ऑप्टिमाइज़र

अन्य अनिवार्य भाषाओं को 100-300% तक हराया? गजब का। मेरी ओर से आपको बधाई हो। ;)

— १

@ डॉक उपरोक्त उत्तर को देखते हुए, मैं पर्ल को अनिवार्य भाषाओं की सूची में शामिल नहीं करूंगा: P

— ऑप्टिमाइज़र

Answer 3

जावास्क्रिप्ट (ईएस 6) 232

s=>{for(s=[...s+'1'.repeat(r=1+s.search('\n'))];s=s.map((c,p)=>c=='#'&(s[p+1]|s[p-1]|s[p-r]|s[p+r])?f=1:c,f=0),f;);for(;s.map((c,p)=>c=='#'&s[p+r]=='.'&&(s[p]='.',f=s[p+r]=c),f=0),f;);return s.join('').replace(/1/g,rok).slice(0,-r)}

एक स्ट्रिंग पैरामीटर के साथ एक फ़ंक्शन के रूप में और एक स्ट्रिंग लौटाता है।

जमीनी रेखा की पहचान करने के लिए सबसे पहले '1' की एक निचली पंक्ति जोड़ें।
पहले लूप निश्चित चट्टानों के लिए खोज करते हैं (जो कि '1' के पास हैं) और उन्हें '1' के रूप में चिह्नित करता है। खोज तब तक दोहराई जाती है जब तक कि कोई और अधिक कठोर चट्टानें न मिलें।
दूसरा लूप शेष '#' वर्णों को नीचे की पंक्ति की ओर ले जाता है। फिर से, यह दोहराया जाता है जब तक कि कोई भी चट्टान को स्थानांतरित नहीं किया जा सकता है।
अंत में, '1' को '#' से फिर से बदलें और नीचे की पंक्ति को काटें।

कम गोल्फ वाला

s=>{
  r = 1+s.search('\n');
  s = [...s+'1'.repeat(r)];
  for (; s = s.map((c,p) => c=='#' & (s[p+1]|s[p-1]|s[p-r]|s[p+r])?f=1:c,f=0),f; );
  for (; s.map((c,p) => c=='#' & s[p+r]=='.'&& (s[p] ='.', s[p+r]=c, f=1),f=0),f; );
  return s.join('')
    .replace(/1/g,'#')
    .slice(0,-r)
}

परीक्षण (आपके पास इस बात के प्रमाण हो सकते हैं कि चट्टानें क्या हैं और क्या गिर गई हैं)

F=
s=>{for(s=[...s+'1'.repeat(r=1+s.search('\n'))];s=s.map((c,p)=>c=='#'&(s[p+1]|s[p-1]|s[p-r]|s[p+r])?f=1:c,f=0),f;);for(;s.map((c,p)=>c=='#'&s[p+r]=='.'&&(s[p]='.',f=s[p+r]=c),f=0),f;);return s.join('').replace(/1/g,rok).slice(0,-r)}

var rok // using rok that is 3 chars like '#'

function update() {
  rok = C.checked ? '@' : '#';
  O.textContent=F(I.textContent)
}

update()

td { padding: 5px }
pre { border: 1px solid #000; margin:0 }

<table><tr><td>Input</td><td>Output</td></tr>
<tr><td><pre id=I>.#####....
.#....####
###.###..#
#.#...##..
.####..#.#
......###.
..#...#..#
..#...#..#</pre></td>
<td><pre id=O></pre>
</td></tr></table>
<input type='checkbox' id=C oninput='update()'>Show firm rocks

Answer 4

एपीएल, १३० ११ ९

'.##'[1+⊖1↓⍉↑↑{,/{⍵[⍒⍵]}¨x⊂⍨2=x←2,⍵}¨↓ ⍉⊃⌈/(1,¨⍳⍴⊃↓x){x←⍵⋄(⍺⌷x)∧←2⋄x≡⍵:x⋄⊃⌈/((⊂⍴⍵)⌊¨1⌈(,∘-⍨↓∘.=⍨⍳2)+⊂⍺)∇¨⊂x}¨⊂⊖'#'=x←⎕]

चूँकि यह संभव नहीं है (जहाँ तक मुझे पता है) इनपुट के संकेत दिए जाने पर नई सूचियों में प्रवेश करने के लिए, यह प्रोग्राम इनपुट के रूप में एक वर्ण मैट्रिक्स लेता है।

उपयोग किया गया एल्गोरिथ्म पहले एक बाइनरी मैट्रिक्स में परिवर्तित हो रहा है ( 0हवा है और 1रॉक है) फिर नीचे की पंक्ति से बाढ़ भरने के रूप में फर्म चट्टानों को चिह्नित करना है 2। फिर प्रत्येक स्तंभ को "दृढ़ चट्टानों के बीच रिक्त स्थान" में विभाजित करें और ढीले चट्टान को "हवा के माध्यम से" गिरने के लिए प्रत्येक विभाजन को सॉर्ट करें।

Edit1: एक अलग बाढ़ भराव एल्गोरिथ्म का उपयोग कर कुछ तैयार

---

टेस्ट चलता है

1 चलाएं

एक वर्ण मैट्रिक्स को परिभाषित करें Aऔर उसे प्रिंट करें:

      A←↑('.#####....') ('.#....####') ('###.###..#') ('#.#...##..') ('.####..#.#') ('......###.') ('..#...#..#') ('..#...#..#')
      A
.#####....
.#....####
###.###..#
#.#...##..
.####..#.#
......###.
..#...#..#
..#...#..#

फिर Aकार्यक्रम में फ़ीड करें :

      '.##'[1+⊖1↓⍉↑↑{,/{⍵[⍒⍵]}¨x⊂⍨2=x←2,⍵}¨↓⍉(1,¨⍳⊃⌽⍴x){⍵≡y←⊃⌈/x←⍺{x←⍵⋄(⍺⌷x)∧←2⋄x}¨⊂⍵:y⋄((⊂⍴⍵)⌊¨1⌈,(,∘-⍨↓∘.=⍨⍳2)∘.+⍺/⍨x≢¨⊂⍵)∇y}⊖'#'=x←⎕]
⎕:
      A
..........
....######
..#.###..#
..#...##..
.##....#..
.##...####
####..#..#
#####.#..#

2 चलाएं

      A←↑('#######')('#.....#')('#.#.#.#')('#.....#')('#######')
      A
#######
#.....#
#.#.#.#
#.....#
#######
      '.##'[1+⊖1↓⍉↑↑{,/{⍵[⍒⍵]}¨x⊂⍨2=x←2,⍵}¨↓⍉(1,¨⍳⊃⌽⍴x){⍵≡y←⊃⌈/x←⍺{x←⍵⋄(⍺⌷x)∧←2⋄x}¨⊂⍵:y⋄((⊂⍴⍵)⌊¨1⌈,(,∘-⍨↓∘.=⍨⍳2)∘.+⍺/⍨x≢¨⊂⍵)∇y}⊖'#'=x←⎕]
⎕:
      A
#######
#.....#
#.....#
#.#.#.#
#######

Answer 5

जेएस - 443 बाइट्स

function g(b){function f(b,c,e){return b.substr(0,c)+e+b.substr(c+1)}function e(d,c){"#"==b[c][d]&&(b[c]=f(b[c],d,"F"),1<d&&e(d-1,c),d<w-1&&e(d+1,c),1<c&&e(d,c-1),c<h-1&&e(d,c+1))}b=b.split("\n");w=b[0].length;h=b.length;for(i=0;i<w;i++)"#"==b[h-1][i]&&e(i,h-1);for(j=h-2;-1<j;j--)for(i=0;i<w;i++)if(k=j+1,"#"==b[j][i]){for(;k<h&&"F"!=b[k][i]&&"#"!=b[k][i];)k++;k--;b[j]=f(b[j],i,".");b[k]=f(b[k],i,"#")}return b.join("\n").replace(/F/g,"#")};

बाढ़ नीचे से चट्टानों को भरती है, फिर अन-बाढ़ से भरी चट्टानों को नीचे लाती है। बाढ़ भरण के साथ बहुत अधिक पुनरावृत्ति का उपयोग करता है ताकि यह आपके ब्राउज़र को थोड़ा सा पीछे कर सके।

यह एक फ़ंक्शन है - इसे कॉल करें g("input")

JSFiddle: http://jsfiddle.net/mh66xge6/1/

अनसोल्डेड JSFiddle: http://jsfiddle.net/mh66xge6/

Answer 6

पायथन 3, 364 बाइट्स

मुझे यकीन है कि इससे अधिक निचोड़ा जा सकता है ... लेकिन यह सीजेएम और पर्ल के साथ कभी भी प्रतिस्पर्धा करने वाला नहीं है।

z="%";R=range
def F(r,c,g):
 if z>g[r][c]:g[r][c]=z;[F(r+d%2*(d-2),c+(d%2-1)*(d-1),g)for d in R(4)]
def P(s):
 t=s.split()[::-1];w=len(t[0]);g=[list(r+".")for r in t+["."*w]];[F(0,c,g)for c in R(w)]
 for c in R(w):
  for r in R(len(g)):
   while g[r][c]<z<g[r-1][c]and r:g[r][c],g[r-1][c]=".#";r-=1
 return"\n".join(''.join(r[:w])for r in g[-2::-1]).replace(z,"#")

अन्य उत्तरों के समान। एक विचित्र बात यह है कि यह ग्रिड को सबसे पहले मोड़ता है (लूप इंडेक्स को अधिक सुविधाजनक बनाने के लिए) और अतिरिक्त पंक्ति और कॉलम जोड़ता है .(रैपिंग -1इंडेक्स के साथ समस्याओं से बचने के लिए )। बुलाकर भागो P(string)।