ASCII एनिमेटेड बर्फ दृश्य

22

एएससीआईआई कला के किसी भी टुकड़े को एक एनिमेटेड बर्फ दृश्य में बदलने के लिए सबसे छोटा कार्यक्रम लिखें, जो गिरने वाली बर्फ ( गैर-गोल्फ वाले जावास्क्रिप्ट उदाहरण पिछले अद्यतन 2011-12-19) से बनना शुरू होता है ।

इनपुट विनिर्देशन : आपके कार्यक्रम को रिक्त स्थान, तारांकन और नई सूचियों के मनमाने संयोजन को स्वीकार करना चाहिए। इनपुट में अधिकतम 23 लाइनें और प्रति पंक्ति 80 वर्ण होंगे। कोई खाली लाइनें नहीं होंगी, फिर भी लाइनों में केवल व्हाट्सएप हो सकता है। एक एकल अनुगामी न्यूलाइन को शामिल किया जाएगा और इसे अनदेखा किया जाना चाहिए।

आउटपुट : आउटपुट ASCII वर्ण (रिक्त स्थान, तारांकन) और नियंत्रण कोड (गाड़ी रिटर्न, लाइनफीड, ANSI एस्केप कोड, आदि) आपके ऑपरेटिंग सिस्टम के टेक्स्ट कंसोल या टर्मिनल एमुलेटर के लिए जब तक उपयोगकर्ता मैन्युअल रूप से प्रोग्राम समाप्त नहीं करता। आप मान सकते हैं कि टर्मिनल विंडो 80x24 वर्ण है यदि आपका ऑपरेटिंग सिस्टम उस सेटिंग को अनुमति देता है।

नियम :

एनीमेशन सुचारू और तेज़ होना चाहिए (15 एफपीएस पसंदीदा)।
बर्फ का घनत्व 5% से 15% के बीच होना चाहिए।
बर्फ की एक से अधिक स्क्रीन प्रति सेकंड स्क्रॉल नहीं हो सकती है। (इसका मतलब है कि किसी भी दूसरी अवधि में नई बर्फ की 24 से अधिक लाइनें नहीं जोड़ी जा सकती हैं।)
बर्फ को किसी भी स्पष्ट पैटर्न को प्रदर्शित नहीं करना चाहिए क्योंकि यह स्क्रीन के शीर्ष में प्रवेश करता है; यह यादृच्छिक दिखना चाहिए।
कार्यक्रम को जितनी जल्दी हो सके स्क्रीन के सभी पंक्तियों को बर्फ से भरना चाहिए; स्क्रीन की अलग-अलग पंक्तियों की प्रारंभिक फिलिंग दर्शक को स्पष्ट नहीं होनी चाहिए।
इनपुट ASCII कला के निचले बाएं कोने को स्क्रीन के निचले बाएं कोने में होना चाहिए (आगे स्पष्टीकरण के लिए चित्र 1)।
ASCII कला के अंदर या नीचे का क्षेत्र स्थायी रूप से तारांकन से भरा नहीं होना चाहिए। हालाँकि, इस क्षेत्र में तारांकन (लेकिन इसकी आवश्यकता नहीं है) स्क्रॉल कर सकते हैं।
इनपुट में दिखाए गए अनुसार बर्फ को स्क्रीन के नीचे या मौजूदा बर्फ के ऊपर जमा नहीं होना चाहिए।
निचले स्थानों को ऊपरी लोगों से पहले भरना चाहिए, क्योंकि विपरीत क्रम में रिक्त स्थान भरने से क्रिसमस ट्री का एनीमेशन मेरे मूल कोड के आउटपुट से बहुत अलग दिखता है। (जोड़ा गया 2011-12-20)

छुट्टियां आनंददायक हों!

चित्र 1: 80x24 स्क्रीन के लेबल वाले क्षेत्र

---------------------------New snow added on this line--------------------------
                                                                             |
                                                                             |
----------------------------------------------------------+                  |
                                                    ****  |                  |
    Snow MUST fall  Snow MAY fall ---------------->  **** |                  |
    through this    through these          ****      **** |  Snow MUST fall  |
    area.           areas of a              ****     **** |  through this    |
                    completed   \--------->  ****     ****|  area.           |
        ASCII art   scene.    \     ***        ****   ****|                  |
          area         \       \   *******      ****  ****|                  |
                        \       \    ********     ***  ***|  (ALL CAPS terms |
      (located in        \       \-->   *********  ***    |  have standard   |
       lower left         \     *******     ******  MAY   |     RFC 2119     |
       corner of           \    *************  **   fall  |    meanings.)    |
       screen)              \        ***********    here  |                  |
                         *** +--->          ****  ***     |                  |
                         *** | ****************   ***     |                  |
  | Snow MUST fall       *** | ****************   ***     |                  |
  | through this         *** +--->                ***     |                  |
  | area.                *** | ****************   ***     |                  |
--+---------------------+*** +--->                ***+----+------------------+--
  |   Snow MUST NOT     |****************************|      Snow MUST NOT    |
  V  accumulate here.   |****************************|     accumulate here.  V

उदाहरण इनपुट

कोड गोल्फ बैनर

 ******   *******  ********  ********     ******    *******  **       ******** 
**    ** **     ** **     ** **          **    **  **     ** **       **       
**       **     ** **     ** **          **        **     ** **       **       
**       **     ** **     ** ******      **   **** **     ** **       ******   
**       **     ** **     ** **          **    **  **     ** **       **       
**    ** **     ** **     ** **          **    **  **     ** **       **       
 ******   *******  ********  ********     ******    *******  ******** **

ढेर अतिप्रवाह लोगो

                                                    ****
                                                     ****
                                           ****      ****
                                            ****     ****
                                             ****     ****
                                    ***        ****   ****
                                   *******      ****  ****
                                     ********     ***  ***
                                        *********  ***
                                *******     ******
                                *************  **
                                     ***********
                         ***                ****  ***
                         ***   ****************   ***
                         ***   ****************   ***
                         ***                      ***
                         ***   ****************   ***
                         ***                      ***
                         ****************************
                         ****************************

क्रिसमस ट्री

                                        *
                                       ***                           *
                *                     *****                         ***
               ***                   *******           *           *****
              *****                 *********         ***            *
                *                  ***********       *****
                       *          *************     *******
        *             ***        ***************       *               *
       ***           *****      *****************                     ***
      *****         *******    *******************                   *****
     *******           *      *********************                 *******
    *********                           *                          *********
        *                                                              *

code-golf ascii-art animation

— कृपया उठो
स्रोत

1

तीसरा क्रिसमस ट्री टूट गया है।

— बॉबी 12

अच्छी चुनौती! मुझे लगता है कि नियमों को आसान संदर्भ के लिए माना जाना चाहिए, और मुझे तीसरा और छठा नियम समझ में नहीं आता ...

— हॉल्वैबो

@ हालावाबो मैंने उन दो नियमों को स्पष्ट किया है, जिन्हें बाद में एक लेबल आंकड़ा जोड़ा गया है।

— प्लीज स्टेंड

क्लेरीफिकेशन रिक्वेस्ट: क्या नई लाइन 80-चार अधिकतम लाइन लंबाई में शामिल है, या क्या यह अधिकतम 80 चार्ट प्लस न्यूलाइन है? (मैंने बाद में मान लिया, लेकिन कुछ प्रस्तुतियाँ पूर्व मान ली गई हैं।)

— इल्मरी करोनें

@ इल्मारियारोनन द बाद।

— कृपया स्टेंड

5

पर्ल, 196/239 चार्ट

chomp(@p=(@f=($"x80)x24,<>)[-24..-1]);{@s=(join("",map rand>.1?$":"*",1..80),@s);if(@s>23){$t=$f[$_],print$_?$/:"\e[H",($f[$_]|=$s[$_]&$p[$_])|($s[$_]&=~$t^$f[$_])for 0..23;select"","","",.1}redo}

यह समाधान आपके जेएस उदाहरण से अलग है जिसमें पैटर्न नीचे से ऊपर की बजाय ऊपर से भरा हुआ है, लेकिन मुझे लगता है कि ठीक है क्योंकि आपने नियमों में इसके बारे में कुछ नहीं कहा था।

एक मामूली 1-चार कमी \eशाब्दिक ईएससी चरित्र के साथ बदलकर प्राप्त की जा सकती है , लेकिन यह कोड को पढ़ने और संपादित करने के लिए बहुत कठिन बनाता है।

अद्यतन: मैंने एक ऐसे संस्करण के साथ आने का प्रबंधन किया जो पैटर्न को नीचे से भरता है, और पैटर्न के भरे हुए हिस्सों के माध्यम से बर्फ को गिरने नहीं देता है, जैसा कि जेएस कार्यान्वयन में, 43 अतिरिक्त वर्णों की लागत पर:

chomp(@p=(@q=@f=($"x80)x24,<>)[-24..-1]);{@s=(join("",map rand>.1?$":"*",1..80),@s);if(@s>23){my$q;$q[-1-$_]=($q|=$p[-$_]&~$f[-$_])for@a=0..23;print$_?$/:"\e[H",($f[$_]|=$s[$_]&$p[$_]&~$q[$_])|($s[$_]&=~$f[$_])for@a;select"","","",.1}redo}

($s[$_]&=~$f[$_])बस के साथ बदलने $s[$_]से पैटर्न के भरे हुए हिस्सों के माध्यम से गिरने वाले बर्फ से गुजरने से 11 वर्णों को बचाया जा सकता है (जो कि कल्पना से मेल खाता है, लेकिन उदाहरण कार्यान्वयन नहीं)।

ठीक है, चूंकि मैं अभी भी एक सप्ताह के बाद दौड़ का नेतृत्व कर रहा हूं, मुझे लगता है कि मुझे समझाना चाहिए कि मेरा समाधान अधिक प्रतिस्पर्धा को प्रोत्साहित करने के लिए कैसे काम करता है। (नोट: यह स्पष्टीकरण 196-चार टॉप-डाउन फिलिंग संस्करण के लिए है। मैं बाद में अन्य संस्करण को शामिल करने के लिए इसमें संशोधन कर सकता हूं।)

सबसे पहले, मेरे समाधान पर आधारित एक बड़ी चाल यह है कि, ASCII वर्ण कोड को व्यवस्थित करने के तरीके के कारण, एक स्थान के लिए ASCII कोड में 1-बिट्स सिर्फ एक के लिए कोड का एक उपसमूह होने के लिए होता है तारांकन।

इस प्रकार, निम्नलिखित अभिव्यक्तियाँ सत्य हैं: " " & "*" eq " "और " " | "*" eq "*"। यह वही है जो मुझे व्यक्तिगत पात्रों पर लूप किए बिना दृश्य के स्थिर और चलते भागों के संयोजन के लिए बिटवाइज़ स्ट्रिंग संचालन का उपयोग करने देता है।

तो, उस रास्ते से, कोड पर चलते हैं। यहाँ इसका एक डी-गोल्फ संस्करण है:

chomp(@p = (@f = ($" x 80) x 24, <ARGV>)[-24..-1]);
{
    @s = (join('', map((rand > 0.1 ? $" : '*'), 1..80)), @s);
    if (@s > 23) {
        foreach (0 .. 23) {
            $t = $f[$_];
            print( $_ ? $/ : "\e[H" );
            print( ($f[$_] |= $s[$_] & $p[$_]) | ($s[$_] &= ~$t ^ $f[$_]) );
        }
        select '', '', '', 0.1;
    }
    redo;
}

पहली पंक्ति सरणियों को @fनिर्धारित करती है ("निश्चित" के लिए) और @p("पैटर्न" के लिए)। @fप्रदर्शन के निश्चित भाग का निर्माण करेगा, और रिक्त स्थान के अलावा कुछ भी नहीं शुरू करता है, जबकि @p, जो सीधे नहीं दिखाया गया है, इसमें इनपुट पैटर्न शामिल है; जैसा कि एनीमेशन आगे बढ़ता है, हम अधिक से अधिक तारांकन जोड़ेंगे, @fजब तक कि यह अंततः जैसा दिखता है @p।

विशेष रूप से, 80 स्थानों में से प्रत्येक के 24 तारों पर @f = ($" x 80) x 23सेट @fहोता है। ( $"एक विशेष पर्ल वैरिएबल है जिसका डिफ़ॉल्ट मान सिर्फ एक स्पेस होता है।) हम फिर इस सूची को <>लेते हैं, रीडलाइन ऑपरेटर का उपयोग करके इनपुट लाइनों को इसमें जोड़ते हैं , इस संयुक्त सूची की अंतिम 24 लाइनें लेते हैं और इसे इसे असाइन करते हैं @p: यह है @pरिक्त लाइनों के साथ पैड करने के लिए एक कॉम्पैक्ट तरीका ताकि पैटर्न दिखाई दे जहां यह होना चाहिए। अंत में, हम किसी भी नई रूपरेखा को हटाने के chompलिए इनपुट लाइनें @pबनाते हैं ताकि बाद में उन्हें समस्या न हो।

अब, मुख्य लूप को देखें। यह पता चलता है कि {...;redo}एक अनंत लूप लिखने की तुलना में एक छोटा रास्ता है while(1){...}या यहां तक कि for(;;){...}, खासकर अगर हम अर्धविराम को पहले छोड़ देते हैं redoक्योंकि यह तुरंत एक ifब्लॉक का अनुसरण करता है।

मुख्य लूप की पहली पंक्ति सरणी का परिचय देती है @s("स्नो" के लिए, निश्चित रूप से), जिसमें यह 90% रिक्त स्थान के यादृच्छिक 80-वर्ण स्ट्रिंग और प्रत्येक पुनरावृत्ति पर 10% तारांकन का संकेत देता है। (कुछ वर्णों को बचाने के लिए, मैं वास्तव में @sसरणी के अंत में अतिरिक्त लाइनों को कभी भी पॉप नहीं करता हूं , इसलिए यह लंबे और लंबे समय तक रहता है। आखिरकार यह कार्यक्रम को रोक देगा क्योंकि सरणी स्मृति में फिट होने के लिए बहुत लंबा हो जाता है, लेकिन वह ज्यादातर लोगों की तुलना में इस एनीमेशन को देखने में जितना समय लगेगा pop@s;, selectउससे पहले एक कथन जोड़ना होगा जो सात चरों की कीमत पर तय करेगा।)

मुख्य लूप के बाकी हिस्से को एक ifब्लॉक में लपेटा जाता है, ताकि यह केवल तब चले जब @sसरणी में कम से कम 24 लाइनें हों। यह कल्पना का पालन करने का एक सरल तरीका है, जिसके लिए पूरे प्रदर्शन को शुरू से गिरने वाली बर्फ से भरना पड़ता है, और बिटवाइज़ के संचालन को भी थोड़ा सरल करता है।

इसके बाद एक foreachलूप आता है , जो कि गोल्फ संस्करण में वास्तव में एक for 0..23संशोधक के साथ एक एकल स्टेटमेंट है । चूंकि लूप की सामग्री को शायद कुछ स्पष्टीकरण की आवश्यकता है, मैं इसे थोड़ा और नीचे अनपैक करने जा रहा हूं:

foreach (0 .. 23) {
    print $_ ? $/ : "\e[H";     # move cursor top left before first line, else print newline
    $t = $f[$_];                # save the previous fixed snowflakes
    $f[$_] |= $s[$_] & $p[$_];  # snowflakes that hit the pattern become fixed 
    $s[$_] &= ~$t ^ $f[$_];     # ...and are removed from the moving part
    print $f[$_] | $s[$_];      # print both moving and fixed snowflakes ORed together
}

सबसे पहले, $_पर्ल में डिफ़ॉल्ट लूप काउंटर चर है जब तक कि एक और चर निर्दिष्ट नहीं किया जाता है। यहाँ यह 0 से 23 तक चलता है, यानी डिस्प्ले फ्रेम में 24 लाइनों पर। सरणी में $foo[$_]अनुक्रमित तत्व को दर्शाता है ।$_@foo

डी-गोल्फ लूप की पहली पंक्ति में, हम या तो एक नई रेखा ( $/विशेष रूप से विशेष चर से प्राप्त ) प्रिंट करते हैं या, जब $_0, स्ट्रिंग के बराबर होता है "\e[H", जहां \eएक ईएससी चरित्र को दर्शाता है। यह एक एएनएसआई टर्मिनल कंट्रोल कोड है जो कर्सर को स्क्रीन के ऊपरी बाएं कोने में ले जाता है। तकनीकी रूप से, हम छोड़ सकते हैं कि अगर हमने एक विशिष्ट स्क्रीन आकार ग्रहण किया, लेकिन मैंने इसे इस संस्करण में रखा क्योंकि इसका मतलब है कि मुझे एनीमेशन चलाने के लिए अपने टर्मिनल का आकार बदलने की आवश्यकता नहीं है।

पर $t = $f[$_]लाइन, हम बस के वर्तमान मूल्य को बचाने $f[$_]एक "अस्थायी" चर (इसलिए में $t) से पहले संभावित रूप से अगली पंक्ति है, जहां में बदल रहा है $s[$_] & $p[$_]बर्फ गिरने और इनपुट पद्धति के चौराहे (बिटवाइज़ और) देता है, और |=ऑपरेटर अन्य रैंकों निश्चित आउटपुट लाइन में $f[$_]।

नीचे दी गई लाइन पर, $t ^ $f[$_]पिछले और वर्तमान मानों का बिटवाइज़ XOR देता है $f[$_], यानी बिट्स की एक सूची जो हमने पिछली पंक्ति में बदली थी, यदि कोई हो, और इनपुट स्ट्रिंग्स में से किसी ~एक को आउटपुट आउटपुट को नकारता है। इस प्रकार, जो हमें मिलता है वह बिटमैस्क है जिसमें सभी बिट्स 1 हैं, सिवाय इसके कि हमने $f[$_]पिछली लाइन पर जोड़ा था। $s[$_]उन बिट्स को उस पर से हटाने के लिए उस बिटकॉम्ब का अनुमान लगाना ; वास्तव में, इसका मतलब यह है कि जब गिरने वाला बर्फ का टुकड़ा तय पैटर्न में एक छेद में भर जाता है, तो यह गिरने वाले बर्फ के सरणी से हटा दिया जाता है।

अंत में, print $f[$_] | $s[$_](जो कि गोल्फ संस्करण में दो पिछली पंक्तियों को एक साथ लागू कर रहा है) को लागू किया जाता है) वर्तमान रेखा पर स्थिर और गतिशील स्नोफ्लेक्स के संघ (बिटवाइर ओआर) को प्रिंट करता है।

एक और बात जो व्याख्या करने के लिए बची है वह select '', '', '', 0.1है भीतर के पाश से नीचे। यह पर्ल में 0.1 सेकंड सोने के लिए सिर्फ एक कलगी रास्ता है; कुछ मूर्खतापूर्ण ऐतिहासिक कारणों के लिए, मानक पर्ल sleepकमांड में एक-दूसरा रिज़ॉल्यूशन है, और मॉड्यूल sleepसे बेहतर आयात करने Time::HiResसे 4-आरजी काselect दुरुपयोग करने से अधिक आकर्षण होता है ।

— इल्मरी करोनें
स्रोत

एक मामूली बग लगता है: 24 वीं पंक्ति का उपयोग नहीं किया गया है, और एएससीआईआई कला की निचली रेखा 23 वीं पंक्ति है। और यह वास्तव में निचले रिक्त स्थान को भरना चाहिए इससे पहले कि यह ऊपरी भरता है, हालांकि मैंने मूल रूप से निर्दिष्ट नहीं किया था।

— प्लीज स्टेंड

@PleaseStand: मैंने say2 अतिरिक्त वर्णों की लागत पर सभी 24 लाइनों (और संयोग से छुटकारा पा लिया ) का उपयोग करने के लिए कोड बदल दिया । मुझे नहीं लगता कि मैं भरण आदेश को बहुत आसानी से बदल सकता हूं, हालांकि; मेरा कार्यान्वयन मूल रूप से इसके साथ बंधा हुआ है।

— इल्मरी करोनें

महान व्याख्या! काश मैं इस प्रविष्टि को फिर से वोट कर सकता।

— डिलन कॉवर

@PleaseStand: मैंने वास्तव में एक बॉटम-अप फिलिंग संस्करण बनाने का प्रबंधन किया था , जो अब आपके जेएस उदाहरण के समान ही दिखता है; यह ऊपर से नीचे की तुलना में थोड़ा लंबा है, लेकिन अभी तक अन्य प्रविष्टियों की तुलना में कम है।

— इल्मरी करोनें

3

HTML और जावास्क्रिप्ट, 436 वर्ण

इसे इनपुट पर भेजें:

<body onload="for(a=[],b=[],c=document.body.firstChild,e=c[H='innerHTML'].split(N='\n'),f=e.length-1,g=24,h=g-f;f--;)for(X=80;X--;)b[80*(h+f)+X]='*'==e[f][X];for(setInterval(F='for(y=24;y--;)for(x=80;x--;)if(a[w=80*y+x]){d=1;if(b[w])for(d=0,z=y+1;24>z;++z)b[s=80*z+x]&&!a[s]&&(d=1);d&&(a[w]=0,a[w+80]=1)}for(x=80;x--;).1>Math.random(i=0)&&(a[x]=1);for(t=\'\';1920>i;++i)t+=\'* \'[+!a[i]],79==i%80&&(t+=N);c[H]=t',67);g--;)eval(F)"><pre>

प्रत्येक उदाहरण के लिए इसे देखें: कोड गोल्फ , स्टैक ओवरफ्लो लोगो , क्रिसमस ट्री । Internet Explorer उपयोगकर्ताओं को सही ढंग से काम करने के लिए प्रस्तुत करने के लिए संस्करण 9 को चलाने और "IE9 मानकों" (F12 डेवलपर टूल का उपयोग करके) को "दस्तावेज़ मोड" सेट करने की आवश्यकता है।

— कृपया उठो
स्रोत

1

सभी 3 टूटे हुए लगते हैं? pasteall.org/pic/show.php?id=66297

— CoDEmanX

1

पायथन, 299 वर्ण

यह नियमों के अनुरूप होना चाहिए, यह मानते हुए कि नई रूपरेखा 80 की सीमा में शामिल है।

import random,sys,time
C=1920
v=_,x=' *'
a=['']*C
f=lambda n:[random.choice(e*9+x)for e in _*n]
for e in sys.stdin:a+="%-80s"%e
a=a[-C:]
s=f(C)
while 1:
 z=0;t=''
 for e in s:
    t+=v[x<a[z]or e>_]
    if(e>_<a[z])>(x in a[z+80::80]):a[z]='+'
    t+=z%80/79*'\n';z+=1
 print t;s=f(80)+s[:-80];time.sleep(.1)

— hallvabo
स्रोत

यदि इनपुट में कोई रेखाएं हैं, जो बिल्कुल 80 वर्ण (प्लस न्यूलाइन) लंबी हैं तो आपका आउटपुट खराब हो जाता है। मैंने PleaseStand को स्पष्ट करने के लिए कहा है कि क्या यह ठीक है।

— इल्मरी करोनें

ऐसा इसलिए है क्योंकि मैं प्रत्येक 80-चार चौड़ी लाइन के अंत में एक नई पंक्ति शामिल करता हूं। विवरण यहाँ अस्पष्ट है, क्योंकि यह निर्दिष्ट करता है कि नई सूचियों को शामिल किया जाना चाहिए, लेकिन यह भी कि कोई मान सकता है कि टर्मिनल 80 वर्ण चौड़ा है (जिस स्थिति में कोई भी नई सूची को छोड़ सकता है और स्वचालित रैपिंग पर निर्भर हो सकता है)।

— हॉलवेज़ो

मुझे लगता है कि वास्तविक समस्या यह है कि आप इनपुट लाइनों को actual० चार्ट पर ले जाने से पहले न्यूलाइन्स को बंद नहीं करते हैं, जिससे कि plus०-चार्ट्स-प्लस-न्यूलाइन इनपुट वास्तव में s१ चार्ट्स को जोड़ देता है aऔर इसलिए इंडेक्सिंग को गड़बड़ कर देता है। मैं सिर्फ यह कोशिश की, और ऐसा लगता है कि लाइन 6 के %eसाथ प्रतिस्थापित %e.rstrip()करने से समस्या ठीक हो जाती है। (बेशक, वहाँ एक अच्छी तरह से ठीक हो सकता है; मैं अजगर गोल्फ में अच्छा नहीं हूँ।)

— इल्मरी करोनें

यदि आप 81 चार लाइनों का समर्थन करना चाहते हैं, तो बस संख्याओं को बदलें, और यह ठीक काम करता है। जब तक आप प्रति पंक्ति 100 वर्णों के नीचे रहते हैं, तब तक यह चार गिनती नहीं बदलेगी :-)

— hallvabo

यदि मैं 81-चर लाइनों का उपयोग करने के लिए आपका कोड बदलता हूं, तो यह 80-कॉलम टर्मिनल पर सही ढंग से नहीं चलेगा, अब यह होगा? आप 80-कॉलम आउटपुट का उत्पादन कर रहे हैं, यह ठीक है कि आप 80-कॉलम इनपुट को सही तरीके से स्वीकार नहीं कर रहे हैं । इसे आज़माएं: प्रत्येक पर 80 तारांकन वाली दो लाइनों के साथ एक इनपुट फ़ाइल बनाएं और देखें कि क्या होता है। यह उतना कठिन नहीं होना चाहिए: मेरा समाधान इसे ठीक करता है।

— इल्मरी करोनें

0

जावा, 625 चार्ट

import java.io.*;import java.util.*;class s extends TimerTask {int _c,_k;char _i[],_o[];boolean _b[];public s(String f) throws IOException {_i=new char[23*80];_o=new char[80];_b=new boolean [23*80];BufferedReader br = new BufferedReader(new FileReader(f));while (br.read(_i,_c++*80,80)!=-1);} public void run(){_k=--_k<0?_c:_k;for(int i=0;i<80;_b[_k*80+i]=Math.random()>0.9?true:false,i++);for(int m=0;m<_c;m++){for(int n=0;n<80;_o[n]=_b[(_k+m)%_c*80+n]?'*':_i[m*80+n],n++);System.out.println(_o);}}public static void main(String[] a) throws IOException{Timer timer=new Timer();timer.scheduleAtFixedRate(new s(a[0]),0,500);}}

जावा में एक सरल समाधान।

— siz
स्रोत

अच्छा है, लेकिन मुझे नहीं लगता कि आप कल्पना का पालन कर रहे हैं। विशेष रूप से, आप शुरुआत से पूरे पैटर्न को दिखाते हैं - यह नमूना डेमो के रूप में "गिरने वाली बर्फ से" नहीं बनता है। (निश्चित रूप से, इस प्रश्न में बेहतर व्याख्या की जा सकती है। आपको वास्तव में यह समझने के लिए डेमो देखने की आवश्यकता है कि यह क्या करना चाहिए।) इसके अलावा, आपका फ्रैमरेट बहुत धीमा है, आप बर्फ से भरे स्क्रीन से शुरू नहीं करते हैं, आपको लगता है। दिए गए उदाहरणों से अलग एक इनपुट प्रारूप मान रहे हैं, और आप वास्तव में फ्रेम के बीच कर्सर की स्थिति को रीसेट करने के लिए "\033[H"चाहिए (मुद्रण यह करना चाहिए)।

— इल्मरी करोनें