Animer le texte dans votre terminal

Le but

Le but est d '"animer" la chaîne "Hello world" dans votre sortie afin que chaque caractère soit capitalisé l'un après l'autre.

Votre programme peut sortir après que chaque lettre ait été mise en majuscule.

Par exemple;

# Iteration 1
Hello world

# Iteration 2
hEllo world

# Iteration 3
heLlo world

# Iteration 4
helLo world

# Iteration 5
hellO world

# Iteration 6 (note: it should capitilize the space char (ie: a break between iteration 5 and iteration 7)
hello world

# Iteration 7
hello World

# Iteration 8
hello wOrld

# Iteration 9
hello woRld

# Iteration 10
hello worLd

# Iteration 11
hello worlD

Il ne devrait animer la chaîne qu'une seule fois et entre chaque état, il devrait s'écouler un délai d'une seconde.

Contribution

Aucune entrée n'est requise, mais "Hello world" doit être la chaîne "animée".

Sortie

La chaîne "Hello world" doit être animée. La sortie doit avoir la forme d'une ligne pour créer une sorte d'animation d'onde. Une nouvelle ligne vide est autorisée. Exemple gif;

^{Je l'ai vu sur une vidéo youtube metasploit et j'ai trouvé l'effet super cool. C'est là que j'ai enregistré le gif, donc c'est un peu lent, mais j'espère que cela illustre bien la sortie.}

C'est le code-golf , le plus petit nombre d'octets sera considéré comme le gagnant.

^{Lien bac à sable}

Vim 26 octets

ihello world<ESC>qq~gsul@qq0@q

Explication (pas encore .gif):

Premièrement, nous devons entrer le texte "hello world". C'est assez simple. C'est juste:

ihello world<ESC>

À ce stade, le curseur se trouve sur le «d» dans le «monde». Prochain:

qq              " Start recording into register 'q'
  ~             " Swap the case of the character underneath the cursor, and move the cursor to the right
   gs           " Sleep for one second
     u          " Undo the last change (of swapping case).
      l         " Move one character to the right (Get it? 'l' == 'Right' because vim is intuitive!)
                " This will cause the error to break on the last character of the input.
       @q       " Call register 'q'
         q      " Stop recording
          0     " Move to the first character
           @q   " Call the recursive macro

J'ai également trouvé deux autres versions à 26 octets:

ihello world<ESC>qq~gsulq011@q
ihello world<ESC>011@='~gsul'<cr>

Python 2, 98 94 90 octets

for x in range(11):s='hello world';print'\r'+s[:x]+s[x:].capitalize(),;[1for y in' '*8**8]

-9 -4 octets grâce à @ElPedro -4 octets grâce à @JonathanAllan et @Rod

Commodore 64, 168 162 137 133 octets BASIC (et symbolisés) utilisés

 0s=1024:?"{control+n}{clear home}hello world":fOi=.to1:fOj=.to11:x=pE(s+j):pokes+j,x+64
 1x=pE(1023+j):pO1023+j,abs(x-64):pO1029,32:pO1035,32:fOz=.to99:i=.:nEz,j,i

Vous devrez utiliser les abréviations du mot-clé BASIC pour entrer cela dans un véritable émulateur C64 ou (ou entrer le programme dans un Commodore 128 et le recharger en mode C64, bien que cela devrait également fonctionner avec le 128). Le {control+n}ne fonctionnera / affichera qu'après le devis d'ouverture. En abrégé chr$(14), il enregistre certains octets et fait passer le jeu de caractères en mode Business ou en majuscules / minuscules.

J'ai ajouté quelques abréviations pour vous, donc vous. Le {clear home}caractère est créé en appuyant sur Shiftet la CLR/HOMEtouche après le guillemet ouvrant.

À des fins d'illustration, la liste non annulée peut être saisie comme suit:

 0 let s=1024
 1 print chr$(14); chr$(147); "hello world"
 2 for i=0 to 1
 3  for j=0 to 11
 4   let x=peek(s + j)
 5   poke s + j, x + 64
 6   let x=peek(1023 + j)
 7   poke 1023 + j, abs(x - 64)
 8   poke 1029, 32
 9   poke 1035, 32
10   for z=0 to 99
11    let i=0
12   next z
13  next j
14 next i

Cela fonctionne en commutant le jeu de caractères PETSCII en mode Business (majuscules / minuscules), et en écrivant la chaîne hello world sur la ligne supérieure de l’écran situé à l’emplacement de mémoire $ 0400. 11 octets à partir de là et augmenter chaque valeur de 64 (l'équivalent en majuscule). Si le compteur j est> 0, il appelle une routine sur la ligne 2 pour réduire à nouveau l'emplacement mémoire précédent de 64.

La ligne 3 est une pause, elle écrit également un espace dans les emplacements 0405 $ et 040b $, ce qui est une correction de bogue (qui pourrait probablement être supprimée pour économiser quelques octets).

C #, 230 215 193 161 135 134 130 octets

C'est C # alors c'est long à droite! :-( Mais après un peu d'aide et de recherche, j'ai (et d'autres, vraiment) réussi à supprimer exactement 100 octets déjà.

Golfé

()=>{for(int i=1;;){var b="\rhello world".ToCharArray();b[i++]-=' ';System.Console.Write(b);System.Threading.Thread.Sleep(1000);}}

Ungolfed

class P
{
    static void Main()
    {
        for (int i = 1;;)
        {
            var b = "\rhello world".ToCharArray();
            b[i++] -= ' ';
            System.Console.Write(b);
            System.Threading.Thread.Sleep(1000);
        }
    }
}

Capture d'écran

Bien qu'il semble beaucoup mieux en boucle et plus rapide ..

Mises à jour

• Perdu 15 octets en utilisant un retour chariot au lieu de Clear()cela m'a également permis de remplacer un en utilisant System.Consolequelque part en ligne.

• Programme remplacé par lambda économisant 23 octets grâce à @devRicher

• C'est devenu une sorte de collaboration avec @devRicher à ce stade, grâce à certaines de ses suggestions, j'ai réussi à perdre 32 octets de plus!
• Merci à 2 suggestions très intelligentes et intéressantes par @Kratz je réussi à remplacer new string(b)avec bet b[i]=char.ToUpper(b[i])avec b[i]-=' ', me sauver 26 autres octets!
• 1 octet en moins en se déplaçant i++grâce à @Snowfire
• 4 octets de moins en déplaçant le chariot retour au début de la chaîne et en supprimant i<11de ma forboucle

Powershell, 126 119 107 104 octets

'Hello world';$s='hello world';1..10|%{sleep 1;cls;-join($s[0..($_-1)]+[char]($s[$_]-32)+$s[++$_..11])}

Révisions (il y en aura probablement beaucoup):

Changer $s.Lengthen const 1011

Un constructeur de chaînes restructuré, une instruction de jointure supprimée et utilisée à la ++$splace de ($s+1), pour enregistrer des octets grâce à @AdmBorkBork

AdmBorkBork souligne que l'utilisation de la chaîne deux fois est en réalité plus courte que l'encapsulation puis .ToLower()l'ajout - ce qui en dit long sur la puissance verbeuse de -3!

fondamentalement, parcourez la longueur de la chaîne, formez un ensemble de trois parties, le pré-capital, le capital et le post-capital, éloignez 32 de la lettre du milieu, puis reconvertissez-les en caractères avec majuscules, heureusement, cela ne transformez pas l’espace en personnage visible non plus, j’espère que cela est acceptable?

Assemblage CP-1610 , 50 DECLEs = 63 octets

Ce code est destiné à être exécuté sur une Intellivision .

Un opcode CP-1610 est codé avec une valeur de 10 bits, appelée "DECLE". Ce programme a une durée de 50 décles et commence à 4800 $ et se termine à 4831 $.

                                  ROMW  10          ; use 10-bit ROM
                                  ORG   $4800       ; start program at address $4800

                          main    PROC
4800 0002                         EIS               ; enable interrupts (to enable display)

4801 0001                         SDBD              ; load pointer to string in R4
4802 02BC 0026 0048               MVII  #@@str, R4

4805 02A2                         MVI@  R4,     R2  ; R2 = length of string
4806 0091                         MOVR  R2,     R1  ; R1 = uppercase counter

4807 02BD 0214            @@loop  MVII  #$214,  R5  ; R5 = video memory pointer
4809 0093                         MOVR  R2,     R3  ; R3 = character counter

480A 02A0                 @@next  MVI@  R4,     R0  ; R0 = next character
480B 0338 0020                    SUBI  #32,    R0  ; minus 32 -> character #
480D 004C                         SLL   R0,     2   ; multiply by 8 to get the
480E 0048                         SLL   R0          ; correct GROM card
480F 03F8 0007                    XORI  #7,     R0  ; add 7 (for white)

4811 014B                         CMPR  R1,     R3  ; uppercase? ...
4812 020C 0002                    BNEQ  @@draw

4814 0338 0100                    SUBI  #256,   R0  ; ... yes: sub 32*8

4816 0268                 @@draw  MVO@  R0,     R5  ; draw character
4817 0013                         DECR  R3          ; decrement character counter
4818 022C 000F                    BNEQ  @@next      ; process next character or stop

481A 0001                         SDBD              ; R0 = spin counter to wait ~1 second
481B 02B8 0038 00D3               MVII  #$D338, R0  ;    = 54072 = 13518 * 60 / 15
                                                    ; (assuming 13518 cycles per frame)

481E 0010                 @@spin  DECR  R0          ; 6 cycles
481F 022C 0002                    BNEQ  @@spin      ; 9 cycles
                                                    ; -> 15 cycles per iteration

4821 0114                         SUBR  R2,     R4  ; reset pointer to beginning of string
4822 0011                         DECR  R1          ; decrement uppercase counter
4823 022C 001D                    BNEQ  @@loop      ; process next iteration or stop

4825 0017                         DECR  PC          ; infinite loop

4826 000B 0068 0065 006C  @@str   STRING 11, "hello world"
482A 006C 006F 0020 0077
482E 006F 0072 006C 0064
                                  ENDP

Sortie

MATL , 30 octets

11:"10&Xx'hello world't@)Xk@(D

Essayez-le sur MATL Online!

11:              % Push [1 2 ... 11]
  "              % For each k in [1 2 ... 11]
  10&Xx          %   Pause for 10 tenths of a second and clear screen
  'hello world'  %   Push this string
  t              %   Duplicate
  @)             %   Get the k-th character from the duplicated string
  Xk             %   Convert to uppercase
  @(             %   Write into the k-th position of the string
  D              %   Display
                 % Implicit end

PHP, 76 74 71 octets

Merci @hd pour le retard étant une seconde complète et aucune fraction de celle-ci!
Merci @ user63956 pour 2 octets et @aross pour 3 octets.

for(;$c=($s="hello world")[$i];sleep(print"$s\r"))$s[$i++]=ucfirst($c);

Courez avec -nr.

C, 97 retiré 106 octets

avec des caractères échappés comptés comme 1 octet

char*a="HELLO\0WORLD\xED";b,c;m(){for(b=0;b<156;putchar(a[c]+32*(b/12^c||c==5)))(c=b++%12)||fflush(sleep(1));}

Remarque: j'ai commenté le délai sur une TIO non liée, car elle attend la fin avant d'afficher la sortie. Elle ne semble pas non plus reconnaître les retours à la ligne et met de nouvelles lignes. De plus, si vous êtes sous Windows, le sommeil est en millisecondes au lieu de secondes, il sleep(1)devrait en être de même sleep(1000).

Note 2: J'ai retiré cette entrée pour le moment jusqu'à ce que les bugs de sortie aient été résolus.

JavaScript (ES6), 141 139 131 octets

8B sauvé grâce à Apsillers

_=>a=setInterval("b=[...`hello world`],c.clear(b[d]=b[d].toUpperCase(++d>10&&clearInterval(a))),c.log(b.join``)",1e3,c=console,d=0)

Explication

Cela crée une fonction sans argument, qui divise la chaîne hello worlden un tableau de caractères et met en majuscule le caractère d+1^th . dest un compteur qui commence comme 0et augmente à chaque fois.

Usage

f=_=>a=setInterval("b=[...`hello world`],c.clear(b[d]=b[d].toUpperCase(++d>10&&clearInterval(a))),c.log(b.join``)",1e3,c=console,d=0)
f()

Noodel , 22 octets

”<8@\|DḶ|\6þıHḶƥɲSḍsɲS

Essayez-le :)

Comment ça fonctionne

”<8@\|DḶ|\6þ           # Displays the string "hello¤world".
”<8@\|DḶ|\6            # Decompresses to the array ["h", "e", "l", "l", "o", "¤", "w", "o", "r", "l", "d"] and pushes it on top of the stack.
           þ           # Pushes a copy of the array to the screen which since is an array is done by reference.

            ı          # Makes the array on the top of the stack the new stack.

             HḶƥɲSḍsɲS # Loops eleven times creating the animation.
             H         # Pushes the string "H" on to the top of the stack.
              Ḷ        # Consumes the "H" that gets evaluated as a base 98 number which comes out to eleven.
               ƥ       # Move the stack pointer up one.
                ɲS     # Switch the case of the top of the stack which will show up on the screen because the array is done by reference.
                  ḍs   # Delay for one second.
                    ɲS # Switch the case back.
                       # Implicit end of the loop.

L'extrait de code utilise une version de 25 octets qui effectue une boucle continue.

<div id="noodel" cols="10" rows="2" code="”<8@\|DḶ|\6þıḷʠ*HḶƥɲSḍsɲS" input=""/>
<script src="https://tkellehe.github.io/noodel/release/noodel-2.5.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

Bash + coreutils, 99 98 octets

x=hello\ world
for((;n<11;)){
echo -en "\r${x:0:n}"`tr a-z A-Z<<<"${x:n:1}"`"${x:n+++1}"
sleep 1
}

Perl 6 , 65 61 octets

for 3..12 ->\i{sleep say "\echello world".&{S:nth(i)/./{$/.uc}/}}

(sleep say S:nth(3+$++)/./{$/.uc}/with "\echello world")xx 11

GIF:

Comment ça fonctionne

La séquence d'échappement ANSI \ecefface l'écran.
A chaque itération, le iième caractère de la chaîne codée en dur est remplacé par sa version majuscule.
La sayfonction retourne toujours True, qui est transmise à la fonction de sommeil qui l'interprète comme 1seconde.

Ruby, 82 81 octets

12.times{|a|$><<?^H*11;'Hello world'.chars{|y|$><<((0!=a-=1)?y:y.upcase)};sleep 1}

^ H est ascii 8 (retour arrière) et n’est que de 1 octet.

C, 87 octets

m(){char*f,a[]="\rhello world";for(f=a;*++f;*f&=95,printf(a),*f|=32,fflush(sleep(1)));}

Compile et fonctionne sous Linux.

Mathematica, 130 128 123 110 108 octets

Dynamic@o
s="hello world";i=1;t=StringTake;Do[o=t[s,{1,i-1}]<>Capitalize@t[s,{i}]<>t[s,{++i,11}];Pause@1,11]

Explication: De i=111 à 11, insérez du 1 er au (i-1) ème caractère de "hello world", mettez "hello world"[i]-les en majuscule , puis imprimez le reste de la chaîne en incrémentant ien même temps.

Java 215 212 204 203 octets

interface A{static void main(String z[])throws Exception{for(int i=0;i<10;i++){char[]b="helloworld".toCharArray();b[i]=Character.toUpperCase(b[i]);System.out.println(new String(b));Thread.sleep(1000);}}}

Ungolfed:

 interface A {
 static void main(String z[]) throws Exception {
    for (int i = 0; i < 10; i++) {
        char[] b = "helloworld".toCharArray();
        b[i] = Character.toUpperCase(b[i]);
        System.out.println(new String(b));
        Thread.sleep(1000);
    }
  }
}

R , 106 103 octets

x=el(strsplit("hello world",""))
for(i in 1:11){y=x;y[i]=toupper(y[i]);cat('\f',y,sep='');Sys.sleep(1)}

Juste une simple boucle, effacer la console avec cat('\f')semble quelque peu dépendant du système mais je ne suis pas au courant d'une meilleure façon.

C, 122 octets

i;f(){char s[]="Hello world\r";for(i=0;i<11;i++){s[i]=toupper(s[i]);s[i-1]=tolower(s[i-1]);printf(s);fflush(0);sleep(1);}}

Plus court que C #: D

Perl, 75 octets

sleep print"\33c".("hello world"=~s/(.{$_})(.)(.*)/$1\U$2\E$3\n/r)for 0..10

Utilise le code ANSI ESCcpour effacer la console et déplacer le curseur en haut à gauche à chaque itération, mais doit toujours être placé \nà la fin de la chaîne de remplacement pour éviter de perdre toute l'animation dans le tampon de ligne.

Un appel réussi à printrenvoie une valeur de 1, à laquelle vous pouvez passer directement sleep.

SmileBASIC, 90 71 octets

FOR I=0TO 10CLS?"hello world
LOCATE I,0?CHR$(CHKCHR(I,0)-32)WAIT 60NEXT

Gelée , 24 21 octets

”Æ⁹Œu⁸¦ȮœS
“½,⁻⁸3»Jç€

Ceci est un lien / une fonction niladique qui imprime vers STDOUT. Cela ne fonctionne pas comme un programme complet.

Le code ne peut pas être testé sur TIO; il utilise des caractères de contrôle et TIO n'a pas (encore) d'émulateur de terminal.

Comment ça fonctionne

“½,⁻⁸3»Jç€  Niladic link. No arguments.

“½,⁻⁸3»     Index into Jelly's dictionary to yield "hello world".
       J    Indices; yield [1, ..., 11].
        ç€  Apply the helper link to each index, with right arg. "hello world".


”Æ⁹Œu⁸¦ȮœS  Dyadic helper link. Left argument: i. Right argument: "hello world"

Ӯ          Set the return value to '\r'.
  ⁹         Set the return value to "hello world". Implicitly prints '\r'.
   Œu⁸¦     Uppercase the i-th letter.
       Ȯ    Print.
        œS  Sleep "hello world" seconds. (Strings are cast to Boolean.)

C, 122 octets

En tant qu'exercice, j'ai écrit ceci pour fournir un format de sortie plus optimal que certaines des autres réponses. Cela signifie également que le curseur est placé après la dernière lettre majuscule pendant les pauses.

main(){
    char*p=".Hello world\rH";
    write(1,p+1,13);
    do{
        sleep(1);
        *p=8;
        p[1]|=32;
        p[2]^=(p[2]>32)*32;
        write(1,p++,3);
    }while(p[4]);
}

(Newlines et indentations cosmétiques et ne faisant pas partie du nombre d'octets)

Certains lecteurs remarqueront peut-être que cela nécessite un peu de massage pour pouvoir fonctionner sur des machines modernes (l’incantation magique -static -Wl,-N), mais c’est la façon dont les vraies implémentations de C se comportaient, alors je pense que cela est valable. Il suppose également que le jeu de caractères est ASCII et qu’il n’imprime pas de nouvelle ligne.

Bonus: pour une version EBCDIC, vous pouvez remplacer 8par 22et 64avec 32, et basculer la logique pour p[1]et p[2]. Pour tester sur un système non-EBCDIC, vous pouvez compiler avec -funsigned-char -fexec-charset=cp037.

La sortie est de 43 octets: Hello world«H‹hE‹eL‹lL‹lO‹o ‹ W‹wO‹oR‹rL‹lD

Scala, 92 octets

val h="hello world"
0 to 10 map{i=>print("\b"*99+h.updated(i,h(i)toUpper))
Thread sleep 999}

Ungolfed

val h="hello world"    //declare a variable h with the string "hello world"
0 to 10                //create a range from 0 to 10
map { i=>              //loop with index i
  print(                 //print
    "\b" * 99              //99 backspace chars
    + h.updated(           //and h with
      i,                     //the i-th char
      h(i).toUpper           //replaced with the i-th char in uppercase
    )     
  )
  Thread sleep 999       //sleep 999 ms
}

Lot, 184 octets

@echo off
for %%h in (Hello hEllo heLlo helLo hellO hello)do call:c %%h world
for %%w in (World wOrld woRld worLd worlD)do call:c hello %%w
exit/b
:c
timeout/t>nul 1
cls
echo %*

Curieusement, la ligne de commande de timeout/t>nul 1est corrompue s’il n’ya pas de nouvelle ligne, donc je ne peux pas la mettre à la fin du fichier.

Ruby, 108 octets

Première fois, étudiant de première année. Ce n'est pas un aigle mais je suis au moins un peu fier.

12.times{|i|sleep(0.1); puts "\e[H\e[2J", "hello world".sub(/(?<=.{#{Regexp.quote(i.to_s)}})./, &:upcase);}

Pascal, 187 152 octets

Pas exactement le plus efficace ou le plus court, mais fonctionne assez bien!

uses crt,sysutils;label R;const X:Word=1;P='hello world';begin
R:clrscr;write(P);gotoxy(X,1);write(upcase(P[X]));sleep(999);X:=X*Ord(X<11)+1;goto R
end.

Testé et fonctionne sur Free Pascal Compiler 2.6+.

Merci à @manatwork pour la sauvegarde de 35 octets!

J'ai utilisé http://www.onlinecompiler.net/pascal pour compiler le fichier et l'exécuter sous Windows.
Je n'ai vu aucun problème avec cela, jusqu'à présent.

C 120 110 104 96 octets

f(){char *j,s[]="\rhello world";for(j=s;*++j;*j-=32,printf(s),*j+=32,fflush(0),sleep(‌​1));}

Version non-golfée

void f()
{
  char *j;
  char s[]="hello world";
  j=s; 

   for (;*j;j++)
   {
      *j-=32;  
       printf(s); // print the string and right after change the same char to lower case
       *j+=32;
      fflush(0);
      sleep(1);
   }

}

@ Pakk Merci d'avoir sauvegardé quelques octets, bonne idée. :)

@Pakk @KarlNapf Merci les gars pour vos contributions.

peut encore être raccourci !? :)

Python 2, 220 189 179 octets

Solution sans utiliser les chaînes et le capitalize()nombre d'octets tels quels:

import time,sys
from numpy import *
F=fromstring("\rhello world",int8)
for i in range(1,12):
    time.sleep(1)
    F[i]-=32
    savetxt(sys.stdout,F,fmt="%c",newline="")
    F[i]+=32

Et une variante un peu plus longue (191 caractères) sans réinitialisation de casse:

import time,sys
from numpy import *
a=arange(11)
F=tile(fromstring("\rhello world",int8),(11,1))
F[a,a+1]-=32
for i in a:
    time.sleep(1)
    savetxt(sys.stdout,F[i],fmt="%c",newline="")

C ++, 88 à 125 octets

#include<iostream>#include<unistd.h>
int main(){for(int c;++c<12;){char a[]="\rhello world";a[c]-=32;std::cout<<a;sleep(1);}}

Version non-golfée:

#include <iostream>
#include <unistd.h>

int main()
{
   for (int c;++c<12;)
   {
      char a[] = "\rhello world";
      a[c]-=32;
      std::cout << a;
      sleep(1);
   }
}

Compilé avec TDM-GCC sur une machine Windows 10 avec Dev-C ++.

Edit: J'ai oublié l'inclus dans ma première version.