Spinning rod animation/Text

Spinning rod animation/Text
You are encouraged to solve this task according to the task description, using any language you may know.

Task

An animation with the following frames in the following order must animate with a delay of 0.25 seconds between each frame, with the previous frame being cleared before the next frame appears:

• |
• /
• -
• \

A version that loops and/or a version that doesn't loop can be made.

AWK

<lang AWK>

1. syntax: GAWK -f SPINNING_ROD_ANIMATION_TEXT.AWK

@load "time" BEGIN {

   while (1) {
     printf(" %s\r",substr("|/-\\",x++%4+1,1))
     sleep(.25)
   }
   exit(0)

} </lang>

Bash

<lang bash>while : ; do

 for rod in \| / - \\ ; do printf '  %s\r' $rod; sleep 0.25; done

done</lang> (Added an indent in the printf to better see the spinning rod).

C

Translation of: Go

<lang c>#include <stdio.h>

1. include <time.h>

int main() {

   int i, j, ms = 250;    
   const char *a = "|/-\\";
   time_t start, now;
   struct timespec delay;
   delay.tv_sec = 0;
   delay.tv_nsec = ms * 1000000L;
   printf("\033[?25l");  // hide the cursor
   time(&start);
   while(1) {
       for (i = 0; i < 4; i++) {
           printf("\033[2J");          // clear terminal
           printf("\033[0;0H");        // place cursor at top left corner
           for (j = 0; j < 80; j++) {  // 80 character terminal width, say
               printf("%c", a[i]);
           }
           fflush(stdout);
           nanosleep(&delay, NULL);
       }
       // stop after 20 seconds, say
       time(&now);
       if (difftime(now, start) >= 20) break;
   }
   printf("\033[?25h"); // restore the cursor
   return 0;

}</lang>

C Shell

<lang csh>while 1

 foreach rod ('|' '/' '-' '\')
   printf '  %s\r' $rod; sleep 0.25
 end

end</lang> (Added an indent in the printf to better see the spinning rod).

GlovePIE

Because GlovePIE is a looping programming language, which means the script is ran over and over again in a looping fashion, this code loops again and again until it's stopped. <lang glovepie>debug="|" wait 250 ms debug="/" wait 250 ms debug="-" wait 250 ms debug="\" wait 250 ms</lang>

Go

Works with: Ubuntu 16.04

<lang go>package main

import (

   "fmt"
   "time"

)

func main() {

   a := `|/-\`
   fmt.Printf("\033[?25l")  // hide the cursor
   start := time.Now()
   for {
       for i := 0; i < 4; i++ {
           fmt.Print("\033[2J")       // clear terminal
           fmt.Printf("\033[0;0H")    // place cursor at top left corner
           for j := 0; j < 80; j++ {  // 80 character terminal width, say
               fmt.Printf("%c", a[i])
           }
           time.Sleep(250 * time.Millisecond)
       }
       if time.Since(start).Seconds() >= 20.0 { // stop after 20 seconds, say
           break
       }
   }
   fmt.Print("\033[?25h") // restore the cursor

}</lang>

Java

Translation of: Go

<lang java>public class SpinningRod {

   public static void main(String[] args) throws InterruptedException {
       String a = "|/-\\";
       System.out.print("\033[2J");   // hide the cursor
       long start = System.currentTimeMillis();
       while (true) {
           for (int i = 0; i < 4; i++) {
               System.out.print("\033[2J");     // clear terminal
               System.out.print("\033[0;0H");   // place cursor at top left corner
               for (int j = 0; j < 80; j++) {   // 80 character terminal width, say
                   System.out.print(a.charAt(i));
               }
               Thread.sleep(250);
           }
           long now = System.currentTimeMillis();
           // stop after 20 seconds, say
           if (now - start >= 20000) break;
       }
       System.out.print("\033[?25h"); // restore the cursor
   }

}</lang>

Julia

Translation of: Python

<lang julia>while true

 for rod in "\|/-" # this needs to be a string, a char literal cannot be iterated over
   print(rod,'\r')
   sleep(0.25)
 end

end </lang>

Kotlin

Translation of: Go

<lang scala>// Version 1.2.50

const val ESC = "\u001b"

fun main(args: Array<String>) {

   val a = "|/-\\"
   print("$ESC[?25l") // hide the cursor
   val start = System.currentTimeMillis()
   while (true) {
       for (i in 0..3) {
           print("$ESC[2J")       // clear terminal
           print("$ESC[0;0H")     // place cursor at top left corner
           for (j in 0..79) {     // 80 character terminal width, say
               print(a[i])
           }
           Thread.sleep(250)
       }
       val now = System.currentTimeMillis()
       // stop after 20 seconds, say
       if (now - start >= 20000) break
   }
   print("$ESC[?25h") // restore the cursor

}</lang>

M2000 Interpreter

<lang M2000 Interpreter> Module Checkit {

     n$=lambda$ n=1, a$="|/-\" -> {
           =mid$(a$, n, 1)
           n++
           if n>4 then n=1
     }
     \\ 1000 is 1 second
     Every 250 {
     \\ Print Over: erase line before print. No new line append.
     Print Over  n$()
     }

} CheckIt

</lang>

<lang M2000 Interpreter> Module Checkit {

     n=1
     a$="|/-\"
     Every 250 {
           Print Over mid$(a$, n, 1)
           n++
           if n>4 then n=1      
     }

} CheckIt

</lang>

Microsoft Small Basic

<lang microsoftsmallbasic>a[1]="|" a[2]="/" a[3]="-" a[4]="\" b=0 While b=0

 For c=1 To 4
   TextWindow.Clear()
   TextWindow.WriteLine(a[c])
   Program.Delay(250)
 EndFor

EndWhile</lang>

Perl

The statement $| =1 is required in order to disable output buffering. <lang perl>$|= 1;

while () {

   for (qw[ | / - \ ]) {
       select undef, undef, undef, 0.25;
       printf "\r ($_)";
   }

}</lang>

Perl 6

Works with: Rakudo version 2018.05

Traditionally these are know as throbbers or progress indicators.

This implementation will accept an array of elements to use as its throbber frames, or as a scrolling marquee and optionally a delay before it returns the next element.

<lang perl6>class throbber {

   has @.frames;
   has $.delay is rw = 0;
   has $!index = 0;
   has Bool $.marquee = False;
   method next {
       $!index = ($!index + 1) % +@.frames;
       sleep $.delay if $.delay;
       if $!marquee {
           ("\b" x @.frames) ~ @.frames.rotate($!index).join;
       }
       else {
           "\b" ~ @.frames[$!index];
       }
   }

}

my $rod = throbber.new( :frames(< | / - \ >), :delay(.25) ); print "\e[?25lLong running process... "; print $rod.next for ^20;

my $clock = throbber.new( :frames("🕐" .. "🕛") ); print "\b \nSomething else with a delay... "; until my $done {

   # do something in a loop;
   sleep 1/12;
   print $clock.next;
   $done = True if $++ >= 60;

}

my $scroll = throbber.new( :frames('PLEASE STAND BY... '.comb), :delay(.1), :marquee ); print "\b \nEXPERIENCING TECHNICAL DIFFICULTIES: { $scroll.frames.join }"; print $scroll.next for ^95;

END { print "\e[?25h\n" } # clean up on exit</lang>

Phix

<lang Phix>puts(1,"please_wait... ") cursor(NO_CURSOR) for i=1 to 10 do -- (approx 10 seconds)

   for j=1 to 4 do
       printf(1," \b%c\b",`|/-\`[j])
       sleep(0.25)
   end for

end for puts(1," \ndone") -- clear rod, "done" on next line </lang>

Python

<lang python>from time import sleep while True:

   for rod in r'\|/-':
       print(rod, end='\r')
       sleep(0.25)</lang>

REXX

This REXX program would work for all REXXes if there was a common way to sleep (suspend) execution for fractional seconds.

This REXX version will work for:

• Personnal REXX
• PC REXX

<lang rexx>/*REXX program displays a "spinning rod" (AKA: trobbers or progress indicators). */ if 4=='f4'x then bs= "16"x /*EBCDIC? Then use this backspace chr.*/

            else bs= "08"x                      /* ASCII?    "   "    "      "      "  */

signal on halt /*jump to HALT when user halts pgm.*/ $= '│/─\' /*the throbbing characters for display.*/

                 do j=1                         /*perform  until  halted by the user.  */
                 call charout ,  bs  ||  substr($, 1 + j//length($), 1)
                 call delay .25                 /*delays a quarter of a second.        */
                 end   /*j*/

halt: say bs ' ' /*stick a fork in it, we're all done. */</lang>

Ring

<lang ring>load "stdlib.ring" rod = ["|", "/", "-", "\"] for n = 1 to len(rod)

    see rod[n] + nl
    sleep(0.25)
    system("cls")

next</lang> Output:

|
/
-
\

Scala

<lang Scala>object SpinningRod extends App {

 val start = System.currentTimeMillis

 def a = "|/-\\"

 print("\033[2J") // hide the cursor

 while (System.currentTimeMillis - start < 20000) {
   for (i <- 0 until 4) {
     print("\033[2J\033[0;0H") // clear terminal, place cursor at top left corner
     for (j <- 0 until 80) print(a(i)) // 80 character terminal width, say
     Thread.sleep(250)
   }
 }
 print("\033[?25h") // restore the cursor

}</lang>

zkl

Translation of: C Shell

<lang zkl>foreach n,rod in ((1).MAX, T("|", "/", "-", "\\")){

  print("  %s\r".fmt(rod));
  Atomic.sleep(0.25);

}</lang> A loop foreach a,b in (c,d) translates to foreach a in (c) foreach b in (d). n.MAX is a 64 bit int (9223372036854775807).

A more useful example would be a worker thread showing a "I'm working" display (in another thread) and turning it off when that work is done. <lang zkl>fcn spin{ // this will be a thread that displays spinner

  try{
     foreach n,rod in ((1).MAX, "\\|/-"){
        print("  ",rod,"\r");

Atomic.sleep(0.25);

     }
  }catch{}	// don't complain about uncaught exception that stops thread

}</lang> <lang zkl>// main body of code spinner:=spin.launch(); // start spinner thread, returns reference to thread Atomic.sleep(10); // do stuff vm.kick(spinner.value); // stop thread by throwing exception at it</lang>