ASCII- कला में एक स्टार के विस्फोट को प्रदर्शित करें

Question

लक्ष्य ASCII कला में विस्फोट करने वाले एक स्टार को चेतन करना है, जो एकल स्टार चरित्र *से सुपरनोवा और अंत में अंतरिक्ष शून्य तक शुरू होता है।

नियम:

• आपको 24 लाइनों पर प्रति पंक्ति केवल 80 वर्णों को प्रदर्शित करना है (यह लिनक्स पर डिफ़ॉल्ट टर्मिनल आकार है)
• केवल ASCII से इन 95 मुद्रण योग्य पात्रों की अनुमति है
• कदम:
  1. प्रारंभिक तारा *क्षैतिज और लंबवत होना चाहिए
  2. स्टार को यह दिखाने के लिए विकसित करना होगा कि वह विस्फोट करता है
  3. अंत में स्क्रीन खाली होना चाहिए (स्टार गायब हो गया है)
• कोड या भाषाओं की लंबाई अप्रासंगिक है
• वोट सबसे रचनात्मक और सुंदर परिणामों का फैसला करेंगे। क्या आपने कभी एक विस्फोट करने वाला तारा देखा है? आइए देखें कि आप इसकी कल्पना कैसे करते हैं।

मैंने एक उदाहरण के रूप में पायथन का उपयोग करके एक उत्तर जोड़ा है, लेकिन आपको कुछ अलग या बेहतर बनाने के लिए प्रोत्साहित किया जाता है।

आपके पास भाग लेने के लिए एक सप्ताह है, विजेता को 2014-04-01 को चुना जाएगा।

उत्पादन के नमूने (केवल कुछ फ्रेम के साथ):

# start





                                        *





# during explosion

                                    ****#****
                                 ***#@##*#@#****
                               *@**@@@*##**#*#**#*
                              **@@*#**#@*#@****#***
                              ****@*@***#****@**@@*
                             *******@***@@***#****#*
                              *#***#*##@****##@@@**
                              **#@###****@*********
                               *****@**@*@*****@**
                                 ************@**
                                    ****#****


# star is expanding

                                        *                                       
                               ********* **@******
                           ****   **#**@ #**#*#   ****
                         ***  **  **##** *@@*@*  **  ***
                       **  *  @@   *@*#* ***@*   *#  *  **
                     *** #  *  *#  *@#** ***@*  **  @  * *@*
                    ** *  * ** *@  ****@ @****  ** #* *  * **
                   ** * @* * ** *@  #### *#**  ** ** * @* * **
                  *# * # ** * #* *  **** ****  @ ** * ** * * #*
                 ** * *# * @ * #  @  @*@ *#*  *  @ # # * @* * **
                 *# * * * * # * @* * **# *#* * ** * * * * * # **
                 ** # * * @ * * # * # ** @* * * * * * # @ @ * **
                *# * * * * * * * * # * * * * * * @ @ * * * * * **
                 *# * @ * @ * @ * * * ** *@ * * # * * * * * @ @*
                 *# # @ * * # * *@ * *** @#@ @ ** * @ @ * * # **
                 *# * ** * * * @  @  **@ ***  *  @ * * * @* * #*
                  ** * * ** * #@ *  #*** **##  * #* * #@ * * @*
                   *# * *@ * @@ *#  **** @***  ** ** * #* * #*
                    *# *  * *@ **  @**@* *@#**  ** ** *  * @*
                     *#* @  *  @@  **##* ****@  **  #  * @**
                       **  @  #*   @*@#* @*@*#   @#  *  **
                         *#*  @*  @#*@*# **#*@#  **  ***
                           ****   *##**# #***@*   @***
                               ****@**@* *****@***

# star is disappearing

               *  -  -  --  --   ------- -------   --  --  -  -  *
             ** -  -  -  --  --   ------ ------   --  --  -  -  - **
            * -- - -- -- --  --   ------ ------   --  -- -- -- - -- *
          ** - -  - -- -- --  --  ------ ------  --  -- -- -- -  - - **
         *  - - -- - -- -  -  --   ----- -----   --  -  - -- - -- - -  *
        ** - - - -- - -- -  -  --  ----- -----  --  -  - -- - -- - - - **
        * - - - -  - - -  - -- --  ----- -----  -- -- -  - - -  - - - - *
       * - - - -  - - - -- - -- --  ---- ----  -- -- - -- - - -  - - - - *
      * -- - - - - - - - -- - -- -  ---- ----  - -- - -- - - - - - - - -- *
      * - - - - - - - -- - - - -  -  --- ---  -  - - - - -- - - - - - - - *
      * - - - - - - - - - - - - -- - --- --- - -- - - - - - - - - - - - - *
      * - - - - - - - - - - - - - - - -- -- - - - - - - - - - - - - - - - *
     * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - *
      * - - - - - - - - - - - - - - - -- -- - - - - - - - - - - - - - - - *
      * - - - - - - - - - - - - -- - --- --- - -- - - - - - - - - - - - - *
      * - - - - - - - -- - - - -  -  --- ---  -  - - - - -- - - - - - - - *
      * -- - - - - - - - -- - -- -  ---- ----  - -- - -- - - - - - - - -- *
       * - - - -  - - - -- - -- --  ---- ----  -- -- - -- - - -  - - - - *
        * - - - -  - - -  - -- --  ----- -----  -- -- -  - - -  - - - - *
        ** - - - -- - -- -  -  --  ----- -----  --  -  - -- - -- - - - **
         *  - - -- - -- -  -  --   ----- -----   --  -  - -- - -- - -  *
          ** - -  - -- -- --  --  ------ ------  --  -- -- -- -  - - **
            * -- - -- -- --  --   ------ ------   --  -- -- -- - -- *
             ** -  -  -  --  --   ------ ------   --  --  -  -  - **

# the star is gone
















(there is nothing)

उत्पादन का एनिमेटेड उदाहरण:

यदि आप कुछ प्रेरणा चाहते हैं, तो आप 1988 के खेल कैप्टन ब्लड के एक विस्फोट को देख सकते हैं ।

Comments

वास्तव में यह निर्धारित करने के लिए यहां कोई युक्ति नहीं है कि कोई उत्तर " सही " है या नहीं।

— पीटर टेलर

मैं शब्द को हटाने कर रहा हूँ सही सवाल से। सबसे लोकप्रिय उत्तर को विजेता घोषित किया जाएगा।

— AL

शब्द प्रश्न में है या नहीं, सभी प्रश्नों में एक स्पष्ट कल्पना होनी चाहिए कि किन उत्तरों को मापा जा सकता है।

— पीटर टेलर

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

— AL

कृपया बताएं कि क्या नियम पर्याप्त स्पष्ट नहीं हैं और मैं उन्हें कैसे सुधार सकता हूं।

— AL

Answer 1

C + शाप

मैंने स्रोत कोड को साफ करने के लिए बहुत प्रयास नहीं किया है। मूल रूप से यह एक विस्तार शॉक वेव की गणना करता है, जिसमें एक ठोस पृष्ठभूमि के साथ पहले कुछ फ्रेम में एक तरह का फ्लैश इफेक्ट दिया जाता है। [[EDIT: विस्फोट एक एकल तारांकन से थोड़ा अजीब दिखाई देता है, इसलिए मैंने एनीमेशन की शुरुआत में विस्तार के कुछ फ्रेम जोड़े।]

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

#include <curses.h>
#include <stdlib.h>
#include <math.h>

#define NUM_FRAMES 150
#define NUM_BLOBS 800
#define PERSPECTIVE 50.0

typedef struct {
  double x,y,z;
} spaceblob;

double prng() {
  static long long s=1;
  s = s * 1488248101 + 981577151;
  return ((s % 65536) - 32768) / 32768.0;
}

int main() {
  char *frames[NUM_FRAMES], *p;
  int i,j,x,y,z,v,rows,cols,ith,i0;
  int maxx,minx,maxy,miny,delay=1E6;
  double bx,by,bz,br,r,th,t;
  spaceblob *blobs;

  /* Initialize ncurses and get window dimensions */
  initscr();
  getmaxyx(stdscr,rows,cols);
  minx = -cols / 2;
  maxx = cols+minx-1;
  miny = -rows / 2;
  maxy = rows+miny-1;

  /* Generate random blob coordinates */
  blobs = malloc(NUM_BLOBS * sizeof(spaceblob));
  for (i=0; i<NUM_BLOBS; i++) {
    bx = prng();
    by = prng();
    bz = prng();
    br = sqrt(bx*bx + by*by + bz*bz);
    blobs[i].x = (bx / br) * (1.3 + 0.2 * prng());
    blobs[i].y = (0.5 * by / br) * (1.3 + 0.2 * prng());;
    blobs[i].z = (bz / br) * (1.3 + 0.2 * prng());;
  }

  /* Generate animation frames */
  for (i=0; i<NUM_FRAMES; i++) {
    t = (1. * i) / NUM_FRAMES;
    p = frames[i] = malloc(cols * rows + 1);
    for (y=miny; y<=maxy; y++) {
      for (x=minx; x<=maxx; x++) {

        /* Show a single '*' in first frame */
        if (i==0) {
          *p++ = (x==0 && y==0) ? '*' : ' ';
          continue;
        }

        /* Show expanding star in next 7 frames */
        if (i<8) {
          r = sqrt(x*x + 4*y*y);
          *p++ = (r < i*2) ? '@' : ' ';
          continue;
        }

        /* Otherwise show blast wave */
        r = sqrt(x*x + 4*y*y) * (0.5 + (prng()/3.0)*cos(16.*atan2(y*2.+0.01,x+0.01))*.3);
        ith = 32 + th * 32. * M_1_PI;
        v = i - r - 7;
        if (v<0) *p++ = (i<19)?"%@W#H=+~-:."[i-8]:' '; /* initial flash */
        else if (v<20) *p++ = " .:!HIOMW#%$&@08O=+-"[v];
        else *p++=' ';
      }
    }

    /* Add blobs with perspective effect */
    if (i>6) {
      i0 = i-6;
      for (j=0; j<NUM_BLOBS; j++) {
        bx = blobs[j].x * i0;
        by = blobs[j].y * i0;
        bz = blobs[j].z * i0;
        if (bz<5-PERSPECTIVE || bz>PERSPECTIVE) continue;
        x = cols / 2 + bx * PERSPECTIVE / (bz+PERSPECTIVE);
        y = rows / 2 + by * PERSPECTIVE / (bz+PERSPECTIVE);
        if (x>=0 && x<cols && y>=0 && y<rows)
          frames[i][x+y*cols] = (bz>40) ? '.' : (bz>-20) ? 'o' : '@';
      }
    }

    /* Terminate the text string for this frame */
    *p = '\0';
  }

  /* Now play back the frames in sequence */
  curs_set(0); /* hide text cursor (supposedly) */
  for (i=0; i<NUM_FRAMES; i++) {
    erase();
    mvaddstr(0,0,frames[i]);
    refresh();
    usleep(delay);
    delay=33333; /* Change to 30fps after first frame */
  }
  curs_set(1); /* unhide cursor */
  endwin(); /* Exit ncurses */
  return 0;
}

Comments

यह अच्छा है! क्या आप बता सकते हैं कि आपने टर्मिनल इमेज को कैसे कैप्चर किया है? मुझे लगता है कि जब आप टाइप कर रहे हों तो आपको उस हिस्से को कम करना चाहिए, अगर आपने इसे दर्शक को छेड़ने के लिए नहीं जोड़ा है।

— अल

@ n.1 आप सही कह रहे हैं - यह थोड़ा सा खींच रहा था। मैं स्क्रीन पर कब्जा करने के लिए IShowU का उपयोग करता हूं , और एनिमेटेड GIF बनाने के लिए QuickTime से ImageMagick तक फ्रेम निर्यात करता हूं , और फिर GIF एनीमेशन का अनुकूलन करने के लिए Gifsicle का उपयोग करता हूं। यह वास्तव में एक विचार है। अगर आपको एक बेहतर तरीका मिल गया है तो मुझे बताएं।

— r3mainer

Answer 2

जावास्क्रिप्ट

सोचा कि यह जेएस में एक शॉट के लायक था। बचत और चलाने का सुझाव दें; यदि आप कंसोल में पेस्ट करते हैं तो बहुत धीमी गति से।

var boomboom = (function() {
    //Clear any existing page
    document.getElementsByTagName("body")[0].innerHTML="";

    var space=document.createElement("div");
    var iterator=0;
    var stars = 50;
    var timer=100;

    //Set container
    space.setAttribute("id","space");
    space.setAttribute("style","width:1000px;height:600px;margin:auto;border:solid 1px #000;position:relative;overflow:hidden;background:#000;color:#fff");
    document.getElementsByTagName("body")[0].appendChild(space);

    //Set interval and draw...
    var interval = setInterval(function(){ drawStars(iterator,stars); }, timer);
    drawStars(iterator, stars);

    function drawStars(r,c) {
        clearInterval(interval);

        //a container for this set of stars
        var starContainer=document.createElement("div");

        //don't draw more if there are too many, it's got to go
        if(iterator < 1000) {
            for(var i = 0; i < c; i++) {
                var x,y;

                if(iterator < 100) {
                    x=500 + r * Math.cos(2 * Math.PI * i / c) * 0.7;
                    y=300 + r * Math.sin(2 * Math.PI * i / c) * 0.7;
                }

                //add some randomness for the boom boom
                if(iterator > 100) { 
                    x=500 + r * Math.cos(2 * Math.PI * i / c) * 0.7*Math.random();
                    y=300 + r * Math.sin(2 * Math.PI * i / c) * 0.7*Math.random();
                }

                //Make a star
                var star=document.createElement("div");
                star.setAttribute("class","star");

                //Exploding stars are red, I hope
                var color = iterator < 100 ? "color:#fff" : "color:rgb("+parseInt(255*Math.random())+",0,0)";
                star.setAttribute("style","position:absolute; left:"+ x +"px;top:"+ y +"px;"+color);

                //Change the star character as boom boom gets bigger
                if(iterator <= 200) {
                    star.innerText="*";
                }
                else if(iterator >=200 & iterator <= 400) {
                    star.innerText="O";
                }
                else  {
                    star.innerText="-";
                }
                //Add the star to its container
                starContainer.appendChild(star);
            }
        }
        //draw the container
        space.appendChild(starContainer);

        //increment the iterator.  It's an iterator because we're using intervals and it's late.
        iterator+=5;

        //remove stars when we get too many
        if(iterator > 200) {
            space.removeChild(space.firstChild);
        }
        if(iterator < 1500) { //do it all again
            timer = timer > 10 ? timer-10 : timer;
            interval=setInterval(function(){ drawStars(iterator,stars); }, timer);
        }

        //make sure it's actually empty
        else {
            space.innerHTML="";
        }
    }
}());

JSBin में संपादन : http://jsbin.com/worofeqi/5/watch?js,output

JSBin की तुलना में स्थानीय फ़ाइल सिस्टम से किए जाने पर अजीब तरह से अधिक सुचारू रूप से चलता है। ईमानदारी से यकीन नहीं क्यों; इस शाम को देख सकते हैं।

Comments

क्या आप कृपया इसे jsfiddle, jsbin या किसी अन्य वेबसाइट पर रख सकते हैं जहाँ हम आसानी से देख सकते हैं? प्रश्न जोड़ते समय मैंने केवल एक टर्मिनल में परिणाम प्रदर्शित करने के बारे में सोचा था, लेकिन मैं अब उन नियमों को अपडेट नहीं करूंगा जो आपने अपना उत्तर जोड़ा है, मुझे इस नियम को पहले जोड़ना चाहिए था।

— अल

उत्तर अपडेट किया गया है (ध्यान दें (बहुत ही अजीब) चेतावनी)

— डेव फोर्बर

Answer 3

अजगर

#!/usr/bin/python

import sys, math, time, random

def distance(x, y):
    # ((y - y_center) * 2) -> correct ratio for a true circle
    return math.ceil(math.sqrt(((x - 40) ** 2) + (((y - 12) * 2) ** 2)))

def star(radiuses):
    for r in radiuses:
        #~ clear screen: http://stackoverflow.com/a/2084521/2257664
        print chr(27) + "[2J"

        # width
        for y in range(24):
            # height
            for x in range(80):
                d = distance(x, y)

                #~ border
                if (d == r):
                    sys.stdout.write('*')
                #~ inside the star
                elif (d < r):
                    if (r > 35):
                        sys.stdout.write(' ')
                    elif (r > 25) and ((d % 2) != 0):
                        sys.stdout.write('-')
                    elif (r > 15) and ((d % 2) == 0):
                        sys.stdout.write(' ')
                    else :
                        sys.stdout.write(random.choice('****#@'))
                #~ space outside the star
                else:
                    sys.stdout.write(' ')
            print
        time.sleep(0.1)

star(range(0, 12) + range(10, 0, -1) + range(0, 50))

उदाहरण आउटपुट (कम चरणों का उपयोग और स्क्रीन को साफ़ किए बिना)।

आउटपुट के अंश भी प्रश्न में प्रदर्शित किए जाते हैं।