对终端中的文本进行动画处理

目标

目标是在输出中对字符串“ 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”必须是“已设置动画”的字符串。

输出量

字符串“ Hello world”必须设置为动画。输出必须为1行才能创建一种wave动画。尾随空行是允许的。例子gif;

^{我在metasploit youtube视频上看到了这一点，并认为效果非常酷，这是我从中录制gif的地方，因此有点迟钝，但我希望它能说明输出的罚款}

这是代码高尔夫球，最低字节数将被视为获胜者。

^沙盒链接

Vim 26字节

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

说明（尚无.gif）：

首先，我们必须输入“ hello world”文本。这很简单。只是：

ihello world<ESC>

此时，光标位于“世界”中的“ 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>

Python 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。

第三行是一个暂停，它还会在$ 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.Consoleinuse 替换为内联。

• 使用@devRicher，用lambda节省23个字节的替换程序

• 由于与他的一些建议，这时我与@devRicher进行了某种合作，我设法又损失了32个字节！
• 感谢@Kratz提出的2条非常聪明和有趣的建议，我设法new string(b)用b和替换b[i]=char.ToUpper(b[i])了b[i]-=' '，从而又节省了26个字节！
• 1个字节由移动更少i++由于@Snowfire
• 通过将回车移到字符串的开头并i<11从我的for循环中删除，减少了4个字节

的powershell，126 119 107 104个字节

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

修订（可能会有很多）：

更改$s.Length为const 1011

重组的字符串生成器，删除了1个join语句，并使用++$s代替($s+1)，以节省一些字节，这要感谢@AdmBorkBork

AdmBorkBork指出，仅使用字符串两次实际上比封装然后添加字符串短.ToLower()-这说明了许多关于powershell的详细信息，-3！

基本上遍历字符串的长度，形成一个由三部分组成的数组，即大写字母前，大写字母和大写字母后，从中间字母减去32，然后再转换回char以获取大写字母，幸运的是，也不会将空间变成可见的角色，我希望这是可以接受的吗？

CP-1610组件，50 DECLE = 63字节

该代码旨在在Intellivision上运行。

CP-1610操作码使用10位值（称为“ DECLE”）进行编码。这个程序长50 DECLE，开始于$ 4800，结束于$ 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

输出量

MATL，30字节

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

在MATL在线上尝试一下！

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字节

谢谢@hd，因为延迟是整整一秒，而且是零头！
感谢@ user63956 2个字节和@aross 3个字节。

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：我暂时撤消了该条目，直到消除了输出错误为止。

JavaScript（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^th个字符。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()

Noodel，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
}

Perl 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，并将其传递给sleep函数，该函数将其解释为1秒。

Ruby，82 81个字节

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

^ H是ascii 8（退格），并且只有1个字节。

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=1到11，从“ hello world”的第1个字符到第（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

Perl，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的niladic链接/功能。它不能作为完整程序运行。

该代码无法在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

Scala，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如果没有尾随换行符，则该命令行会损坏，因此我不能将其放在文件末尾。

Ruby，108个字节

第一次，一年级学生。这不是老鹰，但我至少有点骄傲。

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

帕斯卡，187字节

并非最高效或最短，但效果很好！

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+上运行。

感谢@manatwork节省了35个字节！

我已经使用http://www.onlinecompiler.net/pascal来编译文件并在Windows上运行它。
到目前为止，还没有发现任何问题。

Ç 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谢谢大家的投入。

仍然可以缩短！:)

Python 2 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一起编译。

编辑：我忘记了我的第一个版本中的包含。