स्क्रॉलिंग मार्की

13

Obfuscated Hello World में मेरे प्रवेश के बाद मुझे लगा कि अंतर्निहित कोड को साझा करना मजेदार हो सकता है। लेकिन सिर्फ कोड क्यों दिखाते हैं, इसे गोल्फ भी बनाते हैं!

चुनौती

एक स्क्रिप्ट लिखें, जो टर्मिनल के पार एक स्ट्रिंग स्क्रॉल करती है, दाईं से बाईं ओर, बाईं ओर बसती है।

इनपुट

एक स्ट्रिंग को एक तर्क के रूप में लेता है।

परिणाम

स्क्रॉल मार्की को STDOUT में प्रिंट करता है। अधिकतम चौड़ाई ~ 50 चार्ट। 0 या 1 चार शो के साथ शुरू होता है। स्क्रॉल करते समय अक्षरों के बीच कुछ जगह। बंद हो जाता है (शब्द वर्ण के बीच कोई अतिरिक्त स्थान नहीं) बंद हो जाता है। धीरे स्क्रॉल करें, लेकिन बहुत धीमा नहीं (<1s प्रति पुनरावृत्ति)।

उदाहरण

अर्ग के साथ स्क्रिप्ट चलाना 'Hello World' 

                                                   H

बाद में

                H    e    l    l    o         W    o

बाद में

H    e    l    l    o          W    o    r    l    d

बाद में

Hell    o         W    o    r    l    d

आखिरकार 

Hello World

एक चल रहे उदाहरण के लिए, "हैलो वर्ल्ड" चुनौती से मेरे कोड का प्रयास करें। आखिरकार मैं अपना पोस्ट करूंगा। वर्तमान में यह पर्ल में 202 चार्ट है। अब जबकि कुछ प्रतियोगी हैं, मैंने जवाबों में मेरा पोस्ट किया है।

विजेता

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

टिप्पणियाँ

यह खेल xtermपर्यावरण को मानता है। क्या एक और पर्यावरण उपयोगी साबित होना चाहिए, केवल समान वातावरण की तुलना की जाएगी और प्रत्येक के लिए एक अलग विजेता घोषित किया जा सकता है।

परिशिष्ट (25 अप्रैल, 2012)

कुछ नवोदित मुद्दों को संबोधित करने के लिए, मैं एक निर्णय ले रहा हूं। आपकी वर्ण गणना में आवश्यक कोड शामिल होना चाहिए:

  1. फ्लश STDOUT (रूबी को देखते हुए)
  2. sleep<1s के समय की देरी के साथ लागू करें (आप पर्ल को देखते हुए)

यह एक दुभाषिया के लिए कमांड लाइन स्विच के रूप में किया जा सकता है, लेकिन उन वर्णों की गिनती कुल (व्हॉट्सएप के आसपास के सैंस) में होती है।

code-golf  ascii-art 
— जोएल बर्जर
स्रोत
मैं इस तरह की चीज़ के लिए टर्मिनल व्यवहार के बारे में थोड़ा चिंतित हूं ... xterm, ... , vt102?
— dmckee --- पूर्व-मध्यस्थ ने बिल्ली
मैं xterm मान रहा हूं, लेकिन मुझे नहीं लगता कि यह बहुत ज्यादा मायने रखता है। शायद मैं आपकी चिंता नहीं समझता?
— जोएल बर्जर
ये ट्रिक्स आम तौर पर विभिन्न टर्मिनलों को गैर-मुद्रण वर्णों को संभालने के तरीके पर निर्भर करते हुए निर्मित होते हैं, और टर्मिनलों में अंतर होता है कि वे क्या कर सकते हैं और क्या अनुक्रम प्रभाव पैदा करते हैं। प्रतिलिपि प्रस्तुत करने योग्यता के लिए एक निर्दिष्ट टर्मिनल वातावरण होना अच्छा हो सकता है।
— dmckee --- पूर्व-मध्यस्थ ने बिल्ली
1
यह आपको सेवा प्रदान करेगा कि कोई व्यक्ति वास्तव में छोटा उत्तर पोस्ट करता है जो अस्पष्ट टर्मिनल पर निर्भर करता है कि आपके पास एमुलेटर नहीं है, लेकिन ठीक है।
— dmckee --- पूर्व-मध्यस्थ ने बिल्ली
ठीक है मुझे लगता है कि मेरे पास अभी है। विचारों के लिए धन्यवाद :-)
— जोएल बर्जर

जवाबों:

5

अजगर 2 - 146 चार्ट

संपादित करें: इसे स्टड के माध्यम से इनपुट के बजाय एक फ़ंक्शन बनाया। पहला तर्क स्ट्रिंग है, और दूसरा तर्क वह लंबाई है जिसे आप चाहते हैं। इसलिए मंगलाचरण होगा f('Hello World', 50)। मैंने इसे बहुत चिकना बना दिया; जब प्रत्येक पात्र 'उतरा' था तो एक अजीब-सा विराम था

import os,time
def f(x,n):
 y=' '*n+'  '.join(x);z=0
 while y:w=y[0]==x[z];y=y[1+w:];z+=w;os.system('cls');print((x[:z]+y)[:n]);time.sleep(0.1)

पुराना, 158 वर्ण:

import os,time,sys
x=' '.join(sys.argv[1:])
y=' '*50+'  '.join(x)
z=0
while y:z+=y[0]==x[z];y=y[1:];os.system('cls');print((x[:z]+y)[:50]);time.sleep(0.1)
— रंगीन जाकेट
स्रोत
बश का उपयोग करना (कम से कम हाल ही में मैकओएसएक्स और सेंटोस की स्थापना में), टर्मिनल स्क्रीन को खाली करने के लिए इस्तेमाल किया जाने वाला शेल कमांड 'क्लियर' होना चाहिए न कि 'क्लस'।
— पाओलो
विंडोज़ के लिए 'cls', OSX / Linux के लिए 'स्पष्ट', मुझे लगता है
— Blazer
उन लोगों के लिए कार्यक्रम कैसे शुरू करें, जो दैनिक आधार पर अजगर से निपटने के लिए नहीं, सहायक होंगे। अजगर शुरू करो। पेस्ट कोड, कॉल f("Hello World, 40)ने मेरे लिए काम किया।
— उपयोगकर्ता अज्ञात
@ युसर आई उम। मैंने वहां मंगलाचरण किया?
— ब्लेजर
4

रूबी, 93 91 89 चार्ट

u="\1";s=u*50+[*$*[0].chars]*(u*3);$><<s.tr(u," ")[0,50]+" \r"while s.sub!u,""*sleep(0.1)

प्रदर्शित किए जाने वाले पाठ को कमांड लाइन तर्क के रूप में दिया जाना चाहिए, जैसे

ruby marquee.rb "Hello World"

ऊपर दिखाए गए उदाहरण के लिए। दुर्भाग्य से मैं यहाँ एनीमेशन नहीं दिखा सकता हूँ, इसलिए आपको कोड को स्वयं आज़माना होगा।

पुराना वर्जन:

s=" "*67+[*$*[0].chars]*"   ";(s.size*3/4).times{|j|s[j/3]='';$><<s[16,50]+" \r";sleep 0.1}
— हावर्ड
स्रोत
प्रभावशाली आकार। हालांकि यह बहुत आसान नहीं है, यह है कि मैं (मैं इस समय बहुत कम बिजली की मशीन पर हूं) या यह है कि कोड कैसे काम करता है?
— जोएल बर्जर
यह पता चला, मुझे यह सेट करना पड़ा STDOUT.sync=true;ताकि यह ऑटोफ्लूश हो। पर्ल इक्विव है $|++। एक अतिरिक्त 17 वर्ण, लेकिन फिर भी खदान से नीचे। वैसे मैं रूबी की पिटाई नहीं कर सकता! गोना हफ्ता काम करवाता है। अच्छा है।
— जोएल बर्जर
अगर मुझे फोन किया जाता है ruby1.8 "Hello World", तो मेरे आश्चर्य को बिल्कुल नहीं, एक त्रुटि कह रही है:ruby1.8: No such file or directory -- Hello World (LoadError)
— उपयोगकर्ता अज्ञात
@userunknown शायद आपको स्रोत फ़ाइल के लिए पथ को वहां भी रखना चाहिए: ruby foo.rb args;-)
— पैट्रिक ऑस्सिटी
@पैड: हाँ, मुझे करना चाहिए। दुर्भाग्य से हावर्ड ने अपने बदलाव के बारे में मुझे बताए बिना अपने पोस्ट को संपादित किया। मेरे प्रश्न को समझने के लिए इतिहास पर एक नज़र डालें।
— उपयोगकर्ता अज्ञात
3

सी, 94 83 80 173 चार्ट

संपादित करें: बहुत सारे कोड जोड़े गए, सभी अनुरोधित कार्यक्षमता को लागू करता है। 1e8गति को नियंत्रित करने के लिए स्थिरांक को घुमाया जा सकता है। मेरी मशीन पर, यह बहुत तेज़ है क्योंकि यह है।
कुछ पात्रों को निश्चित रूप से यहां बचाया जा सकता है। lस्थिर हो सकता है (आरंभीकरण बचाता है), cएक सूचक (जगह b+c) बन सकता है ।

char b[99],c=1;
main(a,t,w,i,l)char**t;{
    for(l=0;b[l++]=*t[1]++;b[l++]=32);
    for(w=80;i--||
        printf("\033[F\033[K%*.*s\n",w-=l<a,a++,b,i=1e8)>l+6||
        b[++c]&&memmove(b+c-1,b+c,l););
}

पुराने संस्करण (80 वर्ण), आंशिक कार्यक्षमता के साथ: के साथ
बदलकर वर्णों के एक जोड़े को बचाया । 32-बिट में काम करता है ( 64-बिट का समर्थन करेगा)।char**tint*tint**t

main(i,t,w)
    int*t;
{
    for(w=80;i--||printf("\033[F\033[K%*s\n",w,t[1],i=1e8)*--w;);
}
— ugoren
स्रोत
2

K & R C - 431 416 अक्षर

मानक का उच्च स्तर तक सम्मान करता है। नर्सों का उपयोग करता है, इसलिए यह काफी हद तक स्वतंत्र होना चाहिए। जब स्ट्रिंग में इच्छित व्हाट्सएप को संरक्षित करने के लिए खेले जाने वाले कुछ प्रवंचना के कारण पाठ की तरफ से टकराता है तो थोड़ी सी अकड़न होती है।

उपयोग करने के लिए स्ट्रिंग को कमांड लाइन पर पहले तर्क के रूप में पारित किया जाना चाहिए (और यदि इसमें रिक्त स्थान शामिल हैं, तो बच जाना चाहिए, अगर यह !मेरे परीक्षण स्ट्रिंग के रूप में शामिल है Hello, World!तो)।

#include <ncurses.h>
#include <unistd.h>
#define T usleep(1e5),S(l)
#define U mvprintw(23,0,"%s",l),refresh()
char l[63],*p,*q,r;
S(char*s){r=0;if(*s==32)q=s++;else{for(;*s-32||*(s+1)-32;s++); 
for(q=s;*s==32;s++);(s-q)&1?s--:usleep(1e5);}
for(r=0;*s;*q++=*s++){*s-32?r=1:0;}return r;}
main(int c,char**v){initscr();curs_set(0);for(c=0;c<62;l[c++]=32);
for(p=*++v;*p;){l[52]=*p++;U;T;U;T;U;T;}for(;T;U);getch();endwin();}

अधिक पठनीय और टिप्पणी के रूप में:

#include <ncurses.h>
#include <unistd.h>

char l[63] /* take advantage of 0 initialization */,
  *p,*q, r;

/* Remove the first unwanted space. Unwanted means at the begining of
 * the line, all of even length blocks between non-spaces, and
 * all-bu-one of odd length blocks between non-spaces.
 *
 * Return true if the removed space occurs before a non-space character.
 */
S/*lide marquee*/(char*s){
  r=0; /* initialize the return value */
  if(*s==' '){
    q=s++;
  } else {
    /* Find the start of first block of contiguous spaces */
    for(;*s-' '||*(s+1)-' ';s++); 
    for(q=s;*s==' ';s++); /* q holds the start, s finds it's end */
    /* if this block is even length remove all, if odd, all but one */
    if( (s-q)%2 )s--; else usleep(1e5);
  }
  /* copy from s to q all the way to the end */
  for(r=0;*s;*q++=*s++){ 
    if(*s-' ')r=1; /* note if we pass a non-space */
  } 
  return r;
}

main(int c,char**v){
  initscr();curs_set(0); /* setup ncurses with invisible cursor */
  for(c=0;c<62;l[c++]=' '); /* initialize l */
  for(p=*++v;*p;){ /* load the message into the marque, skipping space */
    l[52]=*p++;
    mvprintw(23,0,"%s",l),
    refresh();
    usleep(1e5),
    S(l);
    usleep(1e5),
    S(l);
    usleep(1e5),
    S(l);
  }
  for(;usleep(1e5),S(l);mvprintw(23,0,"%s",l),refresh()); /* keeping sliding until we're done. */
  getch();
  endwin();
}
— dmckee --- पूर्व-मध्यस्थ बिल्ली का बच्चा
स्रोत
छोटा करने की बहुत संभावनाएं हैं, विशेष रूप से ifऑपरेटरों के साथ बदलकर । उदाहरण के लिए - if((s-q)%2)s--;else usleep(1e5);-> s-q&1?s--:usleep(1e5);(या s-=s-q&1||usleep(1e5);)
— बदसूरत
@ यूगोरेन: हाँ, और मैं ' 'संख्यात्मक समकक्षों के साथ एस को बदलना भूल गया था ।
— dmckee --- पूर्व-मध्यस्थ ने बिल्ली
कुछ और तरकीबें: x==32साथ बदलें x-32(अर्थ उलट, मतलब उल्टा अगर-और), या x<33(अनुमान के अनुसार 0..31 कभी इस्तेमाल नहीं किया गया)। आपके पास मूल्यों के साथ प्रारंभिक ( for(curs_set(c=0);...)। *(s+1)-> s[1]। अनावश्यक ब्रेसिज़ निकालें ( मदद करने के ;साथ प्रतिस्थापित करना ,)।
— ugoren
2

पर्ल 5.13.2, 96

$_=join$;x4,$;x46,split//,pop;print substr(s/$;/ /gr,0,50)." \r"while$|=s/$;//+select'','','',.1

@ केविन रीड के जवाब से बहुत कुछ चुराते हुए , विशेष रूप से /rनए पर्ल्स में उपलब्ध ट्रिक।

पर्ल, 115

@ जोएल बर्जर के जवाब की तरह, यह बहुत कम हो जाएगा यदि मैं उपयोग कर सकता हूं sleep 1और धीमा हो सकता है, या -MTime::HiRes=sleepसक्षम करने के लिए कमांड लाइन पर पास हो सकता है sleep.1। अन्यथा छोटी नींद लेने का एकमात्र तरीका है select'','','',.1जो बहुत लंबा है।

$|=@_=(($")x45,map{($")x4,$_}split//,pop);for(0..$#_){print@_," \r";splice@_,($_-=45)<0?0:$_/4,1;select'','','',.1}

पर्ल, 128

$_=$"x9 .pop;s/./    $&/g;$.=-46;$\=" \r";while($|=/./g){print substr($_,0,50);pos=++$.<0?0:$./4;s/\G.//;select'','','',.1}print

पर्ल, 133

$|=@_=split//,pop;for$i(reverse-$#_..50){for(@_){print$"x($j||$i),$_;($i+=$j=($i++>0)*4)>50&&last}print"    \r";$j=select'','','',.1}
— ephemient
स्रोत
हाँ, मैं अपने आप को उस एक पर अपने शासन के साथ थोड़ा सा! मुझे महसूस नहीं हुआ कि अन्य लंगूरों ने एक अच्छी तरह से बनाया होगा। ओह ठीक है।
— जोएल बर्जर
कुछ सुझाव, आप प्रत्येक के बाद स्थान को हटा सकते हैं xऔर कुछ को ब्लॉक के रूप में mapबचाएंगे।
— जोएल बर्जर
1

जावास्क्रिप्ट 180 218 वर्ण

उत्पादन संस्करण:

function f(){i--&&(i>50?h=h.substr(1):h=h.replace(" ",i==16?"&nbsp;":""),document.body.innerHTML="<pre>"+h.substr(0,50)+"</pre>",setTimeout(f,99))}h=(new Array(50)).join(" ")+"HelloWorld".split("").join("   "),i=80,f()

Ungolfed संस्करण:

h=new Array(50).join(" ")+("HelloWorld".split("").join("   "));
i=80;

function f(){
        if(i--){
            if(i>50){
                h=h.substr(1);
            }else{
                h=h.replace(" ",(i==16)?"&nbsp;":"");
            }
            document.body.innerHTML="<pre>"+h.substr(0,50)+"</pre>";
            setTimeout(f,99);
        }
}
f();​

यहाँ एक jsFiddle डेमो है

नोट: यदि आप इसे पुन: उत्पन्न करने का प्रयास करते हैं, तो सुनिश्चित करें कि कोड शरीर के नीचे है

— ajax333221
स्रोत
मैं डेमो से नहीं बता सकता, क्या यह बाईं ओर "स्टैक अप" करता है, या बस इसे बाईं ओर बनाता है और फिर अंतिम स्ट्रिंग दिखाता है? यदि आप अनिश्चित हैं तो हावर्ड निश्चित रूप से काम करता है।
— जोएल बर्जर
@JoelBerger हैलो दुनिया में प्रत्येक अक्षर के बीच 4 स्थान होते हैं, जब h पहला वर्ण होता है, तो ये रिक्त स्थान हटा दिए जाते हैं। यह डेमो धीमा है jsfiddle.net/fYvg7/1
— ajax333221
यह करीब है, लेकिन आपको प्रत्येक स्थान को व्यक्तिगत रूप से हटा देना चाहिए।
— जोएल बर्जर
@JoelBerger फिक्स्ड
— ajax333221
वैसे मुझे नाग से नफरत है, लेकिन एक और समस्या: आपकी शुरुआत सभी पत्रों के साथ होती है बजाय एक-एक के दाईं ओर प्रवेश करने की।
— जोएल बर्जर
1

पर्ल 5.13.2, 115 वर्ण

$_=$"x9 .pop=~y/ /\0/r;s/./    $&/g;print(y/\0/ /r=~/(.{50})/,"\r"),select$.,$.,$.,.02while$|=s/ (\S)/$1 /g;print$/
  • चेतावनी साफ।
  • पात्रों या प्रारंभिक व्हाट्सएप के बीच की जगह को कम करके थोड़ा निचोड़ा जा सकता है।
  • उपयोग के कारण पर्ल 5.13.2 या नए की आवश्यकता है /r।
  • रिक्त स्थान को संरक्षित करने के लिए NUL का प्रतिस्थापन अस्पष्ट है क्योंकि POSIX argv एनयूएल-स्वच्छ नहीं है। हालांकि, लूप प्रतिस्थापन किसी अन्य व्हाट्सएप को कुछ नहीं (अंततः) में बदल देगा।

क्रेडिट:

  • $"1 चरित्र द्वारा कमी, ephemient के उत्तर" " से लिए गए स्रोत के रूप में ।
— केविन रीड
स्रोत
मुझे rध्वज से प्यार है , भाषा के लिए सबसे अच्छा जोड़state
— जोएल बर्जर
1

मार 234

w=$1
p(){
i=$1
s=$2
p=$((50+s*3-i))
((p<s+1)) && p=$((s+1));
((p<50)) && echo -en "[20;"${p}H$3"  ";
}
clear
for i in {0..99}
do
for s in $(seq 0 ${#w})
do
p $i $s ${w:s:1} 
done
sleep .1
echo -en "[20;1H  "
done
echo -en "\b\b$w\n"

उपयोग: 

./marquee.sh "Hello, fine marquee world"

ungolfed: 

#!/bin/bash
w=$1
p(){
    #si String index
    it=$1
    #it=iteration
    si=$2
    pos=$((50+(si*3)-it))
    ((pos<si+1 )) && pos=$((si+1));
    ((pos<50)) && echo -en "[20;"${pos}H$3"  ";
}
clear
for it in {0..99}
do
    for si in $(seq 0 ${#w})
    do
        p $it $si ${w:si:1} 
    done
    sleep .1
    echo -en "[20;1H   "
done
echo -en "[22;1H"
— अज्ञात उपयोगकर्ता
स्रोत
1

आर, 319 वर्ण

@Bazazer उदाहरण के दर्शन के बाद (डी सेकंड में देरी है):

f=function(x,n=50,d=0.2){
    s=strsplit(x,"")[[1]];i=1;l=length
    while (i<(n+l(s)-1)){
        if(i<=l(s))cat(rep(" ", n-i),s[1:i])
        else if((i<=n)&&(i>l(s)))cat(rep(" ", n-i),s[1:l(s)])
        else cat(paste(s[1:(i-n+1)],collapse=""),s[(i-n+2):l(s)])
        Sys.sleep(d);system("clear");i=i+1
    }
    cat(paste(s[1:l(s)],collapse=""))
}

उपयोग:

f("Hello World",n=20,d=0.2)
— पाओलो
स्रोत
1

पर्ल : 144 133

$|=@s=(($")x50,map{$_,($")x4}@i=split//,pop);{$n=0;$s[$n]ne$_?last:$n++for@i;splice@s,$n,1;print"\r",@s[0..50];sleep.1;$n!=@i&&redo}

आप के रूप में चलाने की जरूरत है, हालांकि <1s की नींद पाने के लिए:

perl -MTime::HiRes=sleep scriptname 'string to print'

चूंकि मैं खुद को विजेता घोषित नहीं करूंगा, इसलिए मैं खुद से इस बात पर बहस नहीं करूंगा कि वहां क्या मायने रखता है या नहीं (लेकिन मैं वास्तव में रूबी को इस जीत नहीं दिला सकता हूं ;;;)

— जोएल बर्जर
स्रोत
4 और यह एक ट्वीट पर फिट बैठता है: D
— ajax333221
4 वर्ण यहीं: s/' '/$"/gऔरs/shift/pop/
— युगांतरकारी
हाँ, मैंने उन लोगों को शामिल किया था, साथ ही pushबयान को हटा दिया था। मैंने अभी इसे पोस्ट नहीं किया था।
— जोएल बर्गर
0

क्यू, 145

बिल्कुल आवश्यकताओं को पूरा नहीं करता है क्योंकि अंतिम पंक्ति उन सभी रिक्त स्थान को हटा देती है जो मूल इनपुट स्ट्रिंग में थे।

{c:2_'((!)(#)a)_'a:((l:3*(#)x)#" "),\(1_(,/)b,'x,'b:" ");{(-1 x;);system"sleep ",($)y}'[-1_c,(l-1)$d(!:)[d]except\(&)(^)d:((!)(#)q)!q:last c;y];}

इसमें दो तर्क, इनपुट स्ट्रिंग और स्क्रॉल गति होती है

q){c:2_'((!)(#)a)_'a:((l:3*(#)x)#" "),\(1_(,/)b,'x,'b:" ");{(-1 x;);system"sleep ",($)y}'[-1_c,(l-1)$d(!:)[d]except\(&)(^)d:((!)(#)q)!q:last c;y];}["hello";0.05]
             h
            h
           h
          h  e
         h  e
        h  e
       h  e  l
      h  e  l
     h  e  l
    h  e  l  l
   h  e  l  l
  h  e  l  l
 h  e  l  l  o
h  e  l  l  o
h e  l  l  o
he  l  l  o
he l  l  o
hel  l  o
hel l  o
hell  o
hell o
hello
— tmartin
स्रोत
दुर्भाग्य से यह एक महत्वपूर्ण बिंदु है। मुझे पता है कि पर्ल स्क्रिप्ट इसके बिना बहुत छोटी हो सकती है।
— जोएल बर्जर
0

पॉवरशेल, 135

बहुत गोल्फ नहीं है और शायद एक भयानक दृष्टिकोण है, लेकिन मैं बीमार हूं और वास्तव में सोच भी नहीं सकता ...

for($x="`r"+' '*50;$y-ne$x){$y=$x
write-host($x=$x-replace' ([^ ])','$1 ')-n
if(!($t++%5)){$x=$x-replace'.$',"$args"[$i++]}sleep -m 99}
— एक छोटा सा सिक्का
स्रोत
0

जे (116)

s(echo@((50#LF)&,)@([[i.@]&2e7)@(50&{.)@;@:(([,~#&' '@])&.>))"1([-=&0@/:@\:@:~:&0)^:(i.>:+/k)k=.50,3#~<:#s=.>2{ARGV

कमांड लाइन पर इनपुट स्ट्रिंग लेता है, अर्थात jconsole marquee.ijs 'Hello, world!'

अगर इसे स्क्रीन को साफ करने की जरूरत नहीं है, तो आउटपुट इस तरह है:

H  e  l  l  o
H e  l  l  o
He  l  l  o
He l  l  o
...

अनुमति है, यह 12 वर्णों से छोटा होगा।

स्पष्टीकरण:

  • s.=>2{ARGV: कमांड लाइन से स्ट्रिंग प्राप्त करें
  • k.=50,3#~<:#s: प्रत्येक वर्ण से पहले व्हाट्सएप की शुरुआती राशि जोड़ा गया, 50 पहले वाले से पहले और 3 अन्य सभी से पहले। (एक सरणी देता है, '50 3 3 3 ... ')
  • ([-=&0@/:@\:@~:&0): एक सरणी दी गई है, सरणी में पहला नॉनज़रो आइटम घटाता है
  • ^:(i.>:+/k): इस फ़ंक्शन ने N समय को लागू किया, जहां N जोड़ा गया व्हाट्सएप की राशि का 0 है। (एक मैट्रिक्स देता है: 50 3 3 3; 49 3 3 3; 48 3 3 3; ... 0 0 0 1; 0 0 0 0)।
  • "1: मैट्रिक्स की प्रत्येक पंक्ति पर फ़ंक्शन का अनुसरण करें
  • ;@:(([,~#&' '@])@.>): स्ट्रिंग में प्रत्येक वर्ण से पहले रिक्त स्थान की दी गई मात्रा जोड़ें
  • (50&{.): स्ट्रिंग के पहले 50 अक्षर लें
  • ([[i.@]&2e7): एक फ़ंक्शन जो सूची को 0 से 2 * 10 ^ 7 तक उत्पन्न करता है, और फिर इसे दूर फेंकता है। यह मेरी मशीन पर एक सेकंड का लगभग एक तिहाई लेता है, यह देरी का कारण बनता है।
  • ((50#LF)&,): स्क्रीन साफ़ करने के लिए, स्ट्रिंग से पहले 50 नई लिंक जोड़ें
  • echo: स्ट्रिंग का उत्पादन
  • s (...): फ़ंक्शन के लिए बाएं तर्क के रूप में स्ट्रिंग दें
— मारीनस
स्रोत
0

एपीएल (70)

{⎕SM∘←1,⍨1,⍨,/D{⍺,⍨⍵⍴⍕⍬}¨P←⍵-{⍵×~×⍺}\×⍵⊣⎕DL÷8⋄0∨.≠P:∇P}1↓⎕SD,1↓3⍴⍨⍴D←⍞

कीबोर्ड से इनपुट लेता है, आउटपुट ⎕SMविंडो में होता है (जो टर्मिनल होगा यदि आपके पास टेक्स्ट-आधारित एपीएल मुझे लगता है)। खिड़की का आकार स्वचालित रूप से पता लगाया जाता है, अगर आप वास्तव में चाहते हैं कि इसे 50 बदल दिया 1↓⎕SDजाए 50।

स्पष्टीकरण:

  • 1↓⎕SD,1↓3⍴⍨⍴D←⍞: स्ट्रिंग पढ़ें और स्टोर करें D। प्रत्येक वर्ण से पहले जोड़ने के लिए व्हाट्सएप का वर्णन करने वाला एक वेक्टर बनाएं, जो कि पहले वर्ण से पहले स्क्रीन की चौड़ाई है ( 1↓⎕SD), और 3 दूसरों से पहले ( 1↓3⍴⍨⍴D)।

  • ⎕DL÷8: एक सेकंड का 1/8 वां इंतजार करें

  • P←⍵-{⍵×~×⍺}\×⍵: सही तर्क में वेक्टर में, बाईं ओर के नॉनजरो आइटम से 1 घटाएं और पी में नए वेक्टर को स्टोर करें।
  • ,/D{⍺,⍨⍵⍴⍕⍬}¨P: D में प्रत्येक वर्ण के लिए, P में दिए गए व्हाट्सएप की मात्रा को उपसर्ग करें।
  • ⎕SM∘←1,⍨1,⍨: शीर्ष पंक्ति के बाएं कॉलम में स्क्रीन पर प्रदर्शित करें
  • 0∨.≠P:∇P: यदि पी में एक गैर-अक्ष तत्व है, तो पी के साथ दोहराएं।
— मारीनस
स्रोत
0

पॉवरशेल , 129 बाइट्स

for($x=' '*52+(($args|% t*y)-join' '*4);$x-match'  '){write-host "`r$(-join($x=$x-replace'(?<!  .*)  ')[0..50])  "-n
sleep -m 99}

इसे ऑनलाइन आज़माएं!

यह स्क्रिप्ट जॉय की स्क्रिप्ट के विपरीत तर्कों से रिक्त स्थान को नहीं हटाती है ।

TIOआउटपुट को सही ढंग से प्रदर्शित नहीं करता है। पॉवर्सशेल कंसोल के साथ, आपको स्क्रॉलिंग मार्कीलाइन मिलता है।

— Mazzy
स्रोत
0

05AB1E , 42 बाइट्स

ð¶:S3úJ46ú[D50£¶ð:D?IQ#ðõ.;“…¢('\r')“.eт.W

इसे ऑनलाइन (नींद के बिना) आज़माएं। नोट: मेरे पास स्थानीय स्तर पर 05AB1E स्थापित नहीं है, इसलिए अगर \rचाल काम करती है (सिद्धांत रूप में यह काम करना चाहिए , तो) मैं 100% निश्चित नहीं हूं । TIO में इसके \rबजाय newlines के रूप में व्याख्या कर रहे हैं। इसके अलावा, TIO विरासत संस्करण का उपयोग करता है, क्योंकि .eनए TIO संस्करण में अक्षम है (प्रोग्राम दोनों विरासत और 05AB1E के नए संस्करण में समान है, हालांकि)।

स्पष्टीकरण:

ð¶:            # Replace all spaces in the (implicit) input-string with newlines
   S           # Split the string to a list of characters
    3ú         # Pad each character with 3 leading spaces
      J        # Join the characters together again
       46ú     # And pad the entire string with an additional 46 leading spaces
[              # Now start an infinite loop:
 D             #  Duplicate the string
  50£          #  And leave only the first 50 characters of this copy as substring
     ¶ð:       #  Replace the newlines back to spaces
        D?     #  Duplicate the string, and print it without trailing newline
 IQ            #  If the current string is equal to the input:
   #           #   Stop the infinite loop
 ðõ.;          #  Replace the first space with an empty string to remove it
 “…¢('\r')“    #  Push dictionary string "print('\r')"
           .e  #  Evaluate it as Python code
 т.W           #  Sleep for 100 ms

मेरा यह 05AB1E टिप देखें (अनुभाग कैसे शब्दकोश उपयोग कैसे करें? ) को समझने के लिए क्यों “…¢('\r')“है "print('\r')"।

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

पायथन, 139 बाइट्स

import os;P='\n'
def f(x,w):
 v=k=P*w+P.join(x);o=str.replace
 while v!=x:os.system('sleep 1;clear');k=o(k,P,'',1);v=o(k,P,' ');print v[:w]

f('Hello World', 50)शुरू करने के लिए कॉल करना है।

— सुनेरा अविनाश
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.