Animare il testo nel tuo terminale

L'obiettivo. il gol

L'obiettivo è "animare" la stringa "Hello world" nell'output in modo che ogni personaggio diventi maiuscolo uno dopo l'altro.

Il tuo programma può uscire dopo che ogni lettera è stata scritta in maiuscolo.

Per esempio;

# 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

Dovrebbe animare la stringa solo una volta e tra ogni stato dovrebbe esserci un ritardo di 1 secondo.

Ingresso

Non è richiesto alcun input, ma "Hello world" deve essere la stringa "animata".

Produzione

La stringa "Hello world" deve essere animata. L'output deve essere come 1 riga per creare una sorta di animazione wave. È consentita una nuova riga finale vuota. Esempio gif;

^{Ho visto questo su un video di YouTube di metasploit e ho pensato che l'effetto fosse piuttosto bello, che è da dove ho registrato la GIF, quindi è un po 'ritardato, ma spero che illustri l'output}

Questo è code-golf , il conteggio di byte più basso sarà considerato il vincitore.

^{Link sandbox}

Vim 26 byte

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

Spiegazione (no .gif ancora):

Innanzitutto, dobbiamo inserire il testo "ciao mondo". Questo è piuttosto semplice. È appena:

ihello world<ESC>

A questo punto, il cursore si trova sulla 'd' in 'mondo'. Il prossimo:

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

Ci sono anche altre due versioni da 26 byte che ho trovato:

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

Python 2, 98 94 90 byte

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

-9 -4 byte grazie a @ElPedro -4 byte grazie a @JonathanAllan e @Rod

Commodore 64, 168 162 137 133 byte BASIC (e tokenizzati) utilizzati

 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

Dovrai usare le abbreviazioni delle parole chiave BASIC per inserire questo in un vero C64 o emulatore (o inserire il programma in un Commodore 128 e caricarlo nuovamente in modalità C64, anche se questo dovrebbe funzionare anche sul 128). L' {control+n}funziona solo / display dopo la citazione di apertura. È una scorciatoia per chr$(14)e quindi salva alcuni byte e commuta il set di caratteri in modalità business o caratteri maiuscoli / minuscoli.

Ho aggiunto alcune abbreviazioni per te, così tu. Il {clear home}carattere viene creato premendo Shifte il CLR/HOMEtasto dopo la virgoletta di apertura.

A scopo illustrativo, l'elenco non discreto può essere inserito come segue:

 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

Funziona cambiando il set di caratteri PETSCII in modalità business (lettere maiuscole / minuscole) e scrivendo la stringa world hello nella riga superiore dello schermo che si trova nella posizione di memoria $ 0400, prenderà quindi il valore in ogni posizione per il prossimo 11 byte da lì e aumentare ogni valore di 64 (l'equivalente maiuscolo). Se il contatore j è> 0, chiama una routine alla riga 2 per ridurre nuovamente la posizione di memoria precedente di 64.

La riga 3 è una pausa, inoltre scrive uno spazio nella posizione $ 0405 e $ 040b, che è una correzione di bug (che potrebbe essere probabilmente rimossa per salvare alcuni byte).

C #, 230 215 193 161 135 134 130 byte

È C # quindi è lungo giusto! :-( Ma dopo qualche aiuto e ricerca, io (e altri, davvero) sono riuscito a rimuovere esattamente esattamente 100 byte.

golfed

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

Immagine dello schermo

Anche se sembra molto meglio quando si esegue il looping e più veloce ..

aggiornamenti

• Clear()Ho perso 15 byte utilizzando il ritorno a capo anziché il quale mi ha anche permesso di sostituire un utilizzo con System.Consoleda qualche parte in linea.

• Sostituito programma con lambda salvando 23 byte grazie a @devRicher

• A questo punto è diventata una specie di collaborazione con @devRicher , grazie ad alcuni dei suoi suggerimenti sono riuscito a perdere altri 32 byte!
• Grazie a 2 suggerimenti davvero intelligenti e interessanti di @Kratz sono riuscito a sostituire new string(b)con be b[i]=char.ToUpper(b[i])con b[i]-=' ', salvandomi altri 26 byte!
• 1 byte in meno spostandosi i++grazie a @Snowfire
• 4 byte in meno spostando il carrello si torna all'inizio della stringa e si rimuove i<11dal mio forloop

Powershell, 126 119 107 104 byte

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

Revisioni (probabilmente ce ne saranno molte):

Passare $s.Lengtha const 1011

Generatore di stringhe ristrutturato, rimosso 1 istruzione join e utilizzato al ++$sposto di ($s+1), per salvare alcuni byte grazie a @AdmBorkBork

AdmBorkBork sottolinea che usare la stringa due volte è in realtà più breve dell'incapsulamento e poi .ToLower()'ing' - il che dice molto su quanto sia potente il PowerShell, -3!

fondamentalmente attraversa la lunghezza della stringa, forma una matrice di tre parti, la pre-maiuscola, maiuscola e post-maiuscola, togli 32 dalla lettera di mezzo, quindi converti in un carattere per ottenere maiuscole, per fortuna questo non lo fa trasforma lo spazio in un personaggio visibile, spero sia accettabile?

Assemblaggio CP-1610 , 50 DECLE = 63 byte

Questo codice deve essere eseguito su un Intellivision .

Un codice operativo CP-1610 è codificato con un valore di 10 bit, noto come "DECLE". Questo programma è lungo 50 DECLE, a partire da $ 4800 e termina a $ 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

Produzione

MATL , 30 byte

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

Provalo su 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 byte

Grazie @hd per il ritardo che è un secondo pieno e nessuna frazione di esso!
Grazie @ user63956 per 2 byte e @aross per 3 byte.

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

Corri con -nr.

C, 97 ritirato 106 byte

con caratteri di escape conteggiati come 1 byte

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

Nota: ho commentato il ritardo sul TIO non collegato perché attende il completamento prima di visualizzare l'output, inoltre non sembra riconoscere i ritorni a capo e inserisce nuove righe. Inoltre, se sei su Windows, la sospensione è in millisecondi anziché in secondi, quindi sleep(1)dovrebbe diventare sleep(1000).

Nota 2: ho ritirato questa voce per il momento fino a quando i bug di output non sono stati risolti.

JavaScript (ES6), 141 139 131 byte

Risparmio di 8 B grazie a 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)

Spiegazione

Questo crea una funzione senza argomenti, che divide la stringa hello worldin una matrice di caratteri e rende maiuscolo il carattere d+1^th . dè un contatore che inizia come 0e aumenta ogni volta.

uso

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 byte

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

Provalo:)

Come funziona

”<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.

Lo snippet utilizza una versione da 25 byte che viene eseguita in modo continuo.

<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 byte

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 byte

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

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

GIF:

Come funziona

La sequenza di escape ANSI \eccancella lo schermo.
Ad ogni iterazione, il icarattere della stringa hardcoded è sostituito dalla sua versione maiuscola.
La sayfunzione ritorna sempre True, che viene passata alla funzione sleep che la interpreta come 1seconda.

Rubino, 82 81 byte

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

^ H è ascii 8 (backspace) ed è solo 1 byte.

C, 87 byte

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

Compila e gira su Linux.

Mathematica, 130 128 123 110 108 byte

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]

Spiegazione: Da i=1a 11, stampa dal 1 ° al (i-1) carattere di "ciao mondo", capitalizza "hello world"[i], quindi stampa il resto della stringa, incrementando iallo stesso tempo.

Java 215 212 204 203 byte

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 byte

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

Solo un semplice ciclo, cancellare la console con cat('\f')sembra in qualche modo dipendente dal sistema ma non sono a conoscenza di un modo migliore.

C, 122 byte

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

Più corto di C #: D

Perl, 75 byte

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

Utilizza il codice ANSI ESCcper cancellare la console e spostare il cursore in alto a sinistra ad ogni iterazione, ma è comunque necessario \nalla fine della stringa di sostituzione per evitare di perdere l'intera animazione nel buffer di linea.

Una chiamata riuscita a printrestituisce un valore di 1, che può essere passato direttamente a sleep.

SmileBASIC, 90 71 byte

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

Gelatina , 24 21 byte

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

Questo è un collegamento / funzione niladica che stampa su STDOUT. Non funziona come un programma completo.

Il codice non può essere testato su TIO; utilizza caratteri di controllo e TIO non ha ancora un emulatore di terminale.

Come funziona

“½,⁻⁸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 byte

Come esercizio, ho scritto questo per fornire un formato di output più ottimale rispetto ad alcune delle altre risposte. Inoltre significa che il cursore si trova dopo l'ultima lettera maiuscola durante le pause.

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

(Newline e rientri cosmetici e non parte del conteggio dei byte)

Ora, alcuni lettori possono notare che questo richiede un po 'di massaggio per funzionare su macchine moderne (l'incantesimo magico è -static -Wl,-N), ma è così che si comportavano le implementazioni reali di C, quindi penso che sia valido. Presuppone inoltre che il set di caratteri sia ASCII e non stia stampando una nuova riga finale.

Bonus: per una versione EBCDIC, è possibile sostituire 8con 22e 64con 32e cambiare la logica per p[1]e p[2]. Per eseguire il test su un sistema non EBCDIC, è possibile compilare con -funsigned-char -fexec-charset=cp037.

L'output è di 43 byte: Hello world«H‹hE‹eL‹lL‹lO‹o ‹ W‹wO‹oR‹rL‹lD

Scala, 92 byte

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
}

Lotto, 184 byte

@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 %*

Curiosamente la riga di comando per timeout/t>nul 1viene danneggiata se non c'è una nuova riga finale, quindi non posso metterla alla fine del file.

Rubino, 108 byte

Prima volta, studente del primo anno. Non è un'aquila ma sono almeno un po 'orgoglioso.

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

Pascal, 187 152 byte

Non esattamente il più efficiente o il più breve, ma funziona abbastanza bene!

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.

Testato e funziona su Free Pascal Compiler 2.6+.

Grazie a @manatwork per aver salvato 35 byte!

Ho usato http://www.onlinecompiler.net/pascal per compilare il file ed eseguirlo su Windows.
Finora non ho riscontrato alcun problema.

C 120 110 104 96 byte

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

Versione Ungolfed

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 Grazie per aver salvato alcuni byte, ottima idea. :)

@Pakk @KarlNapf Grazie ragazzi per i vostri contributi.

può ancora essere abbreviato !? :)

Python 2, 220 189 179 byte

Soluzione senza utilizzare stringhe e capitalize(), conteggio byte così com'è:

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

E una variante un po 'più lunga (191 caratteri) senza reimpostazione del caso:

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 byte

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

Versione non golfata:

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

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

Compilato con TDM-GCC su un computer Windows 10 con Dev-C ++.

Modifica: ho dimenticato le inclusioni nella mia prima versione.