Animieren Sie den Text in Ihrem Terminal

Das Ziel

Das Ziel ist es, die Zeichenfolge "Hallo Welt" in Ihrer Ausgabe zu "animieren", sodass alle Zeichen nacheinander in Großbuchstaben geschrieben werden.

Ihr Programm kann beendet werden, nachdem jeder Buchstabe groß geschrieben wurde.

Zum Beispiel;

# 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

Die Zeichenfolge sollte nur einmal animiert werden, und zwischen jedem Status sollte eine Verzögerung von 1 Sekunde liegen.

Eingang

Es ist keine Eingabe erforderlich, aber "Hallo Welt" muss die Zeichenfolge sein, die "animiert" ist.

Ausgabe

Der String "Hallo Welt" muss animiert sein. Die Ausgabe muss 1-zeilig sein, um eine Art Wellenanimation zu erstellen. Eine leere nachgestellte neue Zeile ist zulässig. Beispiel gif;

^{Ich habe das auf einem Metasploit-Youtube-Video gesehen und fand den Effekt ziemlich cool. Dort habe ich das GIF aufgenommen, es ist also ein bisschen träge, aber ich hoffe, es zeigt die Ausgabe in Ordnung}

Dies ist Code-Golf . Die niedrigste Byte-Anzahl wird als Sieger gewertet.

^Sandbox-Link

Vim 26 Bytes

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

Erklärung (noch kein .gif):

Zuerst müssen wir den Text "Hallo Welt" eingeben. Das ist ziemlich einfach. Es ist nur:

ihello world<ESC>

Zu diesem Zeitpunkt befindet sich der Cursor auf dem 'd' in 'world'. Nächster:

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

Es gibt auch zwei andere 26-Byte-Versionen, die ich gefunden habe:

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 dank @ElPedro -4 Bytes dank @JonathanAllan und @Rod

Commodore 64, 168 162 137 133 BASIC (und tokenized) Bytes verwendet

 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

Sie müssen BASIC-Schlüsselwortabkürzungen verwenden, um dies in einen echten C64 oder Emulator einzugeben (oder Sie geben das Programm in einen Commodore 128 ein und laden es im C64-Modus zurück, obwohl dies auch auf dem 128 funktionieren sollte). Das {control+n}wird erst nach dem Eröffnungszitat funktionieren / angezeigt. Es ist eine Abkürzung für chr$(14)und speichert daher einige Bytes und schaltet den Zeichensatz in den Geschäftsmodus oder in Groß- / Kleinschreibung.

Ich habe einige Abkürzungen für Sie hinzugefügt, damit Sie. Das {clear home}Zeichen wird durch Drücken von Shiftund der CLR/HOMETaste nach dem öffnenden Anführungszeichen erzeugt.

Zur Veranschaulichung kann die uneingeschränkte Auflistung wie folgt eingegeben werden:

 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

Es funktioniert, indem der PETSCII-Zeichensatz in den Geschäftsmodus (Groß- / Kleinschreibung) geschaltet wird und der Hallo-Welt-String in die oberste Zeile des Bildschirms geschrieben wird, der sich am Speicherort $ 0400 befindet. Anschließend wird der Wert an jedem Speicherort für den nächsten übernommen 11 Bytes von dort und erhöhen Sie jeden Wert um 64 (das Äquivalent in Großbuchstaben). Wenn der Zähler j> 0 ist, ruft er in Zeile 2 eine Routine auf, um den vorherigen Speicherplatz wieder um 64 zu verringern.

Zeile 3 ist eine Pause. Außerdem wird ein Leerzeichen an die Positionen $ 0405 und $ 040b geschrieben. Dies ist eine Fehlerbehebung (die möglicherweise entfernt werden könnte, um einige Bytes zu sparen).

C # 230 215 193 161 135 134 130 Bytes

Es ist C #, also ist es lange richtig! :-( Aber nach einiger Hilfe und Recherche ist es mir (und anderen wirklich) gelungen, bereits genau 100 Bytes zu entfernen.

Golf gespielt

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

Bildschirmfoto

Obwohl es beim Looping viel besser und schneller aussieht.

Aktualisierung

• Verlust von 15 Bytes durch Verwendung von Carriage Return, Clear()wodurch ich auch die Verwendung von System.Consoleirgendwo inline ersetzen konnte .

• Ersetztes Programm mit Lambda-Einsparung von 23 Bytes dank @devRicher

• Zu diesem Zeitpunkt wurde es zu einer Art Zusammenarbeit mit @devRicher , dank einiger seiner Vorschläge konnte ich weitere 32 Bytes verlieren!
• Dank 2 wirklich intelligente und interessante Vorschläge von @Kratz ich es geschafft , zu ersetzen , new string(b)mit bund b[i]=char.ToUpper(b[i])mit b[i]-=' 'mir weitere 26 Bytes gespart!
• 1 Byte weniger durch Verschieben i++dank @Snowfire
• 4 Bytes weniger, indem Sie den Wagenrücklauf an den Anfang der Zeichenfolge verschieben und i<11aus meiner forSchleife entfernen

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

Revisionen (es wird wahrscheinlich viele geben):

Ändern Sie $s.Lengthzu const 1011

Restrukturierter String Builder, 1 Join-Anweisung entfernt und ++$sstattdessen verwendet ($s+1), um dank @AdmBorkBork einige Bytes zu sparen

AdmBorkBork weist darauf hin, dass das zweimalige Verwenden des Strings tatsächlich kürzer ist als das Einkapseln und anschließende .ToLower()Einfügen - was viel darüber aussagt, wie wortreich Powershell ist, -3!

Im Grunde genommen durchlaufen Sie die Länge der Zeichenkette, bilden ein Array aus drei Teilen, dem Vorkapital-, dem Groß- und dem Nachkapital. Entfernen Sie 32 aus dem mittleren Buchstaben und konvertieren Sie dann zurück in ein Zeichen, um Großbuchstaben zu erhalten. Zum Glück ist dies nicht der Fall verwandle den Raum auch nicht in einen sichtbaren Charakter, ich hoffe, das ist akzeptabel?

CP-1610- Baugruppe, 50 DECLEs = 63 Byte

Dieser Code soll auf einer Intellivision ausgeführt werden .

Ein CP-1610-Opcode wird mit einem 10-Bit-Wert codiert, der als "DECLE" bezeichnet wird. Dieses Programm ist 50 DECLE lang und beginnt bei 4800 US-Dollar und endet bei 4831 US-Dollar.

                                  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

Ausgabe

MATL , 30 Bytes

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

Probieren Sie es bei 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

Vielen Dank an @hd für die Verzögerung von einer vollen Sekunde und keinen Bruchteil davon!
Danke @ user63956 für 2 Bytes und @aross für 3 Bytes.

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

Laufen Sie mit -nr.

C, 97 abgezogen 106 Bytes

mit maskierten Zeichen als 1 Byte gezählt

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

Hinweis: Ich habe die Zeitverzögerung für nicht verknüpftes TIO auskommentiert, da es auf den Abschluss wartet, bevor die Ausgabe angezeigt wird, außerdem Wagenrückläufe nicht erkennt und neue Zeilen einfügt. Wenn Sie unter Windows arbeiten, wird der Energiesparmodus in Millisekunden anstatt in Sekunden sleep(1)angezeigt sleep(1000).

Anmerkung 2: Ich habe diesen Eintrag für den Moment zurückgezogen, bis die Ausgabefehler behoben wurden.

JavaScript (ES6), 141 139 131 Bytes

8B dank Apsillers gerettet

_=>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)

Erläuterung

Dadurch wird eine Funktion ohne Argumente erstellt, die die Zeichenfolge hello worldin ein Array von Zeichen aufteilt und das d+1^dritte Zeichen in ^{Großbuchstaben} schreibt. dist ein Zähler, der wie 0folgt beginnt und jedes Mal erhöht wird.

Verwendungszweck

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

Nudel , 22 Bytes

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

Versuch es:)

Wie es funktioniert

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

Das Snippet verwendet eine 25-Byte- Version, die sich fortlaufend wiederholt.

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

Wie es funktioniert

Die ANSI-Escape-Sequenz \eclöscht den Bildschirm.
Bei jeder Iteration wird das i'te Zeichen der fest codierten Zeichenfolge durch die Version in Großbuchstaben ersetzt.
Die sayFunktion kehrt immer zurück Trueund wird an die Sleep-Funktion weitergeleitet, die sie als 1Sekunde interpretiert .

Ruby, 82 81 Bytes

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

^ H ist ASCII 8 (Rücktaste) und ist nur 1 Byte.

C 87 Bytes

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

Kompiliert und läuft unter 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]

Erläuterung: i=1Drucken Sie von bis 11 vom ersten bis zum (i-1) -ten Zeichen von "Hallo Welt", schreiben Sie die Großbuchstaben ein "hello world"[i], und drucken Sie dann den Rest der Zeichenfolge, wobei Sie gleichzeitig die Inkrementierung vornehmen i.

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

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

Nur eine einfache Schleife, mit der die Konsole geleert wird, cat('\f')scheint etwas systemabhängig zu sein, aber mir ist kein besserer Weg bekannt.

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

Kürzer als C #: D

Perl, 75 Bytes

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

Verwendet den ANSI-Code ESCc, um die Konsole zu löschen und den Cursor bei jeder Iteration nach links oben zu bewegen. Er muss jedoch \nam Ende der Ersetzungszeichenfolge stehen, damit nicht die gesamte Animation im Zeilenpuffer verloren geht.

Ein erfolgreicher Aufruf von printgibt den Wert 1 zurück, der direkt an übergeben werden kann sleep.

SmileBASIC, 90 71 Bytes

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

Jelly , 24 21 Bytes

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

Dies ist ein Link / eine Funktion von Niladic, der / die auf STDOUT gedruckt wird. Es funktioniert nicht als vollständiges Programm.

Der Code kann nicht mit TIO getestet werden. es verwendet Steuerzeichen und TIO hat (noch) keinen Terminal-Emulator.

Wie es funktioniert

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

Als Übung habe ich dies geschrieben, um ein optimaleres Ausgabeformat als einige der anderen Antworten bereitzustellen. Dies bedeutet auch, dass der Cursor während der Pausen hinter dem zuletzt großgeschriebenen Buchstaben steht.

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

(Zeilenumbrüche und Einrückungen sind kosmetisch und nicht Teil der Byteanzahl)

Nun mögen einige Leser bemerken, dass dies einige Massagen erfordert, um auf modernen Maschinen ausgeführt zu werden (die magische Beschwörung ist -static -Wl,-N), aber so haben sich echte Implementierungen von C früher verhalten, also denke ich, dass es gültig ist. Es wird außerdem davon ausgegangen, dass der Zeichensatz ASCII ist, und es wird keine abschließende Newline gedruckt.

Bonus: Für eine EBCDIC - Version können Sie ersetzen 8mit 22und 64mit 32, und schalten Sie die Logik für p[1]und p[2]. Um auf einem Nicht-EBCDIC-System zu testen, können Sie mit kompilieren -funsigned-char -fexec-charset=cp037.

Die Ausgabe beträgt 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}

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
}

Batch, 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 %*

Seltsamerweise wird die Befehlszeile für timeout/t>nul 1beschädigt, wenn keine nachgestellte Zeile vorhanden ist, sodass ich sie nicht am Ende der Datei einfügen kann.

Rubin, 108 Bytes

Zum ersten Mal im ersten Jahr Student. Es ist kein Adler, aber ich bin zumindest ein bisschen stolz.

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

Pascal, 187 152 Bytes

Nicht gerade die effizienteste oder die kürzeste, funktioniert aber ganz gut!

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.

Getestet und funktioniert mit Free Pascal Compiler 2.6+.

Danke an @manatwork für das Speichern von 35 Bytes!

Ich habe http://www.onlinecompiler.net/pascal verwendet , um die Datei zu kompilieren und unter Windows auszuführen.
Habe bisher kein Problem damit gesehen.

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

Ungolfed-Version

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 Danke für das Speichern einiger Bytes, tolle Idee. :)

@Pakk @KarlNapf Vielen Dank für Ihre Beiträge.

kann noch gekürzt werden !? :)

Python 2, 220 189 179 Bytes

Lösung ohne Verwendung von Strings und capitalize()Byteanzahl wie folgt:

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

Und eine etwas längere Variante (191 Zeichen) ohne Zurücksetzen der Groß- / Kleinschreibung:

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

Ungolfed-Version:

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

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

Kompiliert mit TDM-GCC auf einem Windows 10-Computer mit Dev-C ++.

Edit: Ich habe die Includes in meiner ersten Version vergessen.