code machine x86 (37 octets)

Hdddump:

 6800B807BF8007BE8200B40EAC3C0D741338D8740A720481EF400181C7A000AB86C3EBE8C3 

Exécuter dans MS-DOS avec console de 50 lignes, l’entrée est prise à partir de la ligne de commande.

Par exemple

 wave.com 1234567890qwertyuiopasdfghjklzxcvbnm 

Téléchargez le binary ici

Mise à jour: effacé trois octets grâce à jrandomhacker

J

54 caractères, si vous laissez l’interpréteur gérer les entrées / sorties.

 e=:|:@((#&' '@],[)"0[:(-<./)0,[:+/\[:(}:(>-<)}.)ai]) 

65 pour lire explicitement de stdin et écrire sur stdout.

 (|:((#&' '@],[)"0[:(-<./)0,[:+/\[:(}:(>-<)}.)a.&i.)~1!:1[3)1!:2[4 

 e '1234567890qwertyuiopasdfghjklzxcvbnm'
                              z
                             lxvn
                            kcbm
                           j
                          h
                         g
                ypsf
               tuoad
            wri
         9 qe
        8 0
       7
      6
     5
    4
   3
  2
 1

 e '31415926535897932384626433832795028841971693993751058209749445923078164062862'
             9 9 8 6 6
      9 6 8 7 3 3 4 2 4 8 9 88
 3 4 5 2 5 5 2 33 3 7 5 2 4 9 9 99 7
  1 1 3 2 0 1 7 6 3 3 5 8 8 6
                                         1 1 5 2 9 9 3 7 1 4 6 8
                                                   0 0 7 9 5 2 0 0 2 6
                                                          4 44 2

    NB  Recherchez les codes ASCII
 ord =: ai] 
     ord 'p4ssw0rd'
 112 52 115 115 119 48 114 100

    NB  Monter?
 up =:}: <}. 
     up ord 'p4ssw0rd'
 0 1 0 1 0 1 0

    NB  Descente?
 down =:}:>}. 
     vers le bas 'p4ssw0rd'
 1 0 0 0 1 0 1

    NB  Combiner pour obtenir ± 1
 updown =:}: (> - <)}. 
     updown ord 'p4ssw0rd'
 1 _1 0 _1 1 _1 1

    NB  Commence avec 0, suivi avec des sums partielles
 sum =: 0, + / \ 
     sum updown ord 'p4ssw0rd'
 0 1 0 0 _1 0 _1 0

    NB  Soustrayez le minimum pour obtenir la séquence avec la base à 0
 fix =: - <./ 
     sum de sum updown ord 'p4ssw0rd'
 1 2 1 1 0 1 0 1

    NB  Pour plus de commodité, nommez cette chaîne de fonctions
 d =: [: fix [: sum [: updown ord

    NB  Faire des espaces avant les caractères
 push =: (# & '' @], [) "0 d 
     poussez 'p4ssw0rd'
  p
   4
  s
  s
 w
  0
 r
  ré

    NB  Tournez-le sur le côté
 |: poussez 'p4ssw0rd'
     wr
 p ss 0 d
  4

    NB  Combinez en une fonction nommée…
 e =: |: @ push
    NB  … Et tout incorporer
 e =: |: @ ((# & '' @], [) "0 [: (- <./) 0, [: + / \ [: (}: (> - <)}.) ai])

Le code le plus court par caractère compte pour imprimer une «vague» à partir de la chaîne d’entrée.

Console.WriteLine (“une” vague “de la chaîne d’entrée.”);

Perl (94 caractères)

144 caractères à l’origine par Barnaba:

chop($_=<>);$l=length;push(@a," "x$l)for(1..$l*2);$l+=(ord $p<=>ord $_),substr($a[$l],$r++,1)=$p=$_ for(split //);/^\s+$/||print "$_\n" for(@a)

121 personnages de l’optimisation par Chris Lutz:

$_=<>;chop;$a[@a]=" "x$l for 1..($l=length)*2;$l+=$p cmp$_,substr($a[$l],$r++,1)=$p=$_ for split//;/\S/&&print"$_\n"for@a

94 caractères d’optimisation supplémentaire:

$_=<>;@a=($"x($l=y///c).$/)x(2*$l);s/./substr$a[$l+=$"cmp$&],"@-",1,$"=$&/ge;/\S/&&print for@a

Notez que dans le golf Perl traditionnel, on ajoute généralement le nombre de commutateurs et la longueur du code (ce qui aiderait ici par quelques coups), mais ici nous utilisons des programmes autonomes sans commutateur.

C sur un terminal VT100 (76 caractères)

Cela fonctionne dans mon test sur FreeSBIE:

 o;main(c){for(;(c=getchar())-10;o=c)printf("\33[1%c%c",co?65:71,c);} 

Mais pour voir clairement le résultat, vous devez le lancer avec quelque chose comme ceci:

clear ; printf "\n\n\n\n\n" ; echo the quick brown fox jumps over the lazy dog | ./a.out ; printf "\n\n\n\n\n"

Est-ce que ça compte?

Python (161 caractères)

 v,s="",raw_input() m=n=len(s) r=[' ']*n q=[r[:]for i in range(2*n)] for j,i in enumerate(s): m+=(iv) q[m][j],v=i,i for i in q: if i!=r:print''.join(i) 

Je n’ai cependant pas fait grand chose pour le compresser. Portant à quelque chose avec un opérateur de vaisseau spatial maintenant.

Rubis: 99 octets

 r,a,q,i=[],"",99,0 gets.chars{|x|t=r[q+=a<=>x]||="" a=x r[q]+=" "*(it.size)+x i+=1} puts r.compact 

Non compressé:

 r,a,q,i = [],"",99,0 gets.chars { |x| t = r[q+=a<=>x] ||= "" a = x r[q] += " "*(it.size)+x i += 1 } puts r.compact 

PHP (138 caractères)

 $lc;krsort($o);echo join($c,$o); 

Version ‘lisible’ :

  $last_ch; krsort($out); echo join($ch,$out); 

Python 2.x, maintenant réduit à 156 caractères:

 s=raw_input() R=range(len(s)) m=[0] for i in R[1:]:m+=[m[-1]-cmp(s[i],s[i-1])] for x in range(min(m),max(m)+1):print''.join(m[i]==x and s[i]or' 'for i in R) 

Haskell, 215 caractères. Je poste ceci parce que je n’aime pas du tout la version de Khoth. En écrivant dans un style raisonnablement fonctionnel, je me suis retrouvé avec un programme beaucoup plus court et plus lisible par l’OMI. Je n’ai pas vraiment essayé de le faire en dehors des noms de variables et de l’espacement. La mise à jour destructive d’un tableau peut le rendre plus court que la réplication d’espaces.

 import Char import List main=getLine>>=(putStr.p) ps=unlines$transpose[z++(y:x)|(m,y)<-zip ns,let(x,z)=splitAt m$replicate(maximum n)' '] where o=map ord s n=scanl(+)0$map signum$zipWith(-)(tail o)o 

C89 (151 caractères)

 l[999][999];p;v=500;r;main(c){for(;(c=getchar())>0; )l[v+=c>p,v-=c