You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Move the cursor to column 3, row 6, and display the word "Hello" (without the quotes), so that the letter H is in column 3 on row 6.
Contents
- 1 AArch64 Assembly
- 2 Action!
- 3 Ada
- 4 ARM Assembly
- 5 Arturo
- 6 AutoHotkey
- 7 Axe
- 8 BaCon
- 9 BASIC
- 10 Befunge
- 11 Blast
- 12 C/C++
- 13 C#
- 14 COBOL
- 15 Common Lisp
- 16 D
- 17 Elena
- 18 Euphoria
- 19 F#
- 20 Forth
- 21 Fortran
- 22 FreeBASIC
- 23 Go
- 24 Icon and Unicon
- 25 J
- 26 Julia
- 27 Kotlin
- 28 Lasso
- 29 Liberty BASIC
- 30 Logo
- 31 Mathematica/Wolfram Language
- 32 Nim
- 33 NS-HUBASIC
- 34 OCaml
- 35 Pascal
- 36 Perl
- 37 Phix
- 38 PHP
- 39 PicoLisp
- 40 PowerShell
- 41 PureBasic
- 42 Python
- 43 Quackery
- 44 Racket
- 45 Raku
- 46 Retro
- 47 REXX
- 48 Ring
- 49 Ruby
- 50 Scala
- 51 Seed7
- 52 Tcl
- 53 UNIX Shell
- 54 Whitespace
- 55 XPL0
- 56 Wren
- 57 Z80 Assembly
- 58 zkl
AArch64 Assembly[edit]
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program cursorPos64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/*******************************************/
/* Initialized data */
/*******************************************/
.data
szMessStartPgm: .asciz "Program start \n"
szMessEndPgm: .asciz "Program normal end.\n"
szMessMovePos: .asciz "\033[6;3HHello\n"
szCarriageReturn: .asciz "\n"
szCleax1: .byte 0x1B
.byte 'c' // other console clear
.byte 0
/*******************************************/
/* UnInitialized data */
/*******************************************/
.bss
/*******************************************/
/* code section */
/*******************************************/
.text
.global main
main:
ldr x0,qAdrszMessStartPgm // display start message
bl affichageMess
ldr x0,qAdrszCleax1
bl affichageMess
ldr x0,qAdrszMessMovePos
bl affichageMess
ldr x0,qAdrszMessEndPgm // display end message
bl affichageMess
100: // standard end of the program
mov x0,0 // return code
mov x8,EXIT // request to exit program
svc 0 // perform system call
qAdrszMessStartPgm: .quad szMessStartPgm
qAdrszMessEndPgm: .quad szMessEndPgm
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrszCleax1: .quad szCleax1
qAdrszMessMovePos: .quad szMessMovePos
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
Action![edit]
PROC Main()
Position(3,6)
Print("Hello")
RETURN
- Output:
Screenshot from Atari 8-bit computer
Ada[edit]
with Ada.Text_IO;
procedure Cursor_Pos is
begin
Ada.Text_IO.Set_Line(6);
Ada.Text_IO.Set_Col(3);
Ada.Text_IO.Put("Hello");
end Cursor_Pos;
ARM Assembly[edit]
/* ARM assembly Raspberry PI */
/* program cursorPos.s */
/* Constantes */
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ WRITE, 4 @ Linux syscall
/* Initialized data */
.data
szMessStartPgm: .asciz "Program start \n"
szMessEndPgm: .asciz "Program normal end.\n"
szMessMovePos: .asciz "\033[6;3HHello\n"
szCarriageReturn: .asciz "\n"
szClear1: .byte 0x1B
.byte 'c' @ other console clear
.byte 0
/* UnInitialized data */
.bss
/* code section */
.text
.global main
main:
ldr r0,iAdrszMessStartPgm @ display start message
bl affichageMess
ldr r0,iAdrszClear1
bl affichageMess
ldr r0,iAdrszMessMovePos
bl affichageMess
ldr r0,iAdrszMessEndPgm @ display end message
bl affichageMess
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc 0 @ perform system call
iAdrszMessStartPgm: .int szMessStartPgm
iAdrszMessEndPgm: .int szMessEndPgm
iAdrszCarriageReturn: .int szCarriageReturn
iAdrszClear1: .int szClear1
iAdrszMessMovePos: .int szMessMovePos
/******************************************************************/
/* display text with size calculation */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {r0,r1,r2,r7,lr} @ save registers
mov r2,#0 @ counter length */
1: @ loop length calculation
ldrb r1,[r0,r2] @ read octet start position + index
cmp r1,#0 @ if 0 its over
addne r2,r2,#1 @ else add 1 in the length
bne 1b @ and loop
@ so here r2 contains the length of the message
mov r1,r0 @ address message in r1
mov r0,#STDOUT @ code to write to the standard output Linux
mov r7, #WRITE @ code call system "write"
svc #0 @ call system
pop {r0,r1,r2,r7,lr} @ restaur registers
bx lr @ return
Arturo[edit]
goto 3 6
print "Hello"
AutoHotkey[edit]
Remember that AHK is not built for the console, so we must call the WinAPI directly.
DllCall( "AllocConsole" ) ; create a console if not launched from one
hConsole := DllCall( "GetStdHandle", int, STDOUT := -11 )
DllCall("SetConsoleCursorPosition", UPtr, hConsole, UInt, (6 << 16) | 3)
WriteConsole(hConsole, "Hello")
MsgBox
WriteConsole(hConsole, text){
VarSetCapacity(out, 16)
If DllCall( "WriteConsole", UPtr, hConsole, Str, text, UInt, StrLen(text)
, UPtrP, out, uint, 0 )
return out
return 0
}
Axe[edit]
Since the rows and columns are zero-indexed, we must subtract 1 from both.
Output(2,5,"HELLO")
BaCon[edit]
' Cursor positioning, requires ANSI compliant terminal
GOTOXY 3,6
PRINT "Hello"
The X Y in GOTOXY
is Column Row order.
BASIC[edit]
Applesoft BASIC[edit]
10 VTAB 6: HTAB 3
20 PRINT "HELLO"
IS-BASIC[edit]
100 PRINT AT 6,3:"Hello"
Locomotive Basic[edit]
10 LOCATE 3,6
20 PRINT "Hello"
ZX Spectrum Basic[edit]
10 REM The top left corner is at position 0,0
20 REM So we subtract one from the coordinates
30 PRINT AT 5,2 "Hello"
BBC BASIC[edit]
PRINT TAB(2,5);"Hello"
Commodore BASIC[edit]
100 print chr$(19) :rem change to lowercase set
110 print chr$(14) :rem go to position 1,1
120 print:print:print:print
130 print tab(2) "Hello"
Befunge[edit]
Assuming a terminal with support for ANSI escape sequences.
0"olleHH3;6["39*>:#,[email protected]
Blast[edit]
# This will display a message at a specific position on the terminal screen
.begin
cursor 6,3
display "Hello!"
return
# This is the end of the script
C/C++[edit]
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x:#include <stdio.h>
int main()
{
printf("\033[6;3HHello\n");
return 0;
}
The C version of the minesweeper game uses curses. Minesweeper_game#C
On Windows, using console API:
#include <windows.h>
int main() {
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
COORD pos = {3, 6};
SetConsoleCursorPosition(hConsole, pos);
WriteConsole(hConsole, "Hello", 5, NULL, NULL);
return 0;
}
C#[edit]
static void Main(string[] args)
{
Console.SetCursorPosition(3, 6);
Console.Write("Hello");
}
COBOL[edit]
IDENTIFICATION DIVISION.
PROGRAM-ID. cursor-positioning.
PROCEDURE DIVISION.
DISPLAY "Hello" AT LINE 6, COL 3
GOBACK
.
Common Lisp[edit]
ncurses[edit]
To interface the ncurses C library from Lisp, the croatoan library is used.
(defun cursor-positioning ()
(with-screen (scr :input-blocking t :input-echoing nil :cursor-visible nil)
(move scr 5 2)
(princ "Hello" scr)
(refresh scr)
;; wait for keypress
(get-char scr)))
D[edit]
ANSI escape sequences allow you to move the cursor anywhere on the screen. See more at: Bash Prompt HowTo - Chapter 6. ANSI Escape Sequences: Colours and Cursor Movement
Position the Cursor: \033[<L>;<C>H or \033[<L>;<C>f puts the cursor at line L and column C.
import std.stdio;
void main()
{
writef("\033[6;3fHello");
}
Output:
0123456789 1 2 3 4 5 6 Hello 9 8 9
Elena[edit]
ELENA 4.x :
public program()
{
console.setCursorPosition(3,6).write("Hello")
}
Euphoria[edit]
position(6,3)
puts(1,"Hello")
F#[edit]
open System
Console.SetCursorPosition(3, 6)
Console.Write("Hello")
Forth[edit]
2 5 at-xy ." Hello"
Fortran[edit]
Intel Fortran on Windows[edit]
program textposition
use kernel32
implicit none
integer(HANDLE) :: hConsole
integer(BOOL) :: q
hConsole = GetStdHandle(STD_OUTPUT_HANDLE)
q = SetConsoleCursorPosition(hConsole, T_COORD(3, 6))
q = WriteConsole(hConsole, loc("Hello"), 5, NULL, NULL)
end program
FreeBASIC[edit]
Locate 6, 3 : Print "Hello"
Sleep
Go[edit]
External command[edit]
package main
import (
"bytes"
"fmt"
"os"
"os/exec"
)
func main() {
cmd := exec.Command("tput", "-S")
cmd.Stdin = bytes.NewBufferString("clear\ncup 5 2")
cmd.Stdout = os.Stdout
cmd.Run()
fmt.Println("Hello")
}
ANSI escape codes[edit]
package main
import "fmt"
func main() {
fmt.Println("\033[2J\033[6;3HHello")
}
Ncurses[edit]
package main
import (
"log"
gc "code.google.com/p/goncurses"
)
func main() {
s, err := gc.Init()
if err != nil {
log.Fatal("init:", err)
}
defer gc.End()
s.Move(5, 2)
s.Println("Hello")
s.GetChar()
}
Icon and Unicon[edit]
If the OS has older termcap files, CUP is included with link ansi
procedure main()
writes(CUP(6,3), "Hello")
end
procedure CUP(i,j)
writes("\^[[",i,";",j,"H")
return
end
J[edit]
Using terminal positioning verbs of Terminal_control/Coloured_text#J
'Hello',~move 6 3
Julia[edit]
const ESC = "\u001B"
gotoANSI(x, y) = print("$ESC[$(y);$(x)H")
gotoANSI(3, 6)
println("Hello")
Kotlin[edit]
// version 1.1.2
fun main(args: Array<String>) {
print("\u001Bc") // clear screen first
println("\u001B[6;3HHello")
}
Lasso[edit]
local(esc = decode_base64('Gw=='))
stdout( #esc + '[6;3HHello')
Liberty BASIC[edit]
locate 3, 6
print "Hello"
Logo[edit]
setcursor [2 5]
type "Hello
You can also draw positioned text on the turtle graphics window.
setpos [20 50]
setxy 20 30 ; alternate way to set position
label "Hello
Mathematica/Wolfram Language[edit]
Run["tput cup 6 3"]
Print["Hello"]
Nim[edit]
import terminal
setCursorPos(3, 6)
echo "Hello"
NS-HUBASIC[edit]
10 LOCATE 3,6
20 PRINT "HELLO"
OCaml[edit]
Using the library ANSITerminal:
#load "unix.cma"
#directory "+ANSITerminal"
#load "ANSITerminal.cma"
module Trm = ANSITerminal
let () =
Trm.erase Trm.Screen;
Trm.set_cursor 3 6;
Trm.print_string [] "Hello";
;;
Pascal[edit]
program cursor_pos;
uses crt;
begin
gotoxy(6,3);
write('Hello');
end.
Perl[edit]
Using the Term::Cap module:
use Term::Cap;
my $t = Term::Cap->Tgetent;
print $t->Tgoto("cm", 2, 5); # 0-based
print "Hello";
Phix[edit]
without js -- position position(6,3) puts(1,"Hello")
PHP[edit]
echo "\033[".$x.",".$y."H"; // Position line $y and column $x.
echo "\033[".$n."A"; // Up $n lines.
echo "\033[".$n."B"; // Down $n lines.
echo "\033[".$n."C"; // Forward $n columns.
echo "\033[".$n."D"; // Backward $n columns.
echo "\033[2J"; // Clear the screen, move to (0,0).
PicoLisp[edit]
(call 'tput "cup" 6 3)
(prin "Hello")
PowerShell[edit]
The following will only work in the PowerShell console host. Most notably it will not work in the PowerShell ISE.
$Host.UI.RawUI.CursorPosition = New-Object System.Management.Automation.Host.Coordinates 2,5
$Host.UI.Write('Hello')
Alternatively, in any PowerShell host that uses the Windows console, one can directly use the .NET Console
class:
[Console]::SetCursorPosition(2,5)
[Console]::Write('Hello')
PureBasic[edit]
EnableGraphicalConsole(#True)
ConsoleLocate(3,6)
Print("Hello")
Python[edit]
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x:print("\033[6;3HHello")
On Windows it needs to import and init the colorama module first.
ANSI sequences are not recognized in Windows console, here is a program using Windows API:
from ctypes import *
STD_OUTPUT_HANDLE = -11
class COORD(Structure):
pass
COORD._fields_ = [("X", c_short), ("Y", c_short)]
def print_at(r, c, s):
h = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
windll.kernel32.SetConsoleCursorPosition(h, COORD(c, r))
c = s.encode("windows-1252")
windll.kernel32.WriteConsoleA(h, c_char_p(c), len(c), None, None)
print_at(6, 3, "Hello")
Quackery[edit]
[ number$ swap number$
$ 'print("\033[' rot join
char ; join
swap join
$ 'H", end="")' join
python ] is cursor-at ( x y --> )
3 6 cursor-at say "Hello"
Racket[edit]
#lang racket
(require (planet neil/charterm:3:0))
(with-charterm
(charterm-clear-screen)
(charterm-cursor 3 6)
(displayln "Hello World"))
Raku[edit]
(formerly Perl 6) Assuming an ANSI terminal:
print "\e[6;3H";
print 'Hello';
Retro[edit]
with console'
: hello 3 6 at-xy "Hello" puts ;
REXX[edit]
The REXX language doesn't have any cursor or screen management tools, but some REXX interpreters have
added the functionality via different methods (such as functions and/or subroutines).
/*REXX program demonstrates moving the cursor position and writing of text to same place*/
call cursor 3,6 /*move the cursor to row 3, column 6. */
say 'Hello' /*write the text at that location. */
call scrwrite 30,50,'Hello.' /*another method, different location. */
call scrwrite 40,60,'Hello.',,,14 /*another method ... in yellow. */
exit 0 /*stick a fork in it, we're all done. */
Ring[edit]
# Project : Terminal control/Cursor positioning
for n = 1 to 5
see nl
next
see " Hello"
Output:
Hello
Ruby[edit]
require 'curses'
Curses.init_screen
begin
Curses.setpos(6, 3) # column 6, row 3
Curses.addstr("Hello")
Curses.getch # Wait until user presses some key.
ensure
Curses.close_screen
end
Scala[edit]
object Main extends App {
print("\u001Bc") // clear screen first
println("\u001B[6;3HHello")
}
Seed7[edit]
The function setPos is portable and positions the cursor on the console window. SetPos is based on terminfo respectively the Windows console API.
$ include "seed7_05.s7i";
include "console.s7i";
const proc: main is func
local
var text: console is STD_NULL;
begin
console := open(CONSOLE);
setPos(console, 6, 3);
write(console, "Hello");
# Terminal windows often restore the previous
# content, when a program is terminated. Therefore
# the program waits until Return/Enter is pressed.
readln;
end func;
Tcl[edit]
exec tput cup 5 2 >/dev/tty
puts "Hello"
UNIX Shell[edit]
# The tput utility numbers from zero, so we have subtracted 1 from row and column
# number to obtain correct positioning.
tput cup 5 2
Whitespace[edit]
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x (see below):
This solution was generated from the following pseudo-Assembly.
push "Hello" ;The characters are pushed onto the stack in reverse order
push "[6;3H"
push 27 ;ESC
push 11 ;Number of characters to print
call 0 ;Calls print-string function
exit
0:
dup jumpz 1 ;Return if counter is zero
exch prtc ;Swap counter with the next character and print it
push 1 sub ;Subtract one from counter
jump 0 ;Loop back to print next character
1:
pop ret ;Pop counter and return
XPL0[edit]
include c:\cxpl\codes; \intrinsic 'code' declarations
[Cursor(2, 5); \3rd column, 6th row
Text(0, "Hello"); \upper-left corner is coordinate 0, 0
]
Wren[edit]
System.write("\e[2J") // clear the terminal
System.print("\e[6;3HHello") // move to (6, 3) and print 'Hello'
Z80 Assembly[edit]
Uses Amstrad CPC, but other machines with similar terminal functions can do the job. (The BIOS calls will be different however.)
ld hl,&0603 ;6 = ROW, 3 = COLUMN
call &BB75 ;set text cursor according to HL
ld hl,Message
call PrintString
ret ;return to basic
Message:
byte "Hello",0
PrintString:
ld a,(hl) ;read a byte from the string
or a ;check equality to zero
ret z ;if equal to zero, we're done
call &BB5A ;print accumulator as an ascii char to screen
inc hl ;next char
jr PrintString
zkl[edit]
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x:
print("\e[6;3H" "Hello");
- Programming Tasks
- Terminal control
- AArch64 Assembly
- Action!
- Ada
- ARM Assembly
- Arturo
- AutoHotkey
- Axe
- BaCon
- BASIC
- Applesoft BASIC
- IS-BASIC
- Locomotive Basic
- ZX Spectrum Basic
- BBC BASIC
- Commodore BASIC
- Befunge
- Blast
- C
- C++
- C sharp
- COBOL
- Common Lisp
- Ncurses
- D
- Elena
- Euphoria
- F Sharp
- Forth
- Fortran
- FreeBASIC
- Go
- Curses
- Icon
- Unicon
- J
- Julia
- Kotlin
- Lasso
- Liberty BASIC
- Logo
- Mathematica
- Wolfram Language
- Nim
- NS-HUBASIC
- OCaml
- Pascal
- Perl
- Phix
- PHP
- PicoLisp
- PowerShell
- PureBasic
- Python
- Quackery
- Racket
- Raku
- Retro
- REXX
- Ring
- Ruby
- Scala
- Seed7
- Tcl
- UNIX Shell
- Whitespace
- XPL0
- Wren
- Z80 Assembly
- Zkl
- ACL2/Omit
- GUISS/Omit
- Maxima/Omit
- PARI/GP/Omit
- Scratch/Omit