Après mon entrée dans Obfuscated Hello World, j'ai pensé qu'il pourrait être amusant de partager le code sous-jacent. Mais pourquoi montrer le code, faisons-en aussi un golf!

Défi

Écrivez un script qui fait défiler une chaîne à travers le terminal, de droite à gauche, s'installant sur le côté gauche.

Contribution

Prend une chaîne comme argument.

Résultat

Imprime le cadre de défilement sur STDOUT. Largeur maximale de ~ 50 caractères. Commence par 0 ou 1 caractère affiché. Un peu d'espace entre les lettres lors du défilement. S'arrête une fois réglé (sans espace supplémentaire entre les caractères des mots). Défilement lent, mais pas trop lent (<1 s par itération).

Exemple

Exécution d'un script avec arg 'Hello World'

                                                   H

plus tard

                H    e    l    l    o         W    o

plus tard

H    e    l    l    o          W    o    r    l    d

plus tard

Hell    o         W    o    r    l    d

enfin

Hello World

Pour un exemple en cours d'exécution, essayez mon code du défi "Hello World". Finalement, je posterai le mien. Il est actuellement de 202 caractères en Perl. Maintenant qu'il y a des concurrents, j'ai posté le mien dans les réponses.

Gagnant

Je ne veux pas que les restrictions soient absolues, c'est pourquoi je les ai laissées un peu vagues. Le script le plus court qui suit l'esprit de mon original l'emportera.

Remarques

Ce jeu suppose un xtermenvironnement. Si un autre environnement s'avère utile, seuls des environnements similaires seront comparés et un gagnant distinct pourra être déclaré pour chacun.

Addendum (25 avril 2012)

Pour résoudre certains problèmes naissants, je prends une décision. Votre nombre de caractères doit inclure le code nécessaire pour:

1. Flush STDOUT (vous regarde Ruby)
2. Mettre sleepen œuvre avec un délai de <1 s (vous regarde Perl)

Cela peut être fait lorsque la ligne de commande bascule vers un interpréteur, mais ces caractères comptent dans le total (sans espaces blancs environnants).

python 2 - 146 caractères

edit: en a fait une fonction au lieu d'une entrée via stdin. le premier argument est la chaîne, et le deuxième argument est la longueur que vous voulez qu'il soit. ainsi l'invocation serait f('Hello World', 50). Je l'ai également rendu beaucoup plus fluide; quand chaque personnage a 'atterri' il y a eu une pause gênante

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)

vieux, 158 caractères:

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)

Rubis, 93 91 89 caractères

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

Le texte à afficher doit être donné comme argument de ligne de commande, par exemple

ruby marquee.rb "Hello World"

pour l'exemple ci-dessus. Malheureusement, je ne peux pas montrer l'animation ici, vous devez donc essayer le code vous-même.

La version précédente:

s=" "*67+[*$*[0].chars]*"   ";(s.size*3/4).times{|j|s[j/3]='';$><<s[16,50]+" \r";sleep 0.1}

C, 94 83 80 173 caractères

EDIT: Ajout de beaucoup de code, implémente toutes les fonctionnalités demandées maintenant. La constante 1e8peut être modifiée pour contrôler la vitesse. Sur ma machine, c'est assez rapide comme ça.
Certains personnages peuvent sûrement être enregistrés ici. lpeut être statique (sauvegarde l'initialisation), cpeut devenir un pointeur (remplacement 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););
}

Ancienne version (80 caractères), avec une fonctionnalité partielle:
enregistré quelques caractères en les remplaçant char**tpar int*t. Fonctionne bien en 32 bits (prend en int**tcharge 64 bits).

main(i,t,w)
    int*t;
{
    for(w=80;i--||printf("\033[F\033[K%*s\n",w,t[1],i=1e8)*--w;);
}

K&R C - 431 416 caractères

Respecte la norme à un haut degré. Utilise ncurses, il doit donc être largement indépendant du terminal. Il y a un léger bégaiement lorsque le texte frappe le côté en raison d'une ruse jouée pour préserver l'espace blanc prévu dans la chaîne.

La chaîne à utiliser doit être passée comme premier argument sur la ligne de commande (et doit être échappée si elle contient des espaces, plus encore si elle contient un !comme ma chaîne de test ( Hello, World!) l'a fait).

#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();}

Sous une forme plus lisible et commentée:

#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();
}

Perl 5.13.2, 96

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

Volant beaucoup de la réponse de @ Kevin Reid , en particulier l' /rastuce disponible dans les nouveaux Perls.

Perl, 115

Comme la réponse de @ Joel Berger , cela deviendrait beaucoup plus court si je pouvais utiliser sleep 1et être lent, ou passer -MTime::HiRes=sleepsur la ligne de commande pour l'activer sleep.1. Sinon, le seul moyen intégré pour obtenir de courtes nuits est select'','','',.1ce qui est assez long.

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

Perl, 128

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

Perl, 133

$|=@_=split//,pop;for$i(reverse-$#_..50){for(@_){print$"x($j||$i),$_;($i+=$j=($i++>0)*4)>50&&last}print"    \r";$j=select'','','',.1}

Javascript 180 218 caractères

Version de production:

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()

Version non golfée:

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)?" ":"");
            }
            document.body.innerHTML="<pre>"+h.substr(0,50)+"</pre>";
            setTimeout(f,99);
        }
}
f();​

Voici une démo jsFiddle

Remarque: si vous essayez de le reproduire, assurez-vous que le code est en dessous du corps

Perl 5.13.2, 115 caractères

$_=$"x9 .pop=~y/ /\0/r;s/./    $&/g;print(y/\0/ /r=~/(.{50})/,"\r"),select$.,$.,$.,.02while$|=s/ (\S)/$1 /g;print$/

• Avertissement de nettoyage.
• Peut être serré un peu en réduisant l'espace entre les caractères ou l'espace blanc initial.
• Nécessite Perl 5.13.2 ou plus récent en raison de l'utilisation de /r.
• La substitution à NUL pour conserver les espaces est sans ambiguïté puisque POSIX argv n'est pas propre à NUL. Cependant, la substitution de boucle transformera tout autre espace blanc en rien (éventuellement).

Crédits:

• $"comme source de " "prise de la réponse de l' éphémient , réduction de 1 caractère.

bash 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"

Usage:

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

non golfé:

#!/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"

R, 319 caractères

En suivant la philosophie de l'exemple @Blazer (d est le délai en secondes):

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=""))
}

Usage:

f("Hello World",n=20,d=0.2)

Perl : 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}

Pour obtenir un sommeil <1s, vous devez exécuter en tant que:

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

Comme je ne me déclarerai pas vainqueur, je ne me disputerai pas sur ce qui compte ou non (mais je ne peux vraiment pas faire gagner ça à Ruby ;-))

Q, 145

Ne répond pas exactement aux exigences car la ligne finale supprime tous les espaces qui se trouvaient dans la chaîne d'entrée d'origine.

{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];}

Il prend deux arguments, une chaîne d'entrée et une vitesse de défilement

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

PowerShell, 135

Pas très golfé et probablement une approche horrible, mais je suis malade et je ne peux pas vraiment penser ...

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}

J (116)

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

Prend la chaîne d'entrée sur la ligne de commande, c.-à-d. jconsole marquee.ijs 'Hello, world!'

S'il n'a pas besoin d'effacer l'écran, c'est-à-dire de produire comme ceci:

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

est autorisé, il serait de 12 caractères plus court.

Explication:

• s.=>2{ARGV: récupère la chaîne depuis la ligne de commande
• k.=50,3#~<:#s: la quantité de départ d'espace ajoutée avant chaque personnage, 50 avant le premier et 3 avant tous les autres. (donne un tableau, '50 3 3 3 ... ')
• ([-=&0@/:@\:@~:&0): étant donné un tableau, décrémente le premier élément différent de zéro dans le tableau
• ^:(i.>:+/k): cette fonction appliquée N fois, où N est 0 jusqu'à la somme de la quantité d'espaces ajoutés. (donne une matrice: 50 3 3 3; 49 3 3 3; 48 3 3 3; ... 0 0 0 1; 0 0 0 0).
• "1: exécuter la fonction suivante sur chaque ligne de la matrice
• ;@:(([,~#&' '@])@.>): ajouter le nombre d'espaces donné avant chaque caractère de la chaîne
• (50&{.): prendre les 50 premiers caractères de la chaîne
• ([[i.@]&2e7): une fonction qui génère la liste de 0 à 2 * 10 ^ 7, puis la jette. Cela prend environ un tiers de seconde sur ma machine, cela entraîne le retard.
• ((50#LF)&,): ajouter 50 sauts de ligne avant la chaîne, pour effacer l'écran
• echo: sortie de la chaîne
• s (...): donne la chaîne comme argument de gauche à la fonction

APL (70)

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

Prend l'entrée du clavier, la sortie est dans la ⎕SMfenêtre (qui serait le terminal si vous aviez un APL basé sur du texte, je suppose). La taille de la fenêtre est détectée automatiquement, si vous voulez vraiment qu'elle soit de 50, changez la 1↓⎕SDen 50.

Explication:

• 1↓⎕SD,1↓3⍴⍨⍴D←⍞: lire la chaîne et stocker D. Générez un vecteur décrivant la quantité d'espace à ajouter avant chaque caractère, c'est-à-dire la largeur de l'écran avant le premier caractère ( 1↓⎕SD) et 3 avant les autres ( 1↓3⍴⍨⍴D).

• ⎕DL÷8: attendez 1 / 8ème de seconde

• P←⍵-{⍵×~×⍺}\×⍵: dans le vecteur de l'argument de droite, soustrayez 1 de l'élément non nul le plus à gauche et stockez le nouveau vecteur dans P.
• ,/D{⍺,⍨⍵⍴⍕⍬}¨P: pour chaque caractère en D, préfixez la quantité d'espaces donnée en P.
• ⎕SM∘←1,⍨1,⍨: affichage à l'écran, dans la colonne la plus à gauche de la ligne supérieure
• 0∨.≠P:∇P: s'il y a un élément non nul dans P, répéter avec P.

PowerShell , 129 octets

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

Essayez-le en ligne!

Ce script ne supprime pas les espaces des arguments contrairement au script de Joey .

TIOn'affiche pas correctement la sortie. Avec la console Powershell, vous obtenez la ligne de repère défilante.

05AB1E , 42 octets

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

Essayez-le en ligne (sans dormir). REMARQUE: je n'ai pas 05AB1E installé localement, donc je ne suis pas sûr à 100% si l' \rastuce fonctionne (en théorie, cela devrait fonctionner, cependant). Dans TIO, ils \rsont plutôt interprétés comme des sauts de ligne. En outre, le TIO utilise la version héritée, car il .eest désactivé dans la nouvelle version TIO (le programme est le même dans l'héritage et la nouvelle version de 05AB1E, cependant).

Explication:

ð¶:            # 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

Voir cette astuce de la mine de 05AB1E (section Comment utiliser le dictionnaire? ) Pour comprendre pourquoi “…¢('\r')“est "print('\r')".

Python, 139 octets

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]

Doit appeler f('Hello World', 50)pour commencer.