ASCII के रूप में Windows ME स्क्रीनसेवर को फिर से बनाएँ

Question

यह चुनौती उबंटू स्टैक एक्सचेंज में इस जवाब से प्रेरित है ।

पहचान

पाइप के साथ विंडोज एमई स्क्रीनसेवर याद रखें ? उदासीनता को वापस लाने का समय!

चुनौती

आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो स्क्रीनसेवर के ASCII प्रतिनिधित्व को आउटपुट करेगा। स्क्रीनसेवर में एक एकल पाइप होना चाहिए जो अर्ध-यादृच्छिक दिशाओं में बढ़ेगा।
पाइप की शुरुआत को स्क्रीन की किसी भी सीमा पर बेतरतीब ढंग से रखा जाएगा और पाइप का टुकड़ा सीमा से सीधा होना चाहिए (कोने के पहले-पाइप या तो क्षैतिज या ऊर्ध्वाधर हो सकते हैं)। प्रत्येक टिक उस दिशा में बढ़ेगा जहां वह एक 80%अवसर पर (क्षैतिज / ऊर्ध्वाधर) का सामना कर रहा है या एक 20%मौका पर एक कोने ले जाएगा ।

पाइप का प्रतिनिधित्व

पाइप बनाने के लिए, 6 यूनिकोड वर्णों का उपयोग किया जाएगा

─    \u2500    horizontal pipe
│    \u2502    vertical pipe
┌    \u250C    upper left corner pipe
┐    \u2510    upper right corner pipe
└    \u2514    lower left corner pipe
┘    \u2518    lower right corner pipe

इनपुट

कार्यक्रम / फ़ंक्शन इनपुट के 3 मान लेगा, जिसे फ़ंक्शन मापदंडों के माध्यम से इकट्ठा किया जा सकता है या उपयोगकर्ता को संकेत दिया जा सकता है।

• टिक की मात्रा
• स्क्रीन की चौड़ाई
• स्क्रीन की ऊंचाई

टिक की मात्रा

हर टिक के लिए, स्क्रीन पर पाइप का एक टुकड़ा जोड़ा जाएगा। यदि वे एक ही स्थिति में अंडे देते हैं तो पाइप पुराने पाइप के टुकड़े को ओवरराइट कर देगा।

उदाहरण के लिए, आकार 3x3 की एक स्क्रीन लें

ticks == 3
─┐ 
 ┘ 


ticks == 4
─┐ 
└┘ 


ticks == 5
│┐ 
└┘ 

जब भी एक पाइप स्क्रीन से बाहर निकलता है, जैसा कि पिछले उदाहरण में 5 टिक्स में है, तो एक नया पाइप एक यादृच्छिक सीमा पर स्पॉन करेगा। उदाहरण के लिए:

ticks == 6
│┐ 
└┘ 
  ─

नए पाइप में क्षैतिज या ऊर्ध्वाधर होने का 50% मौका होना चाहिए।

स्क्रीन की चौड़ाई / ऊँचाई

स्क्रीन की चौड़ाई और ऊंचाई को एक ही मूल्य में जोड़ा जा सकता है अगर वह आपकी पसंद की भाषा में बेहतर हो। स्क्रीन की चौड़ाई और ऊँचाई का मान हमेशा न्यूनतम 1 और 255 का अधिकतम मान होगा। यदि आपकी पसंद की भाषा कंसोल या आउटपुट स्क्रीन का समर्थन करती है, जो 255x255 वर्णों की ग्रिड से छोटी है, तो आप मान सकते हैं कि चौड़ाई और ऊँचाई होगी अपने कंसोल की सीमाओं से अधिक नहीं। (उदाहरण: विंडोज 80x25 cmd विंडो)

उत्पादन

आपके प्रोग्राम / फ़ंक्शन का आउटपुट स्क्रीन पर प्रिंट होना चाहिए, या किसी फ़ंक्शन से लौटाया जाना चाहिए। आपके कार्यक्रम के हर रन के लिए, पाइप का एक अलग सेट उत्पन्न किया जाना चाहिए।

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

निम्नलिखित परीक्षण मामले वैध आउटपुट के सभी यादृच्छिक उदाहरण हैं

f(4, 3, 3)
 │
─┘
  │

f(5, 3, 3)
 │
─┘┌
  │

f(6, 3, 3)
─│
─┘┌
  │

f(7, 3, 3)
──
─┘┌
  │

जाहिर है, जो अधिक टिक गया है, वह आपके कार्यक्रम की वैधता को साबित करने के लिए कठिन हो जाता है। इसलिए, अपने आउटपुट को चलाने का एक gif पोस्ट करना पसंद किया जाएगा। यदि यह संभव नहीं है, तो कृपया अपने कोड का एक संस्करण पोस्ट करें जिसमें आउटपुट प्रिंट करना शामिल है। जाहिर है, यह आपके स्कोर की ओर नहीं गिना जाएगा।

नियम

• यह कोड-गोल्फ है , बाइट्स की सबसे कम राशि जीतती है
• मानक खामियां लागू होती हैं
• यदि आप अपने स्रोत कोड में यूनिकोड पाइप वर्णों का उपयोग करते हैं, तो आप उन्हें एकल बाइट के रूप में गिन सकते हैं

यह काफी कठिन चुनौती है जिसे संभवत: कई रचनात्मक तरीकों से हल किया जा सकता है, आपको और अधिक मौखिक भाषा में उत्तर लिखने के लिए प्रोत्साहित किया जाता है, हालांकि पहले से ही छोटे पलायन में उत्तर हैं। यह प्रति भाषा सबसे कम उत्तरों की एक सूची बनाएगा। फैंसी रंगीन gifs के लिए बोनस upvotes;)

हैप्पी गोल्फिंग!

अस्वीकरण: मुझे पता है कि यूनिकोड वर्ण ASCII नहीं हैं, लेकिन एक बेहतर नाम की कमी के कारण मैं इसे ASCII कला कहता हूं। सुझावों का स्वागत है :)

Comments

यूनिकोड वर्ण जो आप आउटपुट में चाहते हैं वह ASCII नहीं है।

— गेहूं जादूगर

मुझे लगता है कि इसे - संदर्भascii-artgraphical-output

— AdmBorkBork

नोस्टैल्जिया और विंडोज एमई एक ही पंक्ति में अच्छी तरह से फिट नहीं होते हैं

— लुइस मेंडो

3D पाइप्स स्क्रीनसेवर ने Windows ME की भविष्यवाणी की।

— नील

@ जोर्डन मुझे लगा कि उसका मतलब टुपल्स है।

— कार्लकैस्टर

Answer 1

जावास्क्रिप्ट (ईएस 6), 264 266 274 281

(t,w,h,r=n=>Math.random()*n|0,g=[...Array(h)].map(x=>Array(w).fill` `))=>((y=>{for(x=y;t--;d&1?y+=d-2:x+=d-1)x<w&y<h&&~x*~y?0:(d=r(4))&1?x=r(w,y=d&2?0:h-1):y=r(h,x=d?0:w-1),e=d,d=r(5)?d:2*r(2)-~d&3,g[y][x]="─└ ┌┐│┌  ┘─┐┘ └│"[e*4|d]})(w),g.map(x=>x.join``).join`
`)

यूनिकोड ड्रॉइंग वर्णों को 1 बाइट के रूप में गिनना। (ओपी द्वारा निर्दिष्ट)

कम गोल्फ वाला

(t,w,h)=>{
  r=n=>Math.random()*n|0; // integer range random function
  g=[...Array(h)].map(x=>Array(w).fill(' ')); // display grid
  for (x=y=w;t--;)
    x<w & y<h && ~x*~y||( // if passed boundary
      d = r(4), // select random direction
      d & 1? (x=r(w), y=d&2?0:h-1) : (y=r(h), x=d?0:w-1) // choose start position 
    ),
    e=d, d=r(5)?d:2*r(2)-~d&3, // change direction 20% of times
    g[y][x]="─└ ┌┐│┌  ┘─┐┘ └│"[e*4|d], // use char based on current+prev direction
    d&1 ? y+=d-2 : x+=d-1 // change x,y position based on direction
  return g.map(x=>x.join``).join`\n`
}

एनिमेटेड परीक्षण

नोट: एनीमेशन समय को 30 सेकंड से कम रखने की कोशिश कर रहा है, अधिक थिक्स एनीमेशन की गति को तेज करते हैं

f=(t,w,h,r=n=>Math.random()*n|0,g=[...Array(h)].map(x=>Array(w).fill` `))=>
{
  z=[]
  for(x=y=w;t--;d&1?y+=d-2:x+=d-1)
    x<w&y<h&&~x*~y?0:(d=r(4))&1?x=r(w,y=d&2?0:h-1):y=r(h,x=d?0:w-1),
    e=d,d=r(5)?d:2*r(2)-~d&3,g[y][x]="─└ ┌┐│┌  ┘─┐┘ └│"[e*4|d],
    z.push(g.map(x=>x.join``).join`\n`)
  return z
}

function go() {
  B.disabled=true
  var [t,w,h]=I.value.match(/\d+/g)
  var r=f(+t,+w,+h)
  O.style.width = w+'ch';
  var step=0
  var animate =_=>{
    S.textContent = step
    var frame= r[step++]
    if (frame) O.textContent = frame,setTimeout(animate, 30000/t);
    else   B.disabled=false
  }
  
  animate()
}

go()

#O { border: 1px solid #000 }

Input - ticks,width,height
<input value='600,70,10' id=I><button id=B onclick='go()'>GO</button>
<span id=S></span>
<pre id=O></pre>

Comments

बस जब मैंने सोचा कि QBasic वास्तव में एक गोल्फ चुनौती जीत सकता है। ;) एक उत्थान है।

— १

Answer 2

कुछ भी नहीं विषाद की तरह कहते हैं ...

QBasic, 332 बाइट्स

INPUT t,w,h
RANDOMIZE
CLS
1b=INT(RND*4)
d=b
IF b MOD 2THEN c=(b-1)/2*(w-1)+1:r=1+INT(RND*h)ELSE c=1+INT(RND*w):r=b/2*(h-1)+1
WHILE t
LOCATE r,c
m=(b+d)MOD 4
IF b=d THEN x=8.5*m ELSE x=13*m+(1<((b MOD m*3)+m)MOD 5)
?CHR$(179+x);
r=r-(d-1)MOD 2
c=c-(d-2)MOD 2
b=d
d=(4+d+INT(RND*1.25-.125))MOD 4
t=t-1
IF(r<=h)*(c<=w)*r*c=0GOTO 1
WEND

QBasic कार्य के लिए सही भाषा है क्योंकि:

• इसके एन्कोडिंग में बॉक्स ड्राइंग वर्ण शामिल हैं - यूनिकोड की कोई आवश्यकता नहीं है
• LOCATE आपको स्क्रीन पर किसी भी स्थान पर प्रिंट करने की अनुमति देता है, जो कि पहले था
• Microsoft ^®

विशिष्ट तथ्य

यह QBasic, लिखित और परीक्षण पर आधारित है QB64 ऑटोफॉर्माटिंग को बंद कर दिया गया है। यदि आप इसे वास्तविक QBasic IDE में टाइप / पेस्ट करते हैं, तो यह रिक्त स्थान का एक गुच्छा जोड़ देगा और इसमें विस्तार ?होगा PRINT, लेकिन इसे बिल्कुल उसी तरह चलना चाहिए।

कार्यक्रम में तीन अल्पविराम से अलग किए गए मान हैं: टिक, चौड़ाई और ऊंचाई। यह तो एक यादृच्छिक संख्या के बीज के लिए पूछता है। (यदि यह व्यवहार स्वीकार्य नहीं है, तो दूसरी पंक्ति को बदल देंRANDOMIZE TIMER +6 बाइट्स के लिए ।) अंत में, यह स्क्रीन पर पाइप खींचता है।

दर्ज किए जा सकने वाले अधिकतम आयाम 80 (चौड़ाई) 25 (ऊंचाई) हैं। 25 की ऊंचाई देने से निचली पंक्ति कट जाएगी जब QBasic कहता है "जारी रखने के लिए किसी भी कुंजी को दबाएं।"

कैसे?

टीएल; डीआर: गणित का एक बहुत।

वर्तमान पंक्ति और स्तंभ हैं rऔर c; वर्तमान दिशा है dऔर पिछली दिशा है b। दिशा मान 0-3 नीचे, दाएं, ऊपर, बाएं हैं। अंकगणित उन लोगों के लिए rऔर सही कदम मूल्यों में अनुवाद करता हैc साथ ही सही बढ़त शुरू करने के लिए समन्वय करता है।

बॉक्स ड्राइंग वर्ण │┐└─┘┌ कोड पॉइंट्स 179, 191, 192, 196, 217 और 218 क्यूबेसिक में हैं। वे बहुत यादृच्छिक दिखाई देते हैं, लेकिन यह अभी भी कम वर्णों का उपयोग करता है कुछ के साथ संख्या उत्पन्न करने के लिए (बहुत जटिल, मुझे यकीन नहीं है, यहां तक ​​कि मैं-समझ में यह) सशर्त बयानों का एक गुच्छा करने के लिए गणित की तुलना में।

दिशा बदलने के लिए कोड -0.125 और 1.125 के बीच एक यादृच्छिक संख्या उत्पन्न करता है और इसकी मंजिल लेता है। यह -110% समय, 080% समय और 110% समय देता है। फिर हम इसे वर्तमान मान में जोड़ते हैं d, mod 4। 0 को जोड़ने से वर्तमान दिशा बनी रहती है; +/- 1 जोड़ने से एक मोड़ आता है।

नियंत्रण प्रवाह के लिए, WHILE t ... WENDमुख्य लूप है; इससे पहले का खंड, लाइन नंबर 1( 1b=INT(RND*4)) के साथ शुरू होकर , एक यादृच्छिक किनारे पर पाइप को पुनरारंभ करता है। जब भी rऔर cखिड़की के बाहर होते हैं, हमGOTO 1 ।

मुझे GIF दिखाओ!

हेयर यू गो:

यह एनीमेशन, रंग, और एक स्वचालित यादृच्छिक बीज के साथ कुछ हद तक अनजाने संस्करण द्वारा उत्पन्न किया गया था:

INPUT t, w, h
RANDOMIZE TIMER
CLS

restart:
' Calculate an edge to start from

b = INT(RND * 4)
'0: top edge (moving down)
'1: left edge (moving right)
'2: bottom edge (moving up)
'3: right edge (moving left)
d = b

' Calculate column and row for a random point on that edge
IF b MOD 2 THEN
    c = (b - 1) / 2 * (w - 1) + 1
    r = 1 + INT(RND * h)
ELSE
    c = 1 + INT(RND * w)
    r = b / 2 * (h - 1) + 1
END IF
COLOR INT(RND * 15) + 1

WHILE t
    ' Mathemagic to generate the correct box-drawing character
    m = (b + d) MOD 4
    IF b = d THEN
        x = 17 * m / 2
    ELSE
        x = 13 * m + (1 < ((b MOD m * 3) + m) MOD 5)
    END IF
    LOCATE r, c
    PRINT CHR$(179 + x);

    ' Update row and column
    r = r - (d - 1) MOD 2
    c = c - (d - 2) MOD 2
    ' Generate new direction (10% turn one way, 10% turn the other way,
    ' 80% go straight)
    b = d
    d = (4 + d + INT(RND * 1.25 - .125)) MOD 4

    ' Pause
    z = TIMER
    WHILE TIMER < z + 0.01
        IF z > TIMER THEN z = z - 86400
    WEND

    t = t - 1
    IF r > h OR c > w OR r = 0 OR c = 0 THEN GOTO restart
WEND

Comments

मैंने इसे अपने MS-DOS v6.22 VM :-)

— नील

Answer 3

पायथन 2.7, 624 616 569 548 552 बाइट्स

from random import*
from time import*
i=randint
z=lambda a,b:dict(zip(a,b))
c={'u':z('lur',u'┐│┌'),'d':z('ldr',u'┘│└'),'l':z('uld',u'└─┌'),'r':z('urd',u'┘─┐')}
m=z('udlr',[[0,-1],[0,1],[-1,0],[1,0]])
def f(e,t,w,h):
 seed(e);s=[w*[' ',]for _ in' '*h]
 while t>0:
  _=i(0,1);x,y=((i(0,w-1),i(0,1)*(h-1)),(i(0,1)*(w-1),i(0,h-1)))[_];o=('du'[y>0],'rl'[x>0])[_]
  while t>0:
   d=c[o].keys()[i(7,16)//8];s[y][x]=c[o][d];x+=m[d][0];y+=m[d][1];t-=1;sleep(.5);print'\n'.join([''.join(k)for k in s]);o=d
   if(x*y<0)+(x>=w)+(y>=h):break

पहला पैरामीटर एक बीज है, एक ही बीज एक ही आउटपुट उत्पन्न करेगा, प्रत्येक चरण को 500 एमएस विलंब के साथ प्रिंट करेगा।

• -10 बाइट्स @TuukkaX को धन्यवाद

इसका जवाब दो

उदाहरण चलाते हैं

f(5,6,3,3)

उत्पादन होगा

   

  ┐

   

 ─┐ 

   

──┐ 

   

┘─┐ 

   
┐  
┘─┐ 

वर्बोज़ संस्करण

import random as r
from time import *
char={
'u':{'u':'│','l':'┐','r':'┌'},
'd':{'d':'│','l':'┘','r':'└'},
'l':{'u':'└','d':'┌','l':'─'},
'r':{'u':'┘','d':'┐','r':'─'}
}
move={'u':[0,-1],'d':[0,1],'l':[-1,0],'r':[1,0]}
def f(seed,steps,w,h):
 r.seed(seed)
 screen=[[' ',]*w for _ in ' '*h]
 while steps > 0:
  if r.randint(0,1):
   x,y=r.randint(0,w-1),r.randint(0,1)*(h-1)
   origin='du'[y>0]  
  else:
   x,y=r.randint(0,1)*(w-1),r.randint(0,h-1)
   origin = 'rl'[x>0]
  while steps > 0:
   direction = char[origin].keys()[r.randint(0,2)]
   screen[y][x]=char[origin][direction]
   x+=move[direction][0]
   y+=move[direction][1]
   steps-=1
   sleep(0.5)
   print '\n'.join([''.join(k) for k in screen]),''
   if x<0 or y<0 or x>=w or y>=h:
    break
   origin=direction

Comments

वहाँ एक बेकार व्हाट्सएप है if x*y<0 or। 0.5को कम किया जा सकता है .5। import *हो सकता है import*।''.join(k) forएक बेकार व्हाट्सएप है। आपको dictएक चर में रखने और इसे हर बार उपयोग करने के लिए कॉल करने में सक्षम होना चाहिए । यह परीक्षण नहीं किया गया है कि यह कितना बचाता है, लेकिन dict(zip(a,b))दो स्ट्रिंग्स (ए, बी) के लिए काम करने वाले लैम्ब्डा में बचत करके , इसे कुछ काटना चाहिए। +1।

— 19

Answer 4

सी (जीसीसी / लाइनक्स), 402 353 352 302 300 298 296 288 बाइट्स

#define R rand()%
x,y,w,h,r;main(c){srand(time(0));scanf(
"%d%d",&w,&h);for(printf("\e[2J");x%~w*
(y%~h)||(c=R 8,(r=R 4)&1?x=1+R w,y=r&2
?1:h:(y=1+R h,x=r&2?1:w));usleep('??'))
printf("\e[%dm\e[%d;%dH\342\224%c\e[H\n",
30+c,y,x,2*"@J_FHAF__L@HL_JA"[r*4|(r^=R 5
?0:1|R 4)]),x+=--r%2,y+=~-r++%2;}

एकल 4-बिट संख्या में दिशा संचय करने के लिए edc65 को क्रेडिट।

स्क्रीनसेवर को हमेशा के लिए बंद करने से पहले स्टड पर एक चौड़ाई / ऊंचाई पढ़ता है। उदाहरण के लिए:

gcc -w golf.c && echo "25 25" | ./a.out

या एक पूर्ण स्क्रीन स्क्रीनसेवर के लिए:

gcc -w golf.c && resize | sed 's/[^0-9]*//g' | ./a.out

पठनीयता के लिए मैंने नई कड़ियाँ जोड़ीं। ANSI कोड का सम्मान करने वाले टर्मिनल के साथ एक linux मशीन की आवश्यकता होती है। रंग है! यदि आप रंग समर्थन को हटाते हैं तो इसकी लागत 17 बाइट कम होती है।

Answer 5

रूबी, 413 403 396 बाइट्स

एक फ़ंक्शन जो इनपुट के रूप में कई टिक और चौड़ाई लेता है और एक स्ट्रिंग के रूप में अंतिम स्क्रीन देता है। कोई शक नहीं कि अधिक गोल्फ हो सकता है।

->t,w{k=[-1,0,1,0,-1]
b=(" "*w+$/)*w
f=->t,a=[[0,m=rand(w),2],[w-1,m,0],[m,0,1],[m,w-1,3]].sample{n,m,i=a
d=k[i,2]
q=->n,m,i{_,g,j=rand>0.2?[[1,0],[3,0],[0,1],[2,1]].assoc(i):"021322033132243140251350".chars.map(&:to_i).each_slice(3).select{|c,|c==i}.sample
v,u=k[j||=i,2]
y=n+v
x=m+u
[g,y,x,j]}
g,y,x,j=q[n,m,i]
b[n*w+n+m]="─│┌┐┘└"[g]
y>=0&&y<w&&x>=0&&x<w ?t>1?f[t-1,[y,x,j]]:b:f[t]}
f[t]}

इसे repl.it पर देखें: https://repl.it/Db5h/4

इसे क्रिया में देखने के लिए, शुरू होने वाली लाइन के बाद निम्नलिखित डालें b[n*w+n+m]= :

puts b; sleep 0.2

... तो lambda को एक चर उदाहरण के लिए असाइन करें pipes=->... करें और इसे कॉल करें pipes[100,20]( जैसे 100 टिक और 20x20 स्क्रीन)।

अपुष्ट और व्याख्या

# Anonymous function
# t - Number of ticks
# w - Screen width
->t,w{
  # The cardinal directions ([y,x] vectors)
  # Up = k[0..1], Right = k[1..2] etc.
  k = [-1, 0, 1, 0, -1]

  # An empty screen as a string
  b = (" " * w + $/) * w

  # Main tick function (recursive)
  # t - The number of ticks remaining
  # a - The current position and vector index; if not given is generated randomly
  f = ->t,a=[[0,m=rand(w),2], [w-1,m,0], [m,0,1], [m,w-1,3]].sample{
    # Current row, column, and vector index
    n, m, i = a
    d = k[i,2] # Get vector by index

    # Function to get the next move based on the previous position (n,m) and direction (d)
    q = ->n,m,i{
      # Choose the next pipe (`g` for glyph) and get the subsequent vector index (j)
      _, g, j = (
        rand > 0.2 ?
          [[1,0], [3,0], [0,1], [2,1]].assoc(i) : # 80% of the time go straight
          "021322033132243140251350".chars.map(&:to_i).each_slice(3)
            .select{|c,|c==i}.sample
      )

      # Next vector (`v` for vertical, `u` for horizontal)
      # If straight, `j` will be nil so previous index `i` is used
      v, u = k[j||=i, 2]

      # Calculate next position
      y = n + v
      x = m + u

      # Return next glyph, position and vector index
      [g, y, x, j]
    }

    # Get next glyph, and subsequent position and vector index
    g, y, x, j = q[n, m, i]

    # Draw the glyph
    b[n * w + n + m] = "─│┌┐┘└"[g]

    # Check for out-of-bounds
    y >= 0 && y < w && x >=0 && x < w ?
      # In bounds; check number of ticks remaining
      t > 1 ?
        f[t-1, [y,x,j]] : # Ticks remain; start next iteration
        b : # No more ticks; return final screen

      # Out of bounds; repeat tick with new random start position
      f[t]
  }
  f[t]
}