터미널에서 텍스트를 애니메이션

목표

목표는 출력에서 ​​문자열 "Hello world"를 "애니메이션"하여 각 문자가 서로 대문자로 표시되도록하는 것입니다.

각 문자가 대문자로 입력되면 프로그램이 종료 될 수 있습니다.

예를 들어;

# 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

문자열을 한 번만 애니메이션하고 각 상태 사이에 1 초 지연이 있어야합니다.

입력

입력이 필요하지 않지만 "Hello world"는 "animated"인 문자열이어야합니다.

산출

"Hello world"문자열은 애니메이션이어야합니다. 일종의 웨이브 애니메이션을 만들려면 출력이 1 줄이어야합니다. 빈 줄 바꿈이 허용됩니다. 예 gif;

^{나는 metasploit youtube 비디오에서 이것을 보았고 그 효과가 꽤 멋지다고 생각했다.}

이것은 code-golf 이며 가장 낮은 바이트 수는 승자로 간주됩니다.

^{샌드 박스 링크}

Vim 26 바이트

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

설명 (아직 .gif 없음) :

먼저 'hello world'텍스트를 입력해야합니다. 이것은 매우 간단합니다. 그냥 :

ihello world<ESC>

이때 커서는 'world'의 'd'에 있습니다. 다음:

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

내가 찾은 다른 두 가지 26 바이트 버전도 있습니다.

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

파이썬 2, 98 94 90 바이트

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

-9 -4 @ElPedro 덕분에 바이트 -4 @JonathanAllan 및 @Rod 덕분 바이트

코머 64 168 162 137 133 BASIC (및 토큰)가 사용되는 바이트

 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

BASIC 키워드 약어를 사용하여이를 실제 C64 또는 에뮬레이터에 입력하거나 Commodore 128에 프로그램을 입력하고 C64 모드로 다시로드해야합니다 (128에서도 작동해야 함). 는 {control+n}단지 개방 견적 후 / 디스플레이를 작동합니다. 축약 형 chr$(14)이므로 일부 바이트를 저장하고 문자 세트를 비즈니스 모드 또는 대문자 / 소문자로 전환합니다.

나는 당신을 위해 몇 가지 약어를 추가했습니다. {clear home}문자를 누름으로써 구성되어 Shift상기 CLR/HOME개구부 따옴표 후 키.

설명을 위해 명확하지 않은 목록은 다음과 같이 입력 할 수 있습니다.

 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

PETSCII 문자셋을 비즈니스 모드 (대 / 소문자)로 전환하고 hello world 문자열을 메모리 위치 $ 0400에있는 화면의 맨 윗줄에 쓰면 다음 위치의 각 위치에서 값을 가져옵니다. 거기에서 11 바이트이며 각 값을 64만큼 증가시킵니다 (대문자 동일). j 카운터가 0보다 크면 2 행에서 루틴을 호출하여 이전 메모리 위치를 다시 64만큼 줄입니다.

3 행은 일시 정지이며, $ 0405와 $ 040b에 공간을 씁니다. 버그 수정 (일부 바이트를 저장하기 위해 제거 될 수 있음)입니다.

C #을 230 215 193 161 135 134 130 바이트

C #이므로 오래되었습니다! :-( 그러나 약간의 도움과 검색 후, 나는 (그리고 다른 사람들은) 정확히 100 바이트를 이미 제거했습니다.

골프

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

언 골프

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

스크린 샷

루핑하면 더 좋아 보이지만 더 빠릅니다 ..

업데이트

• 대신 캐리지 리턴을 사용하여 15 바이트를 잃어 버린 대신 인라인 Clear()으로 사용을 대체 할 수있었습니다 System.Console.

• @devRicher 덕분에 23 바이트를 절약하는 람다로 대체 된 프로그램

• 이 시점에서 @devRicher 와의 협력이되었습니다. 그의 제안 덕분에 32 바이트를 더 잃을 수있었습니다!
• 에 의해 감사 2 개 정말 똑똑하고 재미있는 제안 @Kratz 나는 대체하기 위해 관리 new string(b)와 b와 b[i]=char.ToUpper(b[i])함께 b[i]-=' '나에게 또 다른 26 바이트를 저장!
• @Snowfirei++ 덕분 에 이동하여 1 바이트 감소
• 캐리지 리턴을 문자열의 시작 부분으로 이동 i<11하고 for루프 에서 제거하면 4 바이트가 줄어 듭니다.

파워 쉘, 126 119 107 104 바이트

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

개정 (많이있을 것입니다) :

$s.Lengthconst 1011로 변경

@AdmBorkBork 덕분에 일부 문자열 을 절약하기 위해 재구성 된 문자열 빌더로 1 개의 join 문을 제거하고 ++$s대신 사용 했습니다.($s+1)

AdmBorkBork는 문자열을 두 번 사용하는 것이 실제로 캡슐화 한 다음보다 짧다는 것을 지적합니다 .ToLower().

기본적으로 문자열의 길이를 반복하고 세 부분의 배열을 형성합니다. 공간을 눈에 보이는 캐릭터로 바꾸지 마십시오.

CP-1610 어셈블리, 50 DECLE = 63 바이트

이 코드는 Intellivision에서 실행되도록 고안되었습니다 .

CP-1610 opcode는 'DECLE'로 알려진 10 비트 값으로 인코딩됩니다. 이 프로그램의 길이는 $ 4800에서 $ 4831로 끝나는 50 DECLE입니다.

                                  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

산출

MATL , 30 바이트

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

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 바이트

지연 시간이 1 초이고 그 일부도없는 @hd에게 감사합니다!
2 바이트는 @ user63956, 3 바이트는 @aross에게 감사합니다.

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

로 실행하십시오 -nr.

C, 97은 106 바이트를 철회했습니다.

이스케이프 문자는 1 바이트로 계산

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

참고 : 연결되지 않은 TIO는 출력을 표시하기 전에 완료를 기다리기 때문에 시간 지연을 언급했으며 캐리지 리턴을 인식하지 못하고 새 줄을 넣습니다. 또한 Windows를 사용하는 경우 절전 모드는 초가 아닌 밀리 초 단위이므로 sleep(1)이어야합니다 sleep(1000).

참고 2 : 출력 버그가 해결 될 때까지 잠시 동안이 항목을 철회했습니다.

자바 스크립트 (ES6), 141 (139) 131 바이트

Apsillers 덕분에 8B 절약

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

설명

이 문자열을 분할 인수가없는 함수 생성 hello world문자의 배열로와 대문자 d+1^번째 문자를. d로 시작하고 0매번 증가 하는 카운터입니다 .

용법

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

누델 , 22 바이트

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

시도 해봐:)

작동 원리

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

스 니펫은 계속 반복 되는 25 바이트 버전을 사용합니다 .

<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 바이트

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
}

펄 6 , 65 61 바이트

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

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

GIF :

작동 원리

ANSI 이스케이프 시퀀스 \ec는 화면을 지 웁니다. 하드 코드 된 문자열
의 i'문자' 는 각 반복마다 대문자 버전으로 대체됩니다.
이 say함수는 항상을 반환 True하며, 이 함수 는 절전 함수로 전달되어 1두 번째 로 해석됩니다 .

루비, 82 81 바이트

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

^ H는 ASCII 8 (백 스페이스)이며 1 바이트입니다.

C 120 110 104 96 바이트

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

언 골프 버전

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 바이트를 절약 해 주셔서 감사합니다. :)

@Pakk @KarlNapf 입력에 감사드립니다.

여전히 단축 될 수 있습니다!? :)

C, 87 바이트

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

Linux에서 컴파일하고 실행합니다.

매쓰, 130 128 123 110 108 바이트

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]

설명 : i=111에서 11 까지 , "hello world"의 첫 번째 문자에서 (i-1) 번째 문자까지 "hello world"[i]인쇄하고 대문자 를 사용한 다음 나머지 문자열을 인쇄 i하면서 동시에 증가시킵니다 .

자바 215 212 204 203 바이트

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

언 골프 드 :

 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 바이트

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

간단한 루프로 콘솔을 지우는 것은 cat('\f')시스템에 다소 의존적이지만 더 나은 방법은 알지 못합니다.

C, 122 바이트

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

C #보다 짧음 : D

펄, 75 바이트

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

ANSI 코드 ESCc를 사용하여 콘솔을 지우고 반복 할 때마다 커서를 왼쪽 상단으로 이동하지만 \n라인 버퍼에서 전체 애니메이션이 손실되지 않도록하려면 대체 문자열의 끝에서 여전히 필요합니다 .

호출이 성공 print하면 1 값 을 반환하며이 값은로 직접 전달 될 수 있습니다 sleep.

SmileBASIC, 90 71 바이트

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

젤리 , 24 21 바이트

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

이것은 STDOUT으로 인쇄되는 닐라 딕 링크 / 함수입니다. 전체 프로그램으로 작동하지 않습니다.

코드는 TIO에서 테스트 할 수 없습니다. 제어 문자를 사용하며 TIO에는 아직 터미널 에뮬레이터가 없습니다.

작동 원리

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

연습으로, 나는 다른 답변보다 더 최적의 출력 형식을 제공하기 위해 이것을 썼습니다. 또한 일시 정지 중에 커서가 가장 최근에 대문자로 표시된 문자 뒤에 놓임을 의미합니다.

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

(줄 바꿈 및 들여 쓰기는 바이트 수의 일부가 아닌 외관상)

이제 일부 독자는 최신 머신에서 실행하기 위해 약간의 마사지가 필요하다는 것을 알 수 있습니다 (마법의 주문은입니다 -static -Wl,-N). 그러나 이것이 C의 실제 구현 방식이 작동했기 때문에 유효하다고 생각합니다. 또한 문자 집합이 ASCII라고 가정하고 후행 줄 바꿈을 인쇄하지 않습니다.

보너스 : EBCDIC를 버전, 당신은 대체 할 수 8와 22와 64와 32와의 논리를 전환 p[1]하고 p[2]. 비 EBCDIC 시스템에서 테스트하려면을 사용하여 컴파일 할 수 있습니다 -funsigned-char -fexec-charset=cp037.

출력은 43 바이트입니다. Hello world«H‹hE‹eL‹lL‹lO‹o ‹ W‹wO‹oR‹rL‹lD

스칼라, 92 바이트

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

언 골프

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
}

배치, 184 바이트

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

흥미롭게도 timeout/t>nul 1마지막 줄 바꿈이 없으면 명령 줄 이 손상되어 파일 끝에 넣을 수 없습니다.

루비, 108 바이트

처음으로, 첫해 학생. 독수리는 아니지만 나는 조금 자랑스러워합니다.

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

파스칼, 187152 바이트

정확히 가장 효율적이거나 가장 짧지는 않지만 잘 작동합니다!

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.

Free Pascal Compiler 2.6 이상에서 테스트 및 작동했습니다.

35 바이트 를 절약 한 @manatwork 에 감사 합니다!

내가 사용했습니다 http://www.onlinecompiler.net/pascal을 파일을 컴파일하고 윈도우에서 실행 할 수 있습니다.
지금까지 아무런 문제도 보지 못했습니다.

파이썬 2, 220 189 179 바이트

문자열을 사용하지 않고 솔루션 capitalize()은 바이트 수를 그대로 계산합니다.

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

대소 문자를 재설정하지 않고 조금 더 긴 변형 (191 자) :

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 바이트

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

언 골프 버전 :

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

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

Dev-C ++를 사용하는 Windows 10 시스템에서 TDM-GCC로 컴파일되었습니다.

편집 : 첫 번째 버전에서 포함을 잊어 버렸습니다.