Terminal control/Display an extended character: Difference between revisions
(→{{header|Dc}}: ++spaces) |
(→{{header|REXX}}: re-wrote the REXX program so it can be executed on an EBCDIC or ASCII machine.) |
||
Line 356: | Line 356: | ||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
<lang rexx>/*REXX program |
<lang rexx>/*REXX program demonstrates displaying an extended character (glyph) to the terminal. */ |
||
/* [↓] this will display the £ glphy (if term supports it).*/ |
|||
say |
say '£' /*assuming the pound sign glyph is displayable on the term. */ |
||
/* [↑] this can execute on an EBCDIC or ASCII machine. */ |
|||
/*stick a fork in it, we're all done. */</lang> |
|||
{{out|output|text=:}} |
|||
<pre> |
|||
£ |
|||
</pre> |
|||
=={{header|Ring}}== |
=={{header|Ring}}== |
Revision as of 22:27, 3 December 2018
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Display an extended (non ASCII) character onto the terminal.
Specifically, display a £ (GBP currency sign).
ACL2
<lang Lisp>(cw "£")</lang>
Ada
<lang ada>with Ada.Text_IO; use Ada.Text_IO; with Ada.Characters.Latin_1;
procedure Pound is begin
Put(Ada.Characters.Latin_1.Pound_Sign);
end Pound;</lang>
Ada allows Unicode characters in the source, and provides output functions on "wide characters".
<lang ada>with Ada.Wide_Text_IO; use Ada.Wide_Text_IO;
procedure Unicode is begin
Put("札幌");
end Unicode;</lang>
AWK
You can print a literal "£".
<lang awk>BEGIN { print "£" }</lang>
You can print a "£" using the escape sequences that match the encoding of your terminal.
cp437 | "\234" |
---|---|
iso-8859-1 | "\243" |
euc-jp | "\241\362" |
utf-8 | "\302\243" |
gb18030 | "\201\60\204\65" |
<lang awk>BEGIN { print "\302\243" } # if your terminal is utf-8</lang>
BASIC
Applesoft BASIC
Poke the glyph onto the hi-res screen. <lang basic>10 DATA 56,68,4,14,4,4,122,0 20 HGR 30 FOR I = 8192 TO 16383 STEP 1024 40 READ B: POKE I,B: NEXT</lang>
ZX Spectrum Basic
The ZX Spectrum uses a modified ascii character set that has a uk pound sign at character number 96:
<lang basic>10 PRINT CHR$(96);</lang>
BBC BASIC
You can print a literal £ if it is available in the default ANSI code page: <lang bbcbasic> PRINT "£"</lang> But to be on the safe side you can do this: <lang bbcbasic> VDU 23,22,640;512;8,16,16,128+8 : REM Enable UTF-8 mode
PRINT CHR$(&C2) CHR$(&A3) : REM UTF-8 encoding for £</lang>
bc
You can print a literal "£".
<lang bc>"£ " quit</lang>
beeswax
<lang beeswax>_4~9P.P.M}</lang>
Befunge
There's no portable way to print an extended character in Befunge, since character output will typically use the default code page of the operating system or environment. On Windows this will often be Windows-1252 or ISO-8859-1 for GUI applications and Code page 437 for console applications (but that also likely depends on the OS localisation).
Example output of a pound character in Code page 437: <lang befunge>"| "+,@</lang>
Example output of a pound character in ISO-8859-1: <lang befunge>"%~"+,@</lang>
Bracmat
<lang bracmat>put$£</lang>
C
<lang c>#include <stdio.h>
int main() { puts("£"); puts("\302\243"); /* if your terminal is utf-8 */ return 0; }</lang>
C#
<lang csharp>class Program {
static void Main() { System.Console.WriteLine("£"); }
}</lang> Output:
£
C++
<lang cpp>#include <iostream>
int main() {
std::cout << static_cast<char>(163); // pound sign return 0;
}</lang>
Clojure
<lang clojure>(println "£")</lang>
COBOL
<lang cobol> IDENTIFICATION DIVISION.
PROGRAM-ID. Display-Pound.
PROCEDURE DIVISION. DISPLAY "£"
GOBACK .</lang>
Common Lisp
<lang lisp> (format t "札幌~%") (format t "~C~%" (code-char #x00A3)) </lang>
D
Assuming unicode support on the terminal <lang d>import std.stdio;
void main() {
writeln('\u00A3');
}</lang>
£
Dc
Assuming unicode support on the terminal <lang dc>49827 P</lang>
EchoLisp
<lang scheme>
- simplest
(display "£")
- unicode character
(display "\u00a3")
- HTML special character
(display "£")
- CSS enhancement
(display "£" "color:blue;font-size:2em") </lang>
- Output:
£
Erlang
In Erlang a string is a list of integers. So the list of 196 is £.
- Output:
8> Pound = [163]. 9> io:fwrite( "~s~n", [Pound] ). £
Forth
The emerging ANS Forth 20xx standard includes an XCHAR wordset which allows manipulation of non-ASCII character sets such as Unicode.
<lang forth>163 xemit \ , or s" £" type</lang>
Go
<lang go>package main
import "fmt"
func main() {
fmt.Println("£")
}</lang>
Haskell
<lang Haskell> module Main where main = do
putStrLn "£" putStrLn "札幌"
</lang>
Icon and Unicon
Write a given character number, say '163', using char
to convert the integer into a string.
<lang Icon> procedure main ()
write ("£ " || char (163)) # £
end </lang>
J
<lang J> '£' £
'札幌'
札幌</lang>
Java
<lang Java>import java.io.PrintStream; import java.io.UnsupportedEncodingException;
public class Main {
public static void main(String[] args) throws UnsupportedEncodingException { PrintStream writer = new PrintStream(System.out, true, "UTF-8"); writer.println("£"); writer.println("札幌"); }
}</lang>
Kotlin
<lang scala>// version 1.1.2
fun main(args:Array<String>) = println("£")</lang>
Lasso
<lang Lasso>stdout(' £ ')</lang> Result:
£
Locomotive Basic
<lang locobasic>10 PRINT CHR$(163)</lang>
Lua
Lua requires an extension module for UTF-8 support. However, the '£' symbol specified for this task is part of extended ASCII (codes 128 - 255) which can be accessed in the same way as normal ASCII. <lang Lua>print(string.char(156))</lang>
Mathematica
<lang Mathematica>FromCharacterCode[{163}]</lang>
NetRexx
<lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols binary
runSample(arg) return
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method runSample(arg) private static
GBP = '\u00a3' -- unicode code point say GBP GBP = '£' -- if the editor's up to it say GBP GBP = 16x00a3 -- yet another way say (Rexx GBP).d2c return
</lang>
- Output:
£ £ £
Nim
<lang nim>echo "£" echo "札幌"
import unicode echo Rune(0xa3)</lang>
Pascal
<lang Pascal>program pound; uses crt; begin
write(chr( 163 ));
end. </lang>
Perl
<lang perl>use feature 'say';
- OK as is
say '£';
- these need 'binmode needed to surpress warning about 'wide' char
binmode STDOUT, ":utf8"; say "\N{FULLWIDTH POUND SIGN}"; say "\x{FFE1}"; say chr 0xffe1;</lang>
Perl 6
To demonstrate we're not limited to Latin-1, we'll print the fullwidth variant. <lang perl6>say '£'; say "\x[FFE1]"; say "\c[FULLWIDTH POUND SIGN]"; 0xffe1.chr.say;</lang>
Phix
On Windows (Linux should be fine), you may need to set the terminal to a truetype font (eg Lucida Console) and the code page to CP_UTF8 (chcp 65001).
See demo\HelloUTF8.exw for a (not very pretty) way to do that programmaticaly.
The following assumes you have done that manually, and saved the source code file in UTF-8 format.
<lang Phix>puts(1,"£")</lang>
Output:
£
PicoLisp
<lang PicoLisp>(prinl (char 26413) (char 24140)) # Sapporo </lang> Output:
札幌
PL/I
<lang PL/I> declare pound character (1) static initial ('9c'x);
put skip list (pound);</lang>
PureBasic
<lang PureBasic>Print(Chr(163))</lang>
£
Python
<lang Python>print u'\u00a3'</lang>
£
Racket
<lang racket>
- lang racket
(display "£") </lang>
REXX
<lang rexx>/*REXX program demonstrates displaying an extended character (glyph) to the terminal. */
/* [↓] this will display the £ glphy (if term supports it).*/
say '£' /*assuming the pound sign glyph is displayable on the term. */
/* [↑] this can execute on an EBCDIC or ASCII machine. */ /*stick a fork in it, we're all done. */</lang>
- output :
£
Ring
<lang ring>
- Project : Terminal control/Display an extended character
see "£" </lang> Output:
£
Ruby
<lang ruby>#encoding: UTF-8 #superfluous in Ruby > 1.9.3 puts "£"</lang>
Scala
<lang Scala>object ExtendedCharacter extends App {
println("£") println("札幌")
}</lang>
Seed7
A write to a console accepts Unicode characters.<lang seed7>$ include "seed7_05.s7i";
include "console.s7i";
const proc: main is func
local var text: console is STD_NULL; begin console := open(CONSOLE); write(console, "£"); # Terminal windows often restore the previous # content, when a program is terminated. Therefore # the program waits until Return/Enter is pressed. readln; end func;</lang>
Sidef
<lang ruby>say '£'; say "\x{FFE1}"; say "\N{FULLWIDTH POUND SIGN}"; say 0xffe1.chr;</lang>
Tcl
Provided the system encoding has a “£” symbol in it, this works: <lang tcl>puts \u00a3</lang> Tcl can output all unicode characters in the BMP, but only if the consumer of the output (terminal, etc.) is able to understand those characters in its current encoding will the output actually make sense. Strictly, this is not a limitation of Tcl but of the environment in which it is placed.
XPL0
<lang XPL0>code ChOut=8; ChOut(0, $9C) \code for IBM PC's extended (OEM) character set </lang>
zkl
If you output device support UTF-8 then: <lang zkl>"\u00a3 \Ua3;".println() //-->£ £</lang>
- Programming Tasks
- Text processing
- ACL2
- Ada
- AWK
- BASIC
- Applesoft BASIC
- ZX Spectrum Basic
- BBC BASIC
- Bc
- Beeswax
- Befunge
- Bracmat
- C
- C sharp
- C++
- Clojure
- COBOL
- Common Lisp
- D
- Dc
- EchoLisp
- Erlang
- Forth
- Go
- Haskell
- Icon
- Unicon
- J
- Java
- Kotlin
- Lasso
- Locomotive Basic
- Lua
- Mathematica
- NetRexx
- Nim
- Pascal
- Perl
- Perl 6
- Phix
- PicoLisp
- PL/I
- PureBasic
- Python
- Racket
- REXX
- Ring
- Ruby
- Scala
- Seed7
- Sidef
- Tcl
- XPL0
- Zkl
- Terminal control
- Axe/Omit