भवन विध्वंस

Question

चुनौती

1 मंजिल प्रति सेकंड की दर से किसी दिए गए भवन को ध्वस्त करने के लिए एक पूर्ण कार्यक्रम / फ़ंक्शन लिखें ।

इनपुट

इनपुट एक है इमारत के माध्यम से STDIN (या जो भी अपनी भाषा में कहा जाता है) या एक के माध्यम से ARGUMENT एक समारोह का। टी = 0 एस

   |
  |#|
  {#}
 |# #|
|# # #|
|# # #|
|# # #|
TTTTTTT  

इनपुट में निम्न शामिल हैं:

• | एक मंजिल की शुरुआत और अंत।
• {, }विस्फोटक के साथ फर्श को चिह्नित करता है।
• # एक खिड़की है जो सजावट के लिए है।
• अंतरिक्ष है, जो हर जगह फर्श के अंदर है जहां #नहीं है।
• T जमीन का निशान (ध्वस्त नहीं किया जा सकता)।
• * विस्फोटित फर्श को चिह्नित करता है।

इनपुट नियम:

• इमारत एक के साथ ऊपर से शुरू होती है |और जमीन पर (बिना ( T= = नहीं) ( ) के साथ समाप्त होती है char used in ground floor।
• एक खिड़की #हर मंजिल के अंदर हर विषम जगह पर है।
• T आपके इनपुट के अंत को चिह्नित करता है।
• केवल एक मंजिल में विस्फोटक होते हैं।
• हर मंजिल विषम संख्या में बनी है। चेरों की।
• जब आप फर्श से नीचे उतरते हैं, तो फर्श पिछली मंजिल के बराबर आकार के हो सकते हैं या 2 चार्ट बड़े हो सकते हैं ।
• इनपुट की एक सरणी के रूप में लिया जा सकता है charsया strings।

आउटपुट:

टी = 0.5 एस

   |
  |#|
  ***
 |# #|
|# # #|
|# # #|
|# # #|
TTTTTTT  

टी = 1 एस

   |
  |#|
 |# #|
|# # #|
|# # #|
|# # #|
TTTTTTT  

टी = 1.5 एस

   |
  ***
 |# #|
|# # #|
|# # #|
|# # #|
TTTTTTT  

टी = 2 एस

   |
 |# #|
|# # #|
|# # #|
|# # #|
TTTTTTT  

टी = 2.5 एस

   *
 |# #|
|# # #|
|# # #|
|# # #|
TTTTTTT  

टी = 3 एस

 |# #|
|# # #|
|# # #|
|# # #|
TTTTTTT  

टी = 3.5 एस

 *****
|# # #|
|# # #|
|# # #|
TTTTTTT  

टी = 4 एस

|# # #|
|# # #|
|# # #|
TTTTTTT  

टी = 4.5 एस

*******
|# # #|
|# # #|
TTTTTTT  

टी = 6.5 एस

*******
TTTTTTT  

टी = 7 एस

TTTTTTT  

आउटपुट नियम:

• हर मंजिल एक newlineपात्र के साथ समाप्त होती है ।
• ग्राउंड में एक अनुगामी न्यूलाइन हो सकती है / नहीं।
• प्रत्येक 0.5 एस के निर्माण (या इसके बारे में क्या बचा है) का उत्पादन।
• आउटपुट एनीमेशन की तरह है जिसे हर 0.5 s में संशोधित किया जाता है और प्रदर्शित किया जाता है।
  (अपने जवाब के साथ GIF पोस्ट करने के लिए स्वतंत्र महसूस करें)

यह एक कोड-गोल्फ है इसलिए सबसे कम बाइट्स में कोड जीतता है!
जमा करने की अंतिम तिथि अब से ठीक 5 दिन है

(लेकिन आप जानते हैं कि क्या? जीतना सब कुछ नहीं है, इस चुनौती को अपनी पसंदीदा भाषा में आज़माने के लिए स्वतंत्र महसूस करें, भले ही विजेता घोषित किए जाने के बाद:)।

संपादित करें: मैंने इनपुट लेने का तरीका बदल दिया है (वास्तव में मेरा बुरा)।

Comments

अब से 1 बजे के बाद क्या जवाब दिया जाना चाहिए ?

— डेनिस

मेरी पोस्ट के समय से 1 घंटा। ताकि किसी भी प्रश्न से संबंधित संदेह को दूर करने के लिए मुझे कम से कम 1 घंटा मिले।

— मुकुल कुमार

मुझे यकीन नहीं है कि अगर समुदाय इस तरह की सीमा को लागू करने के लिए तैयार होगा। यदि आप सुनिश्चित नहीं हैं कि आपका विनिर्देश ठोस है, तो आप मुख्य पर पोस्ट करने से पहले प्रतिक्रिया प्राप्त करने के लिए हमारे सैंडबॉक्स में चुनौती का मसौदा तैयार कर सकते हैं ।

— डेनिस

@ डेनिस हम्म ... हटा दिया

— मुकुल कुमार

दो सवाल: (1) क्या हम यह मान सकते हैं कि किसी भी मंजिल पर कोई व्हाट्सएप नहीं है? (२) क्या हम यह मान सकते हैं कि जमीन के बाद इनपुट की अधिक लाइनें नहीं हैं?

— एच वाल्टर

Answer 1

विम, 41 38 बाइट्स

qw:sl 500m␍q/{␍qqjk^v$r*@wdd:-␍@w@qq@q

यहाँ, ^शाब्दिक देखभाल के लिए उपयोग किया जाता है; -CTRL-M के लिए उपयोग किया जाता है।

व्याख्या

qw:sl 500m␍qआधा सेकेंड सोते हैं, जबकि आधी दूसरी नींद को मैक्रो w के रूप में रिकॉर्ड करते हैं। /{␍विस्फोटक के साथ फर्श पर जाता है। qqमैक्रो क्यू रिकॉर्ड करना शुरू कर देता है, जो पुन: अपने आप को कॉल करेगा।

jkनीचे और ऊपर चलता है; यदि आप अंतिम पंक्ति (ग्राउंड) पर हैं तो यह एक त्रुटि उत्पन्न करता है; त्रुटि पुनरावर्ती मैक्रो को समाप्त करती है। ^v$r*पहले गैर-व्हाट्सएप चरित्र से पंक्ति के अंत तक सब कुछ बदल देता है। @wआधा सेकंड इंतजार करता है, फिर ddवर्तमान मंजिल को हटा देता है। :-␍यदि आप शीर्ष रेखा पर हैं, तो मैक्रो को समाप्त किए बिना एक मंजिल ऊपर जाता है। @wफिर एक और आधा सेकंड इंतजार करता है, और @qq मैक्रो (शुरू में खाली) कहता है।

q@q मैक्रो q को रिकॉर्ड करना बंद कर देता है, फिर उसे कॉल करता है, रिकर्सन को ट्रिगर करता है।

एनीमेशन

Comments

मैं जिफ़ देखने के लिए भूखा था !!

— मुकुल कुमार

मैंने देखा कि किसी और ने इसमें जिफ़ नहीं डाला, लेकिन आपने कहा "बेझिझक", इसलिए मेरी पोस्ट के लिए यह बहुत जरूरी था! किसी भी तरह, मेरा जवाब "गोल्फ" हो सकता है अगर वी में फिर से लिखा जाए

— एच वाल्टर्स

my answer could be "golfed" further... नहीं है कि पर्याप्त? : पी

— मुकुल कुमार

Answer 2

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

f=
(t,s=f=>setTimeout(f,500),v=t.value.split(/(\S.*\n)/),i=v.findIndex(s=>/}/.test(s)),c=_=>t.value=v.join``,d=_=>c(v.splice(--i,2),v[3]&&s(e,i?--i:++i)),e=_=>c(v[i]=v[i].replace(/./g,'*'),s(d)))=>s(e)

<textarea id=t rows=9>
   |
  |#|
  {#}
 |# #|
|# # #|
|# # #|
|# # #|
TTTTTTT
</textarea><input type=button value=Go! onclick=f(t)>

Answer 3

जावा 7, 589 477 476 बाइट्स

import java.util.*;void x(List<String>b,int x)throws Exception{Thread.sleep(500);int i=0,l=b.size(),z=x;String w;for(;i<l;i++){System.out.println(w=b.get(i));if(w.contains("{"))x=i;}System.out.println();w=b.get(x);i=w.contains("*")?1:0;if(i>0)b.remove(x);else b.set(x,z<0?r(w,'{','}'):r(w,'|','|'));if(l>1)x(b,i>0&x>0?x-1:x);}String r(String s,char y,char z){int a,b;return s.substring(0,a=s.indexOf(y))+s.substring(a,b=s.lastIndexOf(z)+1).replaceAll(".","*")+s.substring(b);}

ठीक है, यह एक गड़बड़ है / लंबा है, लेकिन इस चुनौती में जावा के लिए बहुत सारी कष्टप्रद चीजें हैं .. मल्टी-लाइन प्रिंटिंग; Thread.sleep(500)जिसकी आवश्यकता है throws Exception; समान मात्रा के साथ दो सीमांकक के बीच एक प्रतिस्थापन की जगह *; आदि।
यह सब कार्यक्रम को बहुत बड़ा बनाता है। यह रक्षात्मक रूप से कुछ और गोल्फ हो सकता है, शायद एक अलग दृष्टिकोण के साथ आधा भी हो सकता है, लेकिन कम से कम अब एक जवाब है। ;)

Ungolfed:

void x(List<String>b, int x) throws Exception{
  Thread.sleep(500);
  int i = 0,
      l = b.size(),
      z = x;
  String w;
  for(;i<l; i++){
    System.out.println(w=b.get(i));
    if(w.contains("{")){
      x = i;
    }
  }
  System.out.println();
  w = b.get(x);
  i = s.contains("*")
       ? 1
       : 0;
  if(i>0){
    b.remove(x);
  }
  else{
    b.set(x, z < 0
              ? r(s, '{', '}')
              : r(s, '|', '|'));
  }
  if(l>1){
    x(b, i > 0 & x > 0
          ? x-1
          : x);
  }
}

String r(String s, chary, char z){
    int a, b;
    return s.substring(0, a=s.indexOf(y)) + s.substring(a, b=s.lastIndexOf(z) + 1).replaceAll(".", "*") + s.substring(b);
}

टेस्ट कोड:

import java.util.*;

class M{
  void x(List<String>b,int x)throws Exception{Thread.sleep(500);int i=0,l=b.size(),z=x;String w;for(;i<l;i++){System.out.println(w=b.get(i));if(w.contains("{"))x=i;}System.out.println();w=b.get(x);i=w.contains("*")?1:0;if(i>0)b.remove(x);else b.set(x,z<0?r(w,'{','}'):r(w,'|','|'));if(l>1)x(b,i>0&x>0?x-1:x);}String r(String s,char y,char z){int a,b;return s.substring(0,a=s.indexOf(y))+s.substring(a,b=s.lastIndexOf(z)+1).replaceAll(".","*")+s.substring(b);}

  public static void main(String[] a){
    try{
        List<String> l = new ArrayList(){{
            add("   |   ");
            add("  |#|  ");
            add("  |#|  ");
            add(" {# #} ");
            add("|# # #|");
            add("|# # #|");
            add("|# # #|");
            add("TTTTTTT");
        }};
        new M().c(l, -1);
    }
    catch(Exception e){}
  }
}

इसे यहाँ आज़माएँ। (एक बार में यह एक ही बार में आउटपुट करता है और अनदेखा कर देता हैsleep..)

Comments

अपवाद को पकड़ने से आप कुछ बाइट्स बचा सकते हैं। या हो सकता है try{...}finally{return;}?

— नील

@ नील धन्यवाद, लेकिन मैं दोनों तरीकों को मर्ज करने में कामयाब रहा हूं, इसलिए अब मेरे पास एक ही हैthrows Exception

— केविन क्रूज़सेन

Answer 4

हास्केल, 245 221 बाइट्स

import System.Posix.Unistd
r=reverse
c#l|(i,j)<-span(<'!')l=i++(c<$j)
f[b]=[[b]]
f s|(h@(a:b),d:c)<-break(elem '{')s=(h++'*'#d:c):(h++c):f(init h++'{'#last h:c)|1<2=r<$>(f$r s)
mapM((usleep 500000>>).mapM putStrLn).init.f

उपयोग उदाहरण:

mapM((usleep 500000>>).mapM putStrLn).init.f $ ["  |"," {#}"," |#|","|# #|","|# #|","TTTTT"]

यह काम किस प्रकार करता है:

c#l|(i,j)<-span(<'!')l=i++(c<$j)    -- helper function that takes a char c and
                                    -- a string l and keeps the leading spaces
                                    -- of l and replaces the rest with c

                                    -- f takes a building (list of strings) and
                                    -- makes the sequence of collapsing buildings
                                    -- as a list of list of strings
f[b]=[[b]]                          -- base case. Stop when there's only a single
                                    -- floor left
f s                                 -- if the building has at least two floors
   |(h@(a:b),d:c)<-break(elem '{')s --   if there is at least one floor above the
                                    --   explosion
        =(h++'*'#d:c) :             --     return the current building with the
                                    --     floor to explode replaced by *
        (h++c) :                    --     followed by the current building with
                                    --     the exploded floor removed 
        f(init h++'{'#last h:c)     --     followed by a recursive call
                                    --     with the next to explode floor marked
                                    --     with '{'
   |1<2=r<$>(f$r s)                 --   if all top floors have exploded, reverse
                                    --   the left over floors, let them explode
                                    --   and reverse the floors of each building
                                    --   again.

                      f             -- let the building collapse
                 init               -- f comes with an additional building with
                                    -- a single floor of * only -> drop it
mapM(     )                         -- for every building
     (usleep 500000>>)              --   delay 0.5 sec
             mapM putStrLn          --   and print the floors

नोट: यह भी वहाँ threadDelayसे GHC.Concबजाय usleepसे System.Posix.Unistdजो थोड़ा छोटा सा है, लेकिन यह केवल के साथ काम करता GHC, संकलक तो यह एक सामान्य नहीं होगा Haskellजवाब।

Answer 5

सी, 314 287 281 271 बाइट्स

s,e,t,i;f(char**b){char*p;do{system("CLS");i=0;do{while(!(p=b[i]))i++;if(!*b&&e==1)e=i;while(*p<33)putchar(*p++);if(!t)e=*p=='{'?i:e,s+=2;do{putchar(e==i&&t%2&&*p>16?'*':*p);}while(*p&&*p++>16);}while(*b[i++]-84);if(t++%2)b[e]=0,*b&&e>0?e--:e++;Sleep(500);}while(t<s-1);}

-10 जब यह संभव है, साथ ही साथ चार शाब्दिक !=को बदलने -और बचने के बाद isspace(एच वाल्टर्स के लिए बहुत धन्यवाद)। लेकिन अनलॉक्ड कोड अपरिवर्तित रहता है।

s,e,t,i;f(char**b){char*p;do{system("CLS");i=0;do{while(!(p=b[i]))i++;if(!*b&&e==1)e=i;while(isspace(*p))putchar(*p++);if(!t)e=*p=='{'?i:e,s+=2;do{putchar(e==i&&t%2&&*p>0xF?'*':*p);}while(*p&&*p++>0xF);}while(*b[i++]!='T');if(t++%2)b[e]=0,*b&&e>0?e--:e++;Sleep(500);}while(t<s-1);}

-6 कोट्स लगाने के बाद कोमा और {}दो के बाद डिलीट if।

s,e,t,i;f(char**b){char*p;do{system("CLS");i=0;do{while(!(p=b[i]))i++;if(!*b&&e==1)e=i;while(isspace(*p))putchar(*p++);if(!t){s+=2;e=*p=='{'?i:e;}do{putchar(e==i&&t%2&&*p>0xF?'*':*p);}while(*p&&*p++>0xF);}while(*b[i++]!='T');if(t++%2){b[e]=0;e=*b&&e>0?e-1:e+1;}Sleep(500);}while(t<s-1);}

थोड़ा अनुकूलन के बाद -26 बाइट्स, अनावश्यक कोष्ठक को हटाने, साथ ही स्थानीय चर को वैश्विक (ऑटो 0 आरंभीकरण के साथ) और b[0]द्वारा बदलते हैं *b।

f(char**b){int s=0,e=0,t=0;char*p;do{system("CLS");int i=0;do{if(!t){s+=2;if(strchr(b[i],'}'))e=i;printf(b[i]);}else{while(!(p=b[i]))i++;if(!b[0]&&e==1)e=i;do{putchar((e==i&&t%2&&!isspace(*p))?'*':*p);}while(*p&&*p++!='\n');}}while(b[i++][0]!='T');if(t%2){b[e]=0;e=(b[0]&&e)?e-1:e+1;}t++;Sleep(500);}while(--s>1);}

अनलॉक्ड के साथ टेस्ट कोड f:

#include <stdio.h>
#include <windows.h> // to use Sleep and system

s, e, t, i;
f(char**b)
{
    char*p;
    do{
        system("CLS");
        i = 0;
        do
        {
            while (!(p=b[i]))i++; // skip demolished floors
            if (!*b && e==1) e = i;
            while (isspace(*p)) putchar(*p++); // print spaces 
            if (!t){ s += 2; e = *p == '{' ? i : e; } // find a bomb and count steps at the first iteration
            do{
                putchar(e == i && t%2 &&*p>0xF ? '*' : *p); // print floor or * for next floor at odd step
            } while (*p && *p++ >0xF); // >0xF is instead of !='\n'
        } while (*b[i++] != 'T'); // until the ground
        if (t++ % 2)
        {
            b[e] = 0; // delete the demolished floor
            e = *b&&e>0 ? e-1 : e+1; // and determine next floor to be demolished
        }
        Sleep(500);
    } while (t<s-1);
}

int main(void)
{
    char * arr[] = { "   |\n",
                     "  |#|\n",
                     "  {#}\n",
                     " |# #|\n",
                     "|# # #|\n",
                     "|# # #|\n",
                     "|# # #|\n",
                     "TTTTTTT" };
    f(arr);
}

Comments

आप s,e,tविश्व स्तर पर इस तरह से परिभाषित कर सकते हैंs,e,t;

— मुकुल कुमार

@ मुकुलकुमार आपको यकीन है?

— मार्क यिश्री

हाँ यकीन है कि आगे बढ़ो और यह प्रयास करें ..., iदूसरों के साथ भी शामिल करें।

— मुकुल कुमार

मैं कुछ अन्य अनुकूलन की कोशिश करूंगा और आपके सुझावों का भी उपयोग

— करूंगा

@MukulKumar सलाह के लिए धन्यवाद ... -23 बाइट्स

— VolAnd

Answer 6

पर्ल, 153 बाइट्स

for(@a=<>;$a[$i]!~/{/;$i++){}for(;$a[0]!~/^T/;`sleep .5`){if($P=!$P){$a[$i]=~s/(\S.*\S|\S)/"*" x length($1)/e}else{splice(@a,$i,1);if($i){$i--}}print@a}

यह 500 मिली सेकंड तक प्रतीक्षा करने के लिए GNU स्लीप कमांड का उपयोग करता है।

अनप्लग्ड संस्करण

for(@a=<>;$a[$i]!~/{/;$i++){}
for(;$a[0]!~/^T/;`sleep .5`){
    if($P=!$P){
       $a[$i]=~s/(\S.*\S|\S)/"*" x length($1)/e
    } else { 
       splice(@a,$i,1);
       if($i){$i--}
    }
    print @a
 }

Answer 7

PHP, 286 282 274 234 229 बाइट्स

<?for($a=$argv,array_shift($a);!strstr($a[+$i++],"{"););while($a[0][0]!=T){$x=&$a[$i-=$i>0];$x=str_pad(substr($x,0,strspn($x," ")),strlen($x),"*");eval($p='echo join("\n",$a),"\n\n";usleep(5e5);');array_splice($a,$i,1);eval($p);}

कमांड लाइन तर्कों (कोई नया चरित्र नहीं) से तार की सूची के रूप में इनपुट लेता है!

फ़ाइल को सहेजना, साथ चलाना php <filename> ' |' ' |#|' ' {#}' ' |# #|' '|# # #|' '|# # #|' '|# # #|' 'TTTTTTT'

टूट - फूट

<?
for($a=$argv,array_shift($a);   // import input
    !strstr($a[+$i++],"{"););   // find explosives
while($a[0][0]!=T)              // loop while ground not reached:
{
    $x=&$a[$i-=$i>0];               // move up if possible, reference floor
    $x=str_pad(
        substr($x,0,strspn($x," ")  // keep leading spaces
    ),strlen($x),"*");              // replace rest with asterisks
                                    // print and wait
    eval($p='echo join("\n",$a),"\n\n";usleep(5e5);');
    array_splice($a,$i,1);          // remove current floor
    eval($p);                       // print and wait
}