Erstellen Sie in einer beliebigen Programmiersprache ein Programm, das Eingaben entgegennimmt und den auf einer Tastatur eingegebenen Text animiert.

Die Verzögerung zwischen den einzelnen Zeichen sollte variieren, um das echte Tippen auf einer Tastatur zu simulieren. Die Verzögerung beträgt 0.1, 0.1, 0.5, 0.1, 0.1, 0.5 ...Sekunden, bis das letzte Zeichen gedruckt wird. Die endgültige Ausgabe soll auf dem Bildschirm verbleiben.

Sie müssen die aktuelle Textzeile überschreiben, damit der Text nicht in neuen Zeilen gedruckt wird.

Beispiel die Eingabe "Hallo, PPCG! Auf Wiedersehen Erde!" sollte zu der folgenden Animation führen (beachten Sie, dass die Abtastrate des Gif-Herstellers niedrig war, sodass das wahre Ergebnis leicht davon abweicht):

Da dies Codegolf ist, gewinnt die kleinste Menge an Bytes.

C 108 93 89 78 73 80 Bytes

f(char *s){for(int i=0;s[i];fflush(0),usleep(100000*(i++%3?1:5)))putchar(s[i]);}

Ungolfed-Version:

 void f(char *s)
 {
  for( int i=0;s[i];)
  {
    putchar(s[i]);
    fflush(0);
    usleep(100000*(i++%3?1:5));
 }
}

@Kritixi Lithos @Metoniem Vielen Dank für Ihre Eingabe! einige Bytes gespeichert.

Irgendwie int igab mir gerade einen Segmentierungsfehler beim Ausführen, so dass ich ihn mit 0 initialisierte.

Gelee , 13 Bytes

115D÷⁵ṁȮœS¥@"

Dies ist eine monadische Verknüpfung / Funktion. Aufgrund der impliziten Ausgabe funktioniert es nicht als vollständiges Programm.

Nachprüfung

Wie es funktioniert

115D÷⁵ṁȮœS¥@"  Monadic link. Argument: s (string)

115            Set the return value to 115.
   D           Decimal; yield [1, 1, 5].
    ÷⁵         Divide all three integers by 10.
      ṁ        Mold; repeat the items of [0.1, 0.1, 0.5] as many times as
               necessary to match the length of s.
          ¥@"  Combine the two links to the left into a dyadic chain and apply it
               to each element in s and the corr. element of the last return value.
       Ȯ         Print the left argument of the chain (a character of s) and sleep
                 as many seconds as the right argument indicates (0.1 or 0.5).

MATLAB, 74 Bytes

c=input('');p=[1,1,5]/10;for i=c;fprintf('%s',i);p=p([2,3,1]);pause(p);end

Erläuterung:

Ich habe eine ganze Weile gebraucht, um die fprintfVersion kürzer als disp()mit zu machen clc. Der Durchbruch war, als ich herausfand, dass pauseein Vektor als Argument verwendet werden kann. In diesem Fall wird nur der erste Wert ausgewählt. Dadurch ist es möglich, einen Zähler wegzulassen.

c=input('');    % Take input as 'Hello'
p=[.1,.1,.5];   % The various pause times

for i=c;            % For each of the characters in the input c
  fprintf('%s',i);  % Print the character i, without any trailing newline or whitespace
                    % No need to clear the screen, it will just append the new character 
                    % after the existing ones
  pause(p);         % pause for p(1) seconds. If the input to pause is a vector, 
                    % then it will choose the first value
  p=p([2,3,1]);     % Shift the pause times
end

Der kürzeste, den ich verwendet habe, dispwar 81 Bytes:

c=input('');p=[1,1,5]/10;for i=1:nnz(c),clc;disp(c(1:i));pause(p(mod(i,3)+1));end

JavaScript (ES6), 67 Byte

f=(i,o,n=0)=>i[n]&&(o.data+=i[n],setTimeout(f,++n%3?100:500,i,o,n))

<form><input id=i><button onclick=f(i.value,o.firstChild)>Go!</button><pre id=o>

V , 20 19 18 Bytes

1 Byte gespart dank @DJMcMayhem

1 Byte durch Entfernen òam Ende gespeichert

òD1gÓulD1gÓulDgÓul

Schrecklich ungolfisch, ich weiß, es ist einfach so streng u und hindert mich daran, verschachtelte Schleifen zu benutzen.

Erläuterung

Der Cursor beginnt am Anfang des Puffers, der das erste Zeichen der Eingabe ist.

ò                      " Start recursion
 D                     " Deletes everything from the cursor's position to the end of line
  1gÓ                  " Sleep for 100ms
     u                 " Undo (now the deletion is reverted)
      l                " Move cursor one to the right
       D1gÓul          " Do it again
             D         " Same as before but...
              gÓ       " Sleep for 500ms this time
                ul     " Then undo and move right
                       " Implicit ò

Gif kommt bald ...

MATL , 16 Bytes

"@&htDTT5hX@)&Xx

Probieren Sie es bei MATL Online!

Erläuterung

"        % Implicitly input string. For each char of it
  @      %   Push current char
  &h     %   Concatenate everything so far into a string
  tD     %   Duplicate and display
  TT5h   %   Push array [1 1 5]
  X@)    %   Get the k-th element modularly, where k is current iteration.
         %   So this gives 1, 1, 5 cyclically
  &Xx    %   Pause for that many tenths of a second and clear screen
         % Implicit end. Implicitly display the final string, again (screen
         % was deleted at the end of the last iteration)

Nudel , 18 Bytes

ʋ115ṡḶƙÞṡạḌ100.ṡ€ß

Versuch es:)

Wie es funktioniert

                   # Input is automatically pushed to the stack.
ʋ                  # Vectorize the string into an array of characters.
 115               # Push on the string literal "115" to be used to create the delays.
    ṡ              # Swap the two items on the stack.

     ḶƙÞṡạḌ100.ṡ€  # The main loop for the animation.
     Ḷ             # Loops the following code based off of the length of the string.
      ƙ            # Push on the current iteration's element of the character array (essentially a foreach).
       Þ           # Pop off of the stack and push to the screen.
        ṡ          # Swap the string "115" and he array of characters (this is done because need array of characters on the top for the loop to know how many times to loop)
         ạ         # Grab the next character in the string "115" (essentially a natural animation cmd that every time called on the same object will access the next item looping)
                   # Also, turns the string into an array of characters.
          Ḍ100.    # Pop the character off and convert to a number then multiply by 100 to get the correct delay. Then delay for that many ms.
               ṡ   # Swap the items again to compensate for the one earlier.
                €  # The end of the loop.

                 ß # Clears the screen such that when implicit popping of the stack occurs it will display the correct output.

19-Byte- Code-Snippet, das endlose Schleifen durchläuft.

<div id="noodel" cols="30" rows="2" code="ʋ115ṡḷḶƙÞṡạḌ100.ṡ€ß" input='"Hello, PPCG! Goodbye Earth!"'/>
<script src="https://tkellehe.github.io/noodel/release/noodel-2.5.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

APL, 23 Bytes

⊢{⍞←⍺⊣⎕DL⍵÷10}¨1 1 5⍴⍨⍴

Erläuterung:

               1 1 5⍴⍨⍴  ⍝ repeat the values [1,1,5] to match the input length
⊢                        ⍝ the input itself
 {           }¨          ⍝ pairwise map
      ⎕DL⍵÷10            ⍝ wait ⍵÷10 seconds, where ⍵ is the number
     ⊣                   ⍝ ignore that value, and
  ⍞←⍺                    ⍝ output the character   

C # 131 Bytes

Nicht viel zu erklären. Es wird nur eine Zeichenfolge (in "" eingeschlossen) als Argument verwendet und jedes Zeichen mit dem richtigen Verzögerungsmuster gedruckt. Nach der Animation wird ein angezeigt, OutOfRangeExceptionda die Schleife nicht angehalten wird, nachdem alle Zeichen durchlaufen wurden. Da es sich um eine Endlosschleife handelt, bedeutet das auch, dass ich sie int Mainanstelle von verwenden kann void Main;-)

Golf gespielt

class C{static int Main(string[]a){for(int i=0;){System.Console.Write(a[0][i]);System.Threading.Thread.Sleep(i++%3<1?500:100);}}}

Ungolfed

class C
{
    static int Main(string[] a)
    {
        for (int i = 0; ;)
        {
            System.Console.Write(a[0][i]);
            System.Threading.Thread.Sleep(i++ % 3 < 1 ? 500 : 100);
        }
    }
}

Bearbeitungen

• 1 Byte wurde eingespart, indem das Inkrementieren iinnerhalb der Sleep()Methode statt in der forSchleife vorgenommen wurde. (Danke Maliafo )

SmileBASIC, 61 bytes

LINPUT S$FOR I=0TO LEN(S$)-1?S$[I];
WAIT 6+24*(I MOD 3>1)NEXT

I think the delay calculation could be a lot shorter.

Clojure, 81 bytes

#(doseq[[c d](map vector %(cycle[100 100 500]))](Thread/sleep d)(print c)(flush))

Loops over the input string zipped with a infinite list of [100 100 500].

(defn typer [input]
  ; (map vector... is generally how you zip lists in Clojure 
  (doseq [[chr delay] (map vector input (cycle [100 100 500]))]
    (Thread/sleep delay)
    (print chr) (flush)))

Bash (+utilities), 32 byte

Note, this will beep in the process, but who said submissions can not have fancy sound effects !

Golfed

sed 's/.../&\a\a\a\a/g'|pv -qL10

Demo

Python 3, 83 75 bytes

import time;i=0
for c in input():i+=1;print(end=c);time.sleep(i%3and.1or.5)

Try it online!

Powershell, 66 65 63 Bytes

[char[]]$args|%{sleep -m((1,1,5)[++$i%3]*100);Write-Host $_ -N}

-1 removed unneeded white space after -m

-2 thanks to AdmBorkBork - used 1,1,5 and * end result by 100 instead of using 100,100,500

takes $args as a char array, loops through sleeping as specified, Write-Host with the -NoNewline argument is used to write the chars out on the same line.

Improvements?

• use [0..99] instead of [char[]] to save 1 byte, but wont work on strings over 100 chars.
• use 100,500 and [(++$i%3)-gt1] but make it shorter somehow.
• combine it into a single string and clear between outputs, eliminating the long Write-Host

can't find any way to make the last two work, and the first one isn't valid by any particular rule.

Perl, 63 bytes

foreach(split//,pop){$|=++$i;print;select('','','',$i%3?.1:.5)}

Python 3, 88 Bytes

import time;s=''
for x in input():s+=x;time.sleep(.1+.4*(len(s)%3==0));print('\n'*25+s)

Rebol, 65 bytes

s: input t:[.1 .1 .5]forall s[prin s/1 wait last append t take t]

Ungolfed:

s: input
t: [.1 .1 .5]

forall s [
    prin s/1
    wait last append t take t
]

Bash + coreutils, 57 bytes

for((;k<${#1};k++)){ echo -n ${1:k:1};sleep .$[2&k%3|1];}

Java 7, 151 149 bytes

class M{public static void main(String[]a)throws Exception{int n=0;for(String c:a[0].split("")){System.out.print(c);Thread.sleep(n++%3>0?100:500);}}}

-2 bytes thanks to @KritixiLithos for something I always forget..

Explanation:

class M{
  public static void main(String[] a) throws Exception{ // throws Exception is required due to the Thread.sleep
    int n = 0;                                          // Initialize counter (and set to 0)
    for(String c : a[0].split("")){                     // Loop over the characters of the input
      System.out.print(c);                              // Print the character
      Thread.sleep(n++ % 3 > 0 ?                        // if (n modulo 3 != 0)
                                 100                    //   Use 100 ms
                               :                        // else (n modulo 3 == 0):
                                 500);                  //   Use 500 ms
    }
  }
}

Usage:

java -jar M.jar "Hello, PPCG! Goodbye Earth!"

Processing, 133 131 bytes

int i;void setup(){for(String c:String.join("",args).split(""))p{try{Thread.sleep(i++%3<1?500:100);}catch(Exception e){}print(c);}}

I tried doing args[0] and wrapping the argument in "" instead, but it does not work for some reason.

Anyways... this is the first time I've written a Processing program that takes arguments. Unlike Java, you don't need to declare the arguments using String[]args, but the variable args will automatically be initialised to the arguments.

Put it in a file called sketch_name.pde under a folder called sketch_name (yes, same name for folder and sketch). Call it like:

processing-java --sketch=/full/path/to/sketch/folder --run input text here