Terminal control/Display an extended character

Terminal control/Display an extended character
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>

BaCon

<lang freebasic>' Display extended character, pound sterling LET c$ = UTF8$(0xA3) PRINT c$</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>

IS-BASIC

<lang IS-BASIC>PRINT "£"</lang>

or

<lang IS-BASIC>PRINT CHR$(35)</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

Works with: BBC BASIC for Windows

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

Translation of: AWK

<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

Works with: OpenCOBOL

<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

Works with: GNU Forth version 0.7.0

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>

Julia

Translation of: C

<lang julia>println("£") println("\302\243"); # works if your terminal is utf-8 </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>

Objeck

<lang objeck>class Program {

 function : Main(args : String[]) ~ Nil {
   "£"->PrintLine();
 }

}</lang>

Pascal

<lang Pascal>program pound; uses crt; begin

 write(chr( 163 ));

end. </lang>

Perl

<lang perl>use feature 'say';

1. OK as is

say '￡';

1. 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>

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>

1. lang racket

(display "£") </lang>

Raku

(formerly 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>

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>

1. 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

Library: 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.

Wren

<lang ecmascript>System.print("£")</lang>

Xidel

http://videlibri.sourceforge.net/xidel.html <lang bash>xidel -s -e 'parse-html("£ or &#xa3")' £ or £</lang> <lang bash>echo '"\u00a3"' | xidel -s - -e 'json($raw)' £

xidel -s -e 'json("""\\u00a3""")' --xquery 'json(""\\u00a3"")' £ £</lang>

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>