Anima el texto en tu terminal

La meta

El objetivo es "animar" la cadena "Hola mundo" en su salida para que cada personaje se capitalice uno tras otro.

Su programa puede salir después de que cada letra haya sido capitalizada.

Por ejemplo;

# 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

Solo debe animar la cadena una vez y entre cada estado debe haber un retraso de 1 segundo.

Entrada

No se requiere entrada, pero "Hola mundo" debe ser la cadena que está "animada".

Salida

La cadena "Hola mundo" debe estar animada. La salida debe ser como 1 línea para crear una especie de animación de onda. Se permite una nueva línea final vacía. Ejemplo gif;

^{Vi esto en un video de YouTube de Metasploit y pensé que el efecto era bastante bueno, que es donde grabé el gif, por lo que es un poco lento, pero espero que ilustre bien la salida}

Este es el código de golf , el conteo de bytes más bajo se considerará el ganador.

^{Enlace de caja de arena}

Vim 26 bytes

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

Explicación (no .gif todavía):

Primero, debemos ingresar el texto 'hola mundo'. Esto es bastante sencillo. Es solo:

ihello world<ESC>

En este punto, el cursor está en la 'd' en 'mundo'. Próximo:

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

También hay otras dos versiones de 26 bytes que encontré:

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

Python 2, 98 94 90 bytes

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

-9 -4 bytes gracias a @ElPedro -4 bytes gracias a @JonathanAllan y @Rod

Commodore 64, 168 162 137 133 BASIC (y tokenized) bytes utilizados

 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

Deberá usar las abreviaturas de palabras clave BASIC para ingresar esto en un C64 o emulador real (o ingresar el programa en un Commodore 128 y cargarlo nuevamente en modo C64, aunque esto también debería funcionar en el 128). El {control+n}sólo funcionará / pantalla después de la cita de apertura. Es una forma abreviada chr$(14)y, por lo tanto, guarda algunos bytes y cambia el juego de caracteres al modo comercial o los caracteres en mayúscula / minúscula.

He agregado algunas abreviaturas para usted, así que usted. El {clear home}carácter se realiza presionando Shifty la CLR/HOMEtecla después de la comilla de apertura.

Para fines ilustrativos, la lista no consolidada se puede ingresar de la siguiente manera:

 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

Funciona al cambiar el juego de caracteres PETSCII al modo comercial (mayúsculas / minúsculas) y al escribir la cadena hello world en la línea superior de la pantalla que se encuentra en la ubicación de memoria $ 0400, luego tomará el valor en cada ubicación para la próxima 11 bytes desde allí y aumente cada valor en 64 (el equivalente en mayúsculas). Si el contador j es> 0, llama a una rutina en la línea 2 para disminuir la ubicación de memoria anterior en 64 nuevamente.

La línea 3 es una pausa, también escribe un espacio en la ubicación $ 0405 y $ 040b, que es una corrección de errores (que probablemente podría eliminarse para guardar algunos bytes).

C #, 230 215 193 161 135 134 130 bytes

Es C #, así que es largo, ¿verdad? :-( Pero después de un poco de ayuda y búsqueda, yo (y otros, realmente) me las arreglé para eliminar exactamente 100 bytes ya.

Golfed

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

Sin golf

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

Captura de pantalla

Aunque se ve mucho mejor cuando se repite y más rápido.

Actualizaciones

• Perdí 15 bytes al usar el retorno de carro en lugar de lo Clear()que también me permitió reemplazar un uso con System.Consolealgún lugar en línea.

• Programa reemplazado con lambda ahorrando 23 bytes gracias a @devRicher

• Se convirtió en una especie de colaboración con @devRicher en este momento, gracias a algunas de sus sugerencias, ¡logré perder otros 32 bytes!
• Gracias a 2 sugerencias realmente inteligentes e interesantes de @Kratz que logré reemplazar new string(b)con by b[i]=char.ToUpper(b[i])con b[i]-=' ', ¡ahorrándome otros 26 bytes!
• 1 byte menos moviéndote i++gracias a @Snowfire
• 4 bytes menos moviendo el retorno del carro al comienzo de la cadena y eliminándolo i<11de mi forbucle

Powershell, 126 119 107 104 Bytes

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

Revisiones (probablemente habrá muchas):

Cambiar $s.Lengtha const 1011

Constructor de cadenas reestructurado, eliminó 1 declaración de unión y se utilizó en ++$slugar de ($s+1), para guardar algunos bytes gracias a @AdmBorkBork

AdmBorkBork señala que usar la cadena dos veces es en realidad más corto que encapsular y luego usarlo .ToLower(), lo que dice mucho sobre cuán detallado es powershell, -3.

básicamente recorre la longitud de la cadena, forma una matriz de tres partes, pre-capitcal, mayúscula y post-capital, quita 32 de la letra del medio, luego convierte de nuevo en un carácter para obtener mayúsculas, afortunadamente esto no No convierta el espacio en un personaje visible tampoco, espero que esto sea aceptable.

Conjunto CP-1610 , 50 DECLE = 63 bytes

Este código está destinado a ejecutarse en una Intellivision .

Un código de operación CP-1610 está codificado con un valor de 10 bits, conocido como 'DECLE'. Este programa tiene una duración de 50 DECLE, que comienza en $ 4800 y termina en $ 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

Salida

MATL , 30 bytes

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

¡Pruébalo en 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 bytes

¡Gracias @hd por la demora de ser un segundo completo y ninguna fracción del mismo!
Gracias @ user63956 por 2 bytes y @aross por 3 bytes.

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

Corre con -nr.

C, 97 retirados 106 bytes

con caracteres escapados contados como 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: He comentado el retraso de tiempo en TIO no vinculado porque espera a completarse antes de mostrar la salida, tampoco parece reconocer los retornos de carro y pone nuevas líneas. Además, si está en Windows, la suspensión es en milisegundos en lugar de segundos, por lo que sleep(1)debería ser sleep(1000).

Nota 2: He retirado esta entrada por el momento hasta que se hayan solucionado los errores de salida.

JavaScript (ES6), 141 139 131 bytes

Guardado 8B gracias 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)

Explicación

Esto crea una función sin argumentos, que divide la cadena hello worlden una matriz de caracteres y capitaliza el carácter d+1^th . des un contador que comienza como 0y se incrementa cada vez.

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 bytes

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

Intentalo:)

Cómo funciona

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

El fragmento utiliza una versión de 25 bytes que se repite continuamente.

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

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 bytes

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

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

GIF:

Cómo funciona

La secuencia de escape ANSI \ecborra la pantalla.
Cada iteración, el carácter i'th de la cadena codificada está sustituido por su versión en mayúsculas.
La sayfunción siempre regresa True, que se pasa a la función de suspensión que la interpreta como 1segunda.

Ruby, 82 81 bytes

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

^ H es ascii 8 (retroceso), y es solo 1 byte.

C, 87 bytes

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

Compila y ejecuta en Linux.

Mathematica, 130 128 123 110 108 bytes

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]

Explicación: i=1del 11 al 11, imprima del 1 ° al (i-1) carácter de "hola mundo", "hello world"[i]escriba en mayúscula y luego imprima el resto de la cadena, incrementando ial mismo tiempo.

Java 215 212 204 203 bytes

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

Sin golf:

 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 , 106103 bytes

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 simple bucle, limpiar la consola cat('\f')parece algo dependiente del sistema, pero no conozco una mejor manera.

C, 122 bytes

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

Más corto que C #: D

Perl, 75 bytes

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

Utiliza el código ANSI ESCcpara borrar la consola y mover el cursor hacia la parte superior izquierda en cada iteración, pero aún necesita \nal final de la cadena de reemplazo para evitar que toda la animación se pierda en el búfer de línea.

Una llamada exitosa a printdevuelve un valor de 1, al que se puede pasar directamente sleep.

SmileBASIC, 90 71 bytes

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

Jalea , 24 21 bytes

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

Este es un enlace / función niládica que se imprime en STDOUT. No funciona como un programa completo.

El código no se puede probar en TIO; utiliza caracteres de control y TIO no tiene emulador de terminal (todavía).

Cómo funciona

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

Como ejercicio, escribí esto para proporcionar un formato de salida más óptimo que algunas de las otras respuestas. También significa que el cursor se encuentra después de la letra mayúscula más reciente durante las pausas.

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

(Líneas nuevas y muescas cosméticas y que no forman parte del recuento de bytes)

Ahora, algunos lectores pueden notar que esto requiere un poco de masaje para poder ejecutarse en máquinas modernas (el encantamiento mágico es -static -Wl,-N), pero así es como se comportaban las implementaciones reales de C, así que creo que es válido. También supone que el conjunto de caracteres es ASCII y no imprime una nueva línea final.

Bonificación: para una versión EBCDIC, puede reemplazar 8con 22y 64con 32, y cambiar la lógica para p[1]y p[2]. Para probar en un sistema que no sea EBCDIC, puede compilar con -funsigned-char -fexec-charset=cp037.

La salida es de 43 bytes: Hello world«H‹hE‹eL‹lL‹lO‹o ‹ W‹wO‹oR‹rL‹lD

Scala, 92 bytes

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

Sin golf

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
}

Lote, 184 bytes

@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 línea de comando para timeout/t>nul 1se corrompe si no hay una nueva línea final, por lo que no puedo ponerla al final del archivo.

Ruby, 108 bytes

Primera vez, estudiante de primer año. No es un águila, pero al menos estoy un poco orgulloso.

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

Pascal, 187 152 bytes

No es exactamente el más eficiente o el más corto, ¡pero funciona bastante 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.

Probado y funciona en Free Pascal Compiler 2.6+.

¡Gracias a @manatwork por guardar 35 bytes!

He usado http://www.onlinecompiler.net/pascal para compilar el archivo y ejecutarlo en Windows.
No he visto ningún problema con eso, hasta ahora.

C 120 110 104 96 bytes

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

Versión sin golf

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 Gracias por guardar algunos bytes, gran idea. :)

@Pakk @KarlNapf Gracias a todos por sus aportes.

¿Todavía se puede acortar? :)

Python 2, 220 189 179 bytes

Solución sin usar cadenas y capitalize(), byte cuenta como es:

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

Y una variante un poco más larga (191 caracteres) sin reiniciar el 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 Bytes

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

Versión sin golf:

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

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

Compilado con TDM-GCC en una máquina con Windows 10 con Dev-C ++.

Editar: Olvidé los incluye en mi primera versión.