Spinning rod animation/Text: Difference between revisions
added Julia |
|||
Line 135: | Line 135: | ||
=={{header|Julia}}== |
=={{header|Julia}}== |
||
{{trans|Python}} |
{{trans|Python}} |
||
<lang julia> |
<lang julia>while true |
||
while true |
|||
for rod in "\|/-" # this needs to be a string, a char literal cannot be iterated over |
for rod in "\|/-" # this needs to be a string, a char literal cannot be iterated over |
||
print(rod,'\r') |
print(rod,'\r') |
Revision as of 11:15, 16 July 2018
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
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>
- 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
<lang c>#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;
}</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
<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
<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
<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
<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>
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 6
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>
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
<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>