উইন্ডোজ এমই স্ক্রিনসেভারকে ASCII হিসাবে পুনরুদ্ধার করুন

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 এর মান হতে পারে your আপনার কনসোলের সীমানা অতিক্রম করবেন না। (উদাহরণ: উইন্ডোজ 80x25 সেন্টিমিটার উইন্ডো)

আউটপুট

আপনার প্রোগ্রাম / ফাংশনের আউটপুট স্ক্রিনে মুদ্রণ করা উচিত, বা কোনও ফাংশন থেকে ফিরে আসতে হবে। আপনার প্রোগ্রামের প্রতিটি রানের জন্য পাইপের একটি আলাদা সেট তৈরি করা উচিত।

পরীক্ষার মামলা

নিম্নলিখিত পরীক্ষার ক্ষেত্রে বৈধ আউটপুটগুলির সমস্ত এলোমেলো উদাহরণ

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

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

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

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

স্পষ্টতই, যত বেশি টিকটিক ঘটনা ঘটেছে, আপনার প্রোগ্রামটির বৈধতা প্রমাণ করা তত কঠিন। অতএব, আপনার আউটপুট চলমান একটি gif পোস্ট করা পছন্দ করা হবে। যদি এটি সম্ভব না হয় তবে দয়া করে আপনার কোডের একটি সংস্করণ পোস্ট করুন যার মধ্যে আউটপুট মুদ্রণ রয়েছে includes স্পষ্টতই, এটি আপনার স্কোরের পক্ষে গণনা করবে না।

বিধি

• এটি কোড-গল্ফ , সংক্ষিপ্ত পরিমাণে বাইট জিতেছে
• স্ট্যান্ডার্ড লুফোলস প্রযোজ্য
• আপনি যদি আপনার উত্স কোডটিতে ইউনিকোড পাইপ অক্ষর ব্যবহার করেন তবে আপনি সেগুলি একটি একক বাইট হিসাবে গণনা করতে পারেন

এটি বেশ কঠিন চ্যালেঞ্জ যা সম্ভবত অনেকগুলি সৃজনশীল উপায়ে সমাধান করা যেতে পারে, সংক্ষিপ্ত esolangs এর উত্তর ইতিমধ্যে থাকা সত্ত্বেও আপনাকে আরও ভার্জিক ভাষায় একটি উত্তর লিখতে উত্সাহিত করা হবে। এটি প্রতি ভাষাতে সংক্ষিপ্ত উত্তরগুলির একটি ক্যাটালগ তৈরি করবে। অভিনব রঙিন জিআইএফ জন্য বোনাস আপবোটস;)

শুভ গল্ফিং!

দাবি অস্বীকার: আমি জানি যে ইউনিকোডের অক্ষরগুলি ASCII নয়, তবে আরও ভাল নামের অভাবে আমি এটিকে কেবল ASCII আর্ট বলি। পরামর্শ স্বাগত জানাই :)

Comments

আউটপুটটিতে আপনি যে ইউনিকোড অক্ষর চান তা ASCII নয়।

— গম উইজার্ড

আমি মনে করি - রেফারেন্সেরascii-art পরিবর্তে এটি ট্যাগ করা উচিতgraphical-output

— অ্যাডমবর্কবার্ক

নস্টালজিয়া এবং উইন্ডোজ এমই একই লাইনে ভাল

— মানায় না

3 ডি পাইপস স্ক্রিনসেভার উইন্ডোজ এমইকে পূর্বাভাস দেয়।

— নীল

@ জর্ডান আমি ভেবেছিলাম তার অর্থ টিপলস।

— কার্লকাস্টোর

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

ঠিক যখন আমি ভেবেছিলাম কিউ বেসিক আসলে একটি গল্ফ চ্যালেঞ্জ জিততে পারে। ;) একটি upvote আছে।

— DLosc

Answer 2

কিছুই নস্টালজিয়া বেশ মত বলে না ...

কিউ বেসিক, 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

কিউ বেসিক কার্যটির জন্য সঠিক ভাষা কারণ:

• এর এনকোডিংয়ে বাক্স অঙ্কনের অক্ষর রয়েছে - ইউনিকোডের প্রয়োজন নেই
• LOCATE আপনাকে স্ক্রিনের যে কোনও জায়গায় মুদ্রণ করতে দেয়, পূর্বে সেখানে কী ছিল তা ওভাররাইট করে
• মাইক্রোসফ্ট ^®

সুনির্দিষ্ট

এই QBasic golfed, লিখিত এবং এর পরীক্ষা করা হয় QB64 autoformatting বন্ধ পরিণত হয়। আপনি যদি এটিকে প্রকৃত কিউবাসিক আইডিইতে টাইপ / পেস্ট করেন তবে এটি একগুচ্ছ স্পেস যুক্ত করবে এবং এতে প্রসারিত ?হবে PRINTতবে এটি ঠিক একইভাবে চালানো উচিত।

প্রোগ্রামটি তিনটি কমা-বিভাজিত মানগুলি অন্তর্ভুক্ত করে: টিক্স, প্রস্থ এবং উচ্চতা। এরপরে এলোমেলো সংখ্যার বীজ চাইবে। (যদি এই আচরণটি গ্রহণযোগ্য না হয় তবে দ্বিতীয় লাইনটি RANDOMIZE TIMER+6 বাইটের জন্য পরিবর্তন করুন )) অবশেষে, এটি পাইপগুলি স্ক্রিনে আঁকবে।

সর্বাধিক মাত্রাগুলি প্রবেশ করা যেতে পারে 25 (উচ্চতা) দ্বারা 80 (প্রস্থ)। 25 উচ্চতা দেওয়ার ফলে নীচের সারিটি কাটবে যখন কিউ বেসিক বলে "চালিয়ে যেতে কোনও কী টিপুন।"

কিভাবে?

টিএল; ডিআর: প্রচুর গণিত।

বর্তমান সারি এবং কলামটি হ'ল rএবং c; বর্তমান অভিমুখ হল dএবং পূর্ববর্তী দিক হল b। দিকের মান 0-3 হ'ল ডাউন, ডান, উপরে, বাম দিকে। পাটিগণিত জন্য সঠিক পদক্ষেপ মান মধ্যে যারা অনুবাদ করে rএবং c, সেইসাথে সঠিক প্রান্ত স্থানাঙ্ক উপর শুরু।

বক্স অঙ্কনের অক্ষরগুলি │┐└─┘┌কিউ বেসিকের কোড পয়েন্ট 179, 191, 192, 196, 217 এবং 218। এগুলি বেশ এলোমেলো প্রদর্শিত হয়, তবে শর্তসাপেক্ষ বিবৃতিগুলি না করার চেয়ে কিছু সংখ্যক সংখ্যক জেনারেট তৈরি করতে এটি যথেষ্ট অক্ষর ব্যবহার করে (বেশ সমৃদ্ধ, আমি নিশ্চিত নই-এমনকি আমি বুঝতে পারি)

দিক পরিবর্তন করার কোডটি -0.125 এবং 1.125 এর মধ্যে একটি এলোমেলো সংখ্যা তৈরি করে এবং এর তল নেয় takes এটি -110% সময়, 080% সময় এবং 110% সময় দেয়। তারপরে আমরা এটিকে dMod এর বর্তমান মানটিতে যুক্ত করব 0 0 যোগ করার ফলে বর্তমান দিকটি বজায় থাকে; +/- 1 যুক্ত করা একটি মোড় দেয়।

নিয়ন্ত্রণ প্রবাহ হিসাবে, WHILE t ... WENDপ্রধান লুপ; এর আগের বিভাগটি, লাইন নম্বর 1( 1b=INT(RND*4)) দিয়ে শুরু করে পাইপটি এলোমেলো প্রান্তে পুনরায় আরম্ভ করে। যখনই rএবং cআমরা উইন্ডো বাইরে থাকি GOTO 1।

আমাকে জিআইএফ দেখান!

আপনি এখানে যান:

এটি অ্যানিমেশন, রঙ এবং একটি স্বয়ংক্রিয় এলোমেলো বীজ সহ কিছুটা অদম্য সংস্করণ দ্বারা উত্পাদিত হয়েছিল:

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

আমি আমার এমএস-ডস ভি 6.22 ভিএম :-) এ এটি টাইপ করেছি

— নিল

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 বাইটস @ টুক্কাএক্সকে ধন্যবাদ

এটি repl

উদাহরণ রান

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 টি।

— Yytsi

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

পাঠযোগ্যতার জন্য আমি নতুন লাইন যুক্ত করেছি। এএনএসআই কোডগুলি সম্মান করে একটি টার্মিনাল সহ একটি লিনাক্স মেশিনের প্রয়োজন। রঙ আছে! আপনি রঙ সমর্থন সরিয়ে ফেললে এর দাম 17 বাইট কম tes

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

... তারপরে ল্যাম্বডাকে একটি ভেরিয়েবলের জন্য বরাদ্দ করুন 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]
}