Spinning rod animation/Text

From Rosetta Code
Task
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[edit]

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

Bash[edit]

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

(Added an indent in the printf to better see the spinning rod).

C[edit]

Translation of: Go
#include <stdio.h>
#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;
}

C Shell[edit]

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

(Added an indent in the printf to better see the spinning rod).

GlovePIE[edit]

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.

debug="|"
wait 250 ms
debug="/"
wait 250 ms
debug="-"
wait 250 ms
debug="\"
wait 250 ms

Go[edit]

Works with: Ubuntu 16.04
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
}

Java[edit]

Translation of: Go
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
}
}

Julia[edit]

Translation of: Python
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
 

Kotlin[edit]

Translation of: Go
// 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
}

M2000 Interpreter[edit]

 
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︀
 

Microsoft Small Basic[edit]

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

Perl 6[edit]

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.

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

Phix[edit]

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
 

Python[edit]

from time import sleep
while True:
for rod in r'\|/-':
print(rod, end='\r')
sleep(0.25)

REXX[edit]

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
/*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. */

Ring[edit]

load "stdlib.ring"
rod = ["|", "/", "-", "\"]
for n = 1 to len(rod)
see rod[n] + nl
sleep(0.25)
system("cls")
next

Output:

|
/
-
\

Scala[edit]

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
 
}

zkl[edit]

Translation of: C Shell
foreach n,rod in ((1).MAX, T("|", "/", "-", "\\")){
print("  %s\r".fmt(rod));
Atomic.sleep(0.25);
}

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.

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