Idiomatically determine all the lowercase and uppercase letters: Difference between revisions

m
→‎{{header|Wren}}: Changed to Wren S/H
(→‎{{header|Haskell}}: Used Data.List.Split chunksOf (rather than defining one by hand) for a little more focus.)
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(43 intermediate revisions by 30 users not shown)
Line 23:
* [[Idiomatically_determine_all_the_characters_that_can_be_used_for_symbols|Idiomatically determine all the characters that can be used for symbols]].
<br><br>
 
=={{header|11l}}==
{{trans|Kotlin}}
 
<syntaxhighlight lang="11l">print(‘Lower case: ’, end' ‘’)
L(ch) ‘a’..‘z’
print(ch, end' ‘’)
print()
print(‘Upper case: ’, end' ‘’)
L(ch) ‘A’..‘Z’
print(ch, end' ‘’)
print()</syntaxhighlight>
 
{{out}}
<pre>
Lower case: abcdefghijklmnopqrstuvwxyz
Upper case: ABCDEFGHIJKLMNOPQRSTUVWXYZ
</pre>
 
=={{header|8080 Assembly}}==
Code assumes the CP/M operating system and the ASCII character set
<syntaxhighlight>
;------------------------------------------------------
; useful equates
;------------------------------------------------------
bdos equ 5h ; BDOS entry
wboot equ 0 ; BDOS warm boot function
conout equ 2 ; BDOS write character to console function
prtstr equ 9 ; BDOS write string to console function
cr equ 13 ; ASCII carriage return
lf equ 10 ; ASCII line feed
;------------------------------------------------------
; main code begins here
;------------------------------------------------------
org 100h ; entry point under CP/M
lxi sp,stack ; set a local stack
;
; show upper case alphabet
;
lxi d,ucmsg
call message
mvi a,'A'
ucloop: push a
call putchr
pop a
inr a
cpi 'Z'+1
jc ucloop
call crlf
;
; show lower case alphabet
;
lxi d,lcmsg
call message
mvi a,'a'
lcloop: push a
call putchr
pop a
inr a
cpi 'z'+1
jc lcloop
call crlf
;
; we're finished; exit to operating system
;
jmp wboot
;-------------------------------------------------------
; console output of $-terminated string pointed to by DE
;-------------------------------------------------------
message:
push b
push d
push h
mvi c,prtstr
call bdos
pop h
pop d
pop b
ret
;-------------------------------------------------------
; output CRLF to console
;-------------------------------------------------------
crlf: push b
push d
push h
mvi e,cr
mvi c,conout
call bdos
mvi e,lf
mvi c,conout
call bdos
pop h
pop d
pop b
ret
;-------------------------------------------------------
; console output of char in A register
;-------------------------------------------------------
putchr: push b
push d
push h
mov e,a
mvi c,conout
call bdos
pop h
pop d
pop b
ret
;------------------------------------------------------
; messages and data area
;------------------------------------------------------
ucmsg: db 'Upper case: $'
lcmsg: db 'Lower case: $'
stack equ $+128 ; 64-level stack is sufficient
;
end
</syntaxhighlight>
{{out}}
<pre>
Upper case: ABCDEFGHIJKLMNOPQRSTUVWXYZ
Lower case: abcdefghijklmnopqrstuvwxyz
</pre>
 
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="action!">INCLUDE "D2:CHARTEST.ACT" ;from the Action! Tool Kit
 
PROC Main()
CHAR ARRAY lower(128),upper(128)
CHAR c
BYTE lowerLen,upperLen
 
Put(125) PutE() ;clear screen
 
lowerLen=0
upperLen=0
FOR c=0 TO 127
DO
IF IsLower(c) THEN
lowerLen==+1
lower(lowerLen)=c
ELSEIF IsUpper(c) THEN
upperLen==+1
upper(upperLen)=c
FI
OD
lower(0)=lowerLen
upper(0)=upperLen
 
PrintF("lowercase letters:%E %S%E%E",lower)
PrintF("uppercase letters:%E %S",upper)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Idiomatically_determine_all_the_lowercase_and_uppercase_letters.png Screenshot from Atari 8-bit computer]
<pre>
lowercase letters:
abcdefghijklmnopqrstuvwxyz
 
uppercase letters:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
</pre>
 
=={{header|Ada}}==
Creates two subtypes of the standard type Character. Subtype Lower is defined to be all the characters from 'a' to 'z'. Subtype Upper is defined to be all characters from 'A' to 'Z'. This program works with any version of Ada.
<syntaxhighlight lang="ada">
with Ada.Text_IO; use Ada.Text_IO;
 
procedure Main is
subtype Lower is Character range 'a' .. 'z';
subtype Upper is Character range 'A' .. 'Z';
begin
Put ("Lower: ");
for c in Lower'range loop
Put (c);
end loop;
New_Line;
Put ("Upper: ");
for c in Upper'range loop
Put (c);
end loop;
New_Line;
end Main;
</syntaxhighlight>
{{Output}}
<pre>
Lower: abcdefghijklmnopqrstuvwxyz
Upper: ABCDEFGHIJKLMNOPQRSTUVWXYZ
</pre>
 
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}
Uses the non-standard is lower and is upper procedures provided by Algol 68G.
<langsyntaxhighlight lang="algol68">STRING lc := "";
STRING uc := "";
FOR c FROM 0 TO max abs char DO
Line 35 ⟶ 223:
OD;
print( ( "lower: """ + lc + """", newline ) );
print( ( "upper: """ + uc + """", newline ) )</langsyntaxhighlight>
{{out}}
<pre>
Line 41 ⟶ 229:
upper: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">print ["lowercase letters:" `a`..`z`]
print ["uppercase letters:" `A`..`Z`]</syntaxhighlight>
 
{{out}}
 
<pre>lowercase letters: [a b c d e f g h i j k l m n o p q r s t u v w x y z]
uppercase letters: [A B C D E F G H I J K L M N O P Q R S T U V W X Y Z]</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f IDIOMATICALLY_DETERMINE_ALL_THE_LOWERCASE_AND_UPPERCASE_LETTERS.AWK
BEGIN {
Line 60 ⟶ 258:
exit(0)
}
</syntaxhighlight>
</lang>
<p>output using Microsoft Windows 8 version 6.2.9200 with code page 437 in a DOS window</p>
<pre>
Line 71 ⟶ 269:
uppercase 60: ABCDEFGHIJKLMNOPQRSTUVWXYZSOZYAAAAÄÅÆÇEÉEEIIIIDÑOOOOÖOUUUÜY_
</pre>
 
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
{{works with|Chipmunk Basic}}
{{works with|GW-BASIC}}
<syntaxhighlight lang="qbasic">10 FOR j = ASC("a") TO ASC("z")
20 PRINT CHR$(j);
30 NEXT j
40 PRINT
50 FOR j = ASC("A") TO ASC("Z")
60 PRINT CHR$(j);
70 NEXT j
80 END</syntaxhighlight>
{{out}}
<pre>abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
 
==={{header|BASIC256}}===
<syntaxhighlight lang="vb">for j = asc("a") to asc("z")
print chr(j);
next j
print
for j= asc("A") to Asc("Z")
print chr(j);
next j
end</syntaxhighlight>
{{out}}
<pre>abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
 
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
{{works with|Applesoft BASIC}}
{{works with|GW-BASIC}}
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">10 FOR j = ASC("a") TO ASC("z")
20 PRINT CHR$(j);
30 NEXT j
40 PRINT
50 FOR j = ASC("A") TO ASC("Z")
60 PRINT CHR$(j);
70 NEXT j
80 END</syntaxhighlight>
 
==={{header|GW-BASIC}}===
{{works with|Applesoft BASIC}}
{{works with|Chipmunk Basic}}
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">10 FOR j = ASC("a") TO ASC("z")
20 PRINT CHR$(j);
30 NEXT j
40 PRINT
50 FOR j = ASC("A") TO ASC("Z")
60 PRINT CHR$(j);
70 NEXT j
80 END</syntaxhighlight>
{{out}}
<pre>abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
 
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
{{works with|Applesoft BASIC}}
{{works with|Chipmunk Basic}}
{{works with|GW-BASIC}}
<syntaxhighlight lang="qbasic">10 CLS : REM 10 HOME for Applesoft BASIC
20 FOR J = ASC("a") TO ASC("z")
30 PRINT CHR$(J);
40 NEXT J
50 PRINT
60 FOR J = ASC("A") TO ASC("Z")
70 PRINT CHR$(J);
80 NEXT J
90 END</syntaxhighlight>
{{out}}
<pre>abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
 
==={{header|Run BASIC}}===
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
{{works with|Yabasic}}
<syntaxhighlight lang="vb">for j = asc("a") to asc("z")
print chr$(j);
next j
print
for j = asc("A") to asc("Z")
print chr$(j);
next j
end</syntaxhighlight>
{{out}}
<pre>abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
 
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">FOR j = ORD("a"[1:1]) TO ORD("z"[1:1])
PRINT CHR$(j);
NEXT j
PRINT
FOR j = ORD("A"[1:1]) to ORD("Z"[1:1])
PRINT CHR$(j);
NEXT j
END</syntaxhighlight>
{{out}}
<pre>abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
 
==={{header|Yabasic}}===
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
{{works with|Run BASIC}}
<syntaxhighlight lang="vb">for j = asc("a") to asc("z")
print chr$(j);
next j
print
for j= asc("A") to asc("Z")
print chr$(j);
next j
end</syntaxhighlight>
{{out}}
<pre>abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
 
int main(int argc, char const *argv[]) {
Line 81 ⟶ 402:
putchar('\n');
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>
Line 96 ⟶ 417:
NATIONAL character sets not tested here, code is commented out to satisfy the task spec of Latin/ENGLISH but left in listing for the benefit of the reader.
<langsyntaxhighlight lang="cobol"> identification division.
program-id. determine.
 
Line 173 ⟶ 494:
 
goback.
end program determine.</langsyntaxhighlight>
 
{{out}}
Line 180 ⟶ 501:
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
As noted, space is included in the category tests.
 
=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">
(flet ((do-case (converter)
;; A = 10, B = 11, ... Z = 35
(loop for radix from 10 to 35
for char = (funcall converter (digit-char radix 36)) do
(format t "~&~8D #\\~24A ~S"
;; The codes and names vary across systems
(char-code char) (char-name char) char))))
(format t "~&;;; Code Full Name Appearance")
;; Using a local function reduces code duplication
(do-case #'char-downcase) (do-case #'char-upcase))
</syntaxhighlight>
 
{{out}}
<syntaxhighlight lang="lisp">
;;; Code Full Name Appearance
97 #\LATIN_SMALL_LETTER_A #\a
98 #\LATIN_SMALL_LETTER_B #\b
99 #\LATIN_SMALL_LETTER_C #\c
100 #\LATIN_SMALL_LETTER_D #\d
101 #\LATIN_SMALL_LETTER_E #\e
102 #\LATIN_SMALL_LETTER_F #\f
103 #\LATIN_SMALL_LETTER_G #\g
104 #\LATIN_SMALL_LETTER_H #\h
105 #\LATIN_SMALL_LETTER_I #\i
106 #\LATIN_SMALL_LETTER_J #\j
107 #\LATIN_SMALL_LETTER_K #\k
108 #\LATIN_SMALL_LETTER_L #\l
109 #\LATIN_SMALL_LETTER_M #\m
110 #\LATIN_SMALL_LETTER_N #\n
111 #\LATIN_SMALL_LETTER_O #\o
112 #\LATIN_SMALL_LETTER_P #\p
113 #\LATIN_SMALL_LETTER_Q #\q
114 #\LATIN_SMALL_LETTER_R #\r
115 #\LATIN_SMALL_LETTER_S #\s
116 #\LATIN_SMALL_LETTER_T #\t
117 #\LATIN_SMALL_LETTER_U #\u
118 #\LATIN_SMALL_LETTER_V #\v
119 #\LATIN_SMALL_LETTER_W #\w
120 #\LATIN_SMALL_LETTER_X #\x
121 #\LATIN_SMALL_LETTER_Y #\y
122 #\LATIN_SMALL_LETTER_Z #\z
65 #\LATIN_CAPITAL_LETTER_A #\A
66 #\LATIN_CAPITAL_LETTER_B #\B
67 #\LATIN_CAPITAL_LETTER_C #\C
68 #\LATIN_CAPITAL_LETTER_D #\D
69 #\LATIN_CAPITAL_LETTER_E #\E
70 #\LATIN_CAPITAL_LETTER_F #\F
71 #\LATIN_CAPITAL_LETTER_G #\G
72 #\LATIN_CAPITAL_LETTER_H #\H
73 #\LATIN_CAPITAL_LETTER_I #\I
74 #\LATIN_CAPITAL_LETTER_J #\J
75 #\LATIN_CAPITAL_LETTER_K #\K
76 #\LATIN_CAPITAL_LETTER_L #\L
77 #\LATIN_CAPITAL_LETTER_M #\M
78 #\LATIN_CAPITAL_LETTER_N #\N
79 #\LATIN_CAPITAL_LETTER_O #\O
80 #\LATIN_CAPITAL_LETTER_P #\P
81 #\LATIN_CAPITAL_LETTER_Q #\Q
82 #\LATIN_CAPITAL_LETTER_R #\R
83 #\LATIN_CAPITAL_LETTER_S #\S
84 #\LATIN_CAPITAL_LETTER_T #\T
85 #\LATIN_CAPITAL_LETTER_U #\U
86 #\LATIN_CAPITAL_LETTER_V #\V
87 #\LATIN_CAPITAL_LETTER_W #\W
88 #\LATIN_CAPITAL_LETTER_X #\X
89 #\LATIN_CAPITAL_LETTER_Y #\Y
90 #\LATIN_CAPITAL_LETTER_Z #\Z
</syntaxhighlight>
 
=={{header|Dart}}==
<syntaxhighlight lang="dart">void main() {
String lowercase = '';
for (var c = 0x61; c < 0x7b; c++) lowercase += String.fromCharCode(c);
print(lowercase);
 
String uppercase = '';
for (var c = 0x41; c < 0x5b; c++) uppercase += String.fromCharCode(c);
print(uppercase);
}</syntaxhighlight>
{{out}}
<pre>abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
 
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.Character}}
{{Trans|Java}}
<syntaxhighlight lang="delphi">
program Idiomatically_determine_all_the_lowercase_and_uppercase_letters;
 
{$APPTYPE CONSOLE}
 
uses
System.SysUtils,
System.Character;
 
begin
var count := 0;
Write('Upper case: ');
for var i := 0 to $10FFFF do
if char(i).IsUpper then
begin
write(char(i));
inc(count);
if count >= 72 then
Break;
end;
writeln('...');
 
count := 0;
Write('Lower case: ');
for var i := 0 to $10FFFF do
if char(i).IsLower then
begin
write(char(i));
inc(count);
if count >= 72 then
Break;
end;
writeln('...');
readln;
end.</syntaxhighlight>
{{out}}
<pre>Upper case: ABCDEFGHIJKLMNOPQRSTUVWXYZAAAAÄÅÆÇEÉEEIIIIDÑOOOOÖOUUUÜY_AAACCCCDDEEEEEGG...
Lower case: abcdefghijklmnopqrstuvwxyzµßàáâaäåæçèéêëìíîïdñòóôoöoùúûüy_ÿaaaccccddeeee...</pre>
 
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
for i = strcode "a" to strcode "z"
write strchar i
.
print ""
for i = strcode "A" to strcode "Z"
write strchar i
.
</syntaxhighlight>
 
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
seq{(char)0..(char)127} |> Seq.filter(System.Char.IsUpper) |> Seq.iter (string >> printf "%s"); printfn ""
seq{(char)0..(char)127} |> Seq.filter(System.Char.IsLower) |> Seq.iter (string >> printf "%s"); printfn ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 193 ⟶ 654:
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">
USE: math.ranges
CHAR: A CHAR: Z [a,b] >string print
CHAR: a CHAR: z [a,b] >string print
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 203 ⟶ 664:
abcdefghijklmnopqrstuvwxyz
</pre>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">enum chartypes
LOWER = -1, UPPER = 1, NOTLETTER = 0
end enum
 
function letter_case( ch as string ) as byte
'exploits the fact that ucase and lcase consider non-letters to be
'both upper and lower case
if ucase(ch)=lcase(ch) then return NOTLETTER
if ch = ucase(ch) then return UPPER
return LOWER
end function
 
dim as uinteger i
for i = 0 to 255
if letter_case(chr(i)) = LOWER then print chr(i);
next i
print
for i = 0 to 255
if letter_case(chr(i)) = UPPER then print chr(i);
next i
print</syntaxhighlight>
{{out}}
<pre>
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
</pre>
 
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
int i
 
for i = asc("a") to asc("z") : print chr$(i); : next
print
for i = asc("A") to asc("Z") : print chr$(i); : next
 
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
</pre>
 
 
=={{header|Go}}==
Shown are ASCII and Unicode lower and upper case. Relevant to Unicode definitions of lower and upper case is not the hardware or operating system but the Unicode version implemented.
<langsyntaxhighlight lang="go">package main
 
import (
Line 262 ⟶ 768:
fmt.Println()
}
}</langsyntaxhighlight>
{{Out}}
<pre>
Line 317 ⟶ 823:
=={{header|Haskell}}==
The specification seems pretty explicit that it only wants the English letters from <i>a</i> to <i>z</i> and from <i>A</i> to <i>Z</i>, so we don't need to worry about Unicode this time.
<langsyntaxhighlight lang="haskell">main = do putStrLn $ "Lower: " ++ ['a'..'z']
putStrLn $ "Upper: " ++ ['A'..'Z']</langsyntaxhighlight>
{{out}}
<pre>Lower: abcdefghijklmnopqrstuvwxyz
Line 324 ⟶ 830:
 
 
And if we want to generalise a little beyond a narrowly Anglo-Saxon notion of the alphabetalphabets:
<syntaxhighlight lang="haskell">import Control.Monad (join)
<lang Haskell>import Data.Char (chr, isPrint, isUpper, isLower)
import Data.Bifunctor (bimap, second)
import Data.Bool (bool)
import Data.Char (chr, isLower, isPrint, isUpper)
import Data.List (partition)
import Data.List.Split (chunksOf)
 
----------- ALL LOWERCASE AND UPPERCASE LETTERS ----------
 
uppersAndLowers :: (String, String)
uppersAndLowers =
second
(fst . partitionfilter isLower)
( partition isUpper $ filter isPrint (chr <$> [1 .. 0x10ffff]))
isUpper
( ((bool [] . pure) <*> isPrint) . chr
=<< [1 .. 0x10ffff]
)
)
 
--------------------------- TEST -------------------------
main :: IO ()
main = do
mapM_ (putStrLn $. "Upper:"unlines :. chunksOf 70uncurry (fst uppersAndLowers<>)) $
bimap
putStrLn []
("Upper:" :)
mapM_ putStrLn $ "Lower:" : chunksOf 70 (snd uppersAndLowers)</lang>
("\nLower:" :)
$ join bimap (chunksOf 70) uppersAndLowers</syntaxhighlight>
{{Out}}
<pre>Upper:
Line 394 ⟶ 912:
𝜹𝜺𝜻𝜼𝜽𝜾𝜿𝝀𝝁𝝂𝝃𝝄𝝅𝝆𝝇𝝈𝝉𝝊𝝋𝝌𝝍𝝎𝝐𝝑𝝒𝝓𝝔𝝕𝝰𝝱𝝲𝝳𝝴𝝵𝝶𝝷𝝸𝝹𝝺𝝻𝝼𝝽𝝾𝝿𝞀𝞁𝞂𝞃𝞄𝞅𝞆𝞇𝞈𝞊𝞋𝞌𝞍𝞎𝞏𝞪𝞫𝞬𝞭𝞮𝞯𝞰𝞱𝞲𝞳𝞴
𝞵𝞶𝞷𝞸𝞹𝞺𝞻𝞼𝞽𝞾𝞿𝟀𝟁𝟂𝟄𝟅𝟆𝟇𝟈𝟉𝟋</pre>
 
=={{Header|Insitux}}==
 
<b>Approach One</b>
 
<syntaxhighlight lang="insitux">
(let chars-between (comp range (map char-code) (... str)))
 
(str "Upper-case: " (chars-between 65 91) "
Lower-case: " (chars-between 97 123))
</syntaxhighlight>
 
<b>Approach Two</b>
 
<syntaxhighlight lang="insitux">
(let ascii (map char-code (range 127)))
 
(.. str "Upper-case: " (filter upper? ascii) "
Lower-case: " (filter lower? ascii))
</syntaxhighlight>
 
{{out}}
for both approaches
 
<pre>
Upper-case: ABCDEFGHIJKLMNOPQRSTUVWXYZ
Lower-case: abcdefghijklmnopqrstuvwxyz
</pre>
 
=={{header|J}}==
Line 401 ⟶ 947:
That said:
 
<langsyntaxhighlight Jlang="j"> (#~ tolower ~: toupper) a.
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz</langsyntaxhighlight>
 
Note that, as hinted at above, we get the same result using UCS-2:
 
<langsyntaxhighlight Jlang="j"> (#~ tolower ~: toupper) u: i.65536
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz</langsyntaxhighlight>
 
=={{header|Jakt}}==
<syntaxhighlight lang="jakt">
fn main() {
mut lower = StringBuilder::create()
// Iteration as code points (u32)
for code_point in 'a'..('z' + 1) {
lower.append(code_point)
}
println("{}", lower.to_string())
 
mut upper = StringBuilder::create()
// Iteration as ASCII bytes (u8), same result
for b in b'A'..(b'Z' + 1) {
upper.append(b)
}
println("{}", upper.to_string())
}
</syntaxhighlight>
 
=={{header|Java}}==
{{works with|Java|8}}
<langsyntaxhighlight lang="java">import java.util.stream.IntStream;
 
public class Letters {
Line 429 ⟶ 994:
System.out.println("...");
}
}</langsyntaxhighlight>
 
<pre>Upper case: ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞĀĂĄĆĈĊČĎĐĒĔĖĘĚĜĞ...
Lower case: abcdefghijklmnopqrstuvwxyzªµºßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿāăąćĉċčďđēĕ...</pre>
 
=={{header|jq}}==
{{works with|jq|with regex support}}
 
We first define a function for generating a JSON string of all the Unicode characters that have codepoints within a specified range and which belong to a specified "\p" character class.
<langsyntaxhighlight lang="jq"># The range of codepoints is from m up to but excluding n;
# "class" should be a character class, e.g. Ll or Lu for lower/upper case respectively.
def generate(class; m; n):
reduce (range(m;n) | [.] | implode | select( test( "\\p{" + class + "}" ))) as $c
(""; . + $c);</langsyntaxhighlight>
 
'''The number of lowercase Unicode characters:'''
<langsyntaxhighlight lang="jq">def maxu: 1114112; # The number of Unicode codepoints
generate("Ll"; 0; maxu) | length #=> 1607</langsyntaxhighlight>
 
'''The number of uppercase Unicode characters:'''
<langsyntaxhighlight lang="jq">generate("Lu"; 0; maxu) | length #=> 1296</langsyntaxhighlight>
 
'''Examples''':
 
Lowercase letters amongst the first 1024 Unicode codepoints:
<langsyntaxhighlight lang="jq">generate("Ll"; 0; 1024)</langsyntaxhighlight>
{{out}}
<syntaxhighlight lang ="sh">abcdefghijklmnopqrstuvwxyzµºßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿāăąćĉċčďđēĕėęěĝğġģĥħĩīĭįıijĵķĸĺļľŀłńņňʼnŋōŏőœŕŗřśŝşšţťŧũūŭůűųŵŷźżžſƀƃƅƈƌƍƒƕƙƚƛƞơƣƥƨƪƫƭưƴƶƹƺƽƾƿdžljnjǎǐǒǔǖǘǚǜǝǟǡǣǥǧǩǫǭǯǰdzǵǹǻǽǿȁȃȅȇȉȋȍȏȑȓȕȗșțȝȟȡȣȥȧȩȫȭȯȱȳȴȵȶȷȸȹȼȿɀɐɑɒɓɔɕɖɗɘəɚɛɜɝɞɟɠɡɢɣɤɥɦɧɨɩɪɫɬɭɮɯɰɱɲɳɴɵɶɷɸɹɺɻɼɽɾɿʀʁʂʃʄʅʆʇʈʉʊʋʌʍʎʏʐʑʒʓʔʕʖʗʘʙʚʛʜʝʞʟʠʡʢʣʤʥʦʧʨʩʪʫʬʭʮʯΐάέήίΰαβγδεζηθικλμνξοπρςστυφχψωϊϋόύώϐϑϕϖϗϙϛϝϟϡϣϥϧϩϫϭϯϰϱϲϳϵϸϻϼ</langsyntaxhighlight>
 
 
Uppercase letters amongst the first 1024 Unicode codepoints:
<langsyntaxhighlight lang="jq">generate("Lu"; 0; 1024)</langsyntaxhighlight>
{{Out}}
<syntaxhighlight lang ="sh">ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞĀĂĄĆĈĊČĎĐĒĔĖĘĚĜĞĠĢĤĦĨĪĬĮİIJĴĶĹĻĽĿŁŃŅŇŊŌŎŐŒŔŖŘŚŜŞŠŢŤŦŨŪŬŮŰŲŴŶŸŹŻŽƁƂƄƆƇƉƊƋƎƏƐƑƓƔƖƗƘƜƝƟƠƢƤƦƧƩƬƮƯƱƲƳƵƷƸƼDŽLJNJǍǏǑǓǕǗǙǛǞǠǢǤǦǨǪǬǮDZǴǶǷǸǺǼǾȀȂȄȆȈȊȌȎȐȒȔȖȘȚȜȞȠȢȤȦȨȪȬȮȰȲȺȻȽȾɁΆΈΉΊΌΎΏΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩΪΫϒϓϔϘϚϜϞϠϢϤϦϨϪϬϮϴϷϹϺϽϾϿ</langsyntaxhighlight>
 
=={{header|Julia}}==
Julia supports Unicode natively: the Char type in Julia is 32 bits, and Julia code base supports Unicode characters up to 3 bytes in length. This means that unless ascii coding or the English alphabet is specified there are too many valid Chars to print here.
It is common to manipulate characters in varying ways, as below, as integers, unicode Chars, and strings.
<langsyntaxhighlight lang="julia">
function countunicode()
englishlettercodes = [Int(c) for c in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"]
Line 494 ⟶ 1,059:
println("lowercase: $lcletters and uppercase: $ucletters.")
 
</syntaxhighlight>
</lang>
{{output}}
There are 267753 valid Chars and the English ones are lowercase: abcdefghijklmnopqrstuvwxyz and uppercase: ABCDEFGHIJKLMNOPQRSTUVWXYZ.
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.0.6
 
fun main(args: Array<String>) {
Line 507 ⟶ 1,072:
for (ch in 'A'..'Z') print(ch)
println()
}</langsyntaxhighlight>
 
{{out}}
Line 517 ⟶ 1,082:
=={{header|Lua}}==
The function below makes use of Lua's pattern matching system via the in-built string.match() function. All characters matching the supplied pattern argument are concatenated to a string, which is returned as the result after all ASCII characters have been tested.
<langsyntaxhighlight Lualang="lua">function ASCIIstring (pattern)
local matchString, ch = ""
for charNum = 0, 255 do
Line 530 ⟶ 1,095:
print(ASCIIstring("%l"))
print(ASCIIstring("%u"))
</syntaxhighlight>
</lang>
{{Out}}
<pre>abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">StringJoin[CharacterRange["a", "z"]]
StringJoin[CharacterRange["A", "Z"]]</syntaxhighlight>
{{out}}
<pre>abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
 
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">
sublist(makelist(unicode(i),i,0,127),lowercasep);
sublist(makelist(unicode(i),i,0,127),uppercasep);
</syntaxhighlight>
{{out}}
<pre>
["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"]
</pre>
 
=={{header|MiniScript}}==
MiniScript natively supports Unicode, but the task clearly specifies only English (unaccented) letters, so a solution is:
<langsyntaxhighlight MiniScriptlang="miniscript">toChars = function(seq)
for i in seq.indexes
seq[i] = char(seq[i])
Line 545 ⟶ 1,128:
 
print toChars(range(code("a"), code("z")))
print toChars(range(code("A"), code("Z")))</langsyntaxhighlight>
 
{{out}}
<pre>abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
 
=={{header|Nim}}==
Nim has a <code>char</code> type whose values are contained in a single bit. The values from 0 to 127 are the ASCII characters. Strings are composed of char values but they are considered to be encoded in UTF-8. So accessing an individual character of a string may have no meaning when not working in ASCII.
 
Note that Nim allows to work with full Unicode, either by using strings encoded in UTF-8 (but with limited possibilities) or by using the runes of the module “unicode”. Identifiers may contain Unicode letters or digits as in “θ₁”, “â”, “x₁”, “x³”.
 
The following program displays the lowercase and uppercase ASCII letters.
 
<syntaxhighlight lang="nim">import sequtils, strutils
 
echo "Lowercase characters:"
echo toSeq('a'..'z').join()
echo ""
echo "Uppercase characters:"
echo toSeq('A'..'Z').join()</syntaxhighlight>
 
{{out}}
<pre>Lowercase characters:
abcdefghijklmnopqrstuvwxyz
 
Uppercase characters:
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
 
=={{header|PARI/GP}}==
GP has no support for Unicode and does not even have reliable cross-platform support for upper ASCII. The only letters in lower ASCII are
<langsyntaxhighlight lang="parigp">apply(Strchr, concat([65..90], [97..122]))</langsyntaxhighlight>
Upper ASCII (not to be confused with ISO Latin-1) has the following letters:
<langsyntaxhighlight lang="parigp">apply(Strchr, concat(concat([128..154], [160..165]),concat(concat([181,182,183,198,199],[208..216]),[224..237])))</langsyntaxhighlight>
 
=={{header|Perl}}==
<syntaxhighlight lang ="perl">foruse $i (0v5..2**8-1) {12;
use utf8;
$c = chr $i;
binmode STDOUT, ':utf8';
 
my($lower,$upper);
 
for my $i (0..2**8-1) {
my $c = chr $i;
$lower .= $c if $c =~ /[[:lower:]]/;
$upper .= $c if $c =~ /[[:upper:]]/;
}
 
printsay "$lower\n";
printsay "$upper\n";</langsyntaxhighlight>
{{out}}
<pre>abcdefghijklmnopqrstuvwxyzªµºßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ
ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ</pre>
ABCDEFGHIJKLMNOPQRSTUVWXYZ</pre>
 
=={{header|Phix}}==
Phix supports utf8 source files, so theoretically (but not necessarily in practice) identifiers can contain any utf8-representable characters.<br>
The compiler source ptok.e contains:
<lang Phix>charset['A'..'Z'] = LETTER
charset[#80] = LETTER -- more unicode
charset[#88] = LETTER -- more unicode
charset[#94] = LETTER -- for rosettacode/unicode (as ptok.e is not stored in utf8)
charset[#9A] = LETTER -- for rosettacode/unicode
charset[#A3] = LETTER -- for rosettacode/unicode
charset[#BB] = LETTER -- for rosettacode/unicode
charset[#CE] = LETTER -- for rosettacode/unicode
charset[#CF] = LETTER
charset[#E2] = LETTER
charset['_'] = LETTER
charset['a'..'z'] = LETTER</lang>
So the language itself supports A-Z, a-z, and a handful of ad-hoc non-Latin characters, which can easily be extended.
 
The builtin routines islower and isupper (see builtins\pcase.e and/or builtins\pcase8.e) currently test values in the range 1..255 thus:
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Phix>sequence lc = {}, uc = {}
<span style="color: #004080;">sequence</span> <span style="color: #000000;">lc</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{},</span> <span style="color: #000000;">uc</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
for ch=1 to 255 do
<span style="color: #008080;">for</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">255</span> <span style="color: #008080;">do</span>
if islower(ch) then lc &= ch end if
<span style="color: #008080;">if</span> <span style="color: #7060A8;">islower</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> <span style="color: #000000;">lc</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">ch</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
if isupper(ch) then uc &= ch end if
<span style="color: #008080;">if</span> <span style="color: #7060A8;">isupper</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> <span style="color: #000000;">uc</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">ch</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
end for
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
lc = utf32_to_utf8(lc)&"\n"
<span style="color: #000000;">lc</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">utf32_to_utf8</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lc</span><span style="color: #0000FF;">)&</span><span style="color: #008000;">"\n"</span>
uc = utf32_to_utf8(uc)&"\n"
<span style="color: #000000;">uc</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">utf32_to_utf8</span><span style="color: #0000FF;">(</span><span style="color: #000000;">uc</span><span style="color: #0000FF;">)&</span><span style="color: #008000;">"\n"</span>
puts(1,lc)
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lc</span><span style="color: #0000FF;">)</span>
puts(1,uc)</lang>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">uc</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 602 ⟶ 1,199:
ABCDEFGHIJKLMNOPQRSTUVWXYZ���ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ
</pre>
That code is now part of demo\HelloUTF8.exw, which has the necessary Windows console code page setting code, though it has clearly fouled up on 2 or 3 characters somehow - probably quite easy to fix, should you care enough. I also tried displaying them in a MessageBox, which hid the 2/3 glitches, but got exactly the same results on copy and paste, btw, and slightly different but no better running it under pwa/p2js. Apart from the characters shown above (<=#FF), no attempt whatsoever is made to convert higher unicode codepoints between upper and lower case, and using say <code>utf32_to_utf8(upper(utf8_to_utf32(utf8)))</code> is advised when dealing with utf8 strings, since a plain <code>upper(utf8)</code> will likely mangle individual bytes which are part of a multi-byte character in the range #100..#10FFFF, which the former leaves completely alone.
That code is now part of demo\HelloUTF8.exw, which has the necessary Windows console code page setting code, though it has
clearly fouled up on 2 or 3 characters somehow - probably quite easy to fix, should you care enough. (I also tried displaying
them in a MessageBox, which hid the 2/3 glitches, but got exactly the same results on copy and paste, btw.)
 
=={{header|Python}}==
Python defines [http://docs.python.org/3.1/library/stdtypes.html#str.isalnum eleven string classes] for the Unicode characters in the range 0 to 0x10FFFF which include lowercase and uppercase. The following gives information on all the classes with the two asked for coming first but only printing out the first up to 100 characters to spare long meaningless printouts.
 
<langsyntaxhighlight lang="python">classes = (str.isupper, str.islower, str.isalnum, str.isalpha, str.isdecimal,
str.isdigit, str.isidentifier, str.isnumeric, str.isprintable,
str.isspace, str.istitle)
Line 616 ⟶ 1,211:
chars = ''.join(chr(i) for i in range(0x10FFFF+1) if stringclass(chr(i)))
print('\nString class %s has %i characters the first of which are:\n %r'
% (stringclass.__name__, len(chars), chars[:100]))</langsyntaxhighlight>
 
{{out}}
Line 651 ⟶ 1,246:
String class istitle has 1514 characters the first of which are:
'ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞĀĂĄĆĈĊČĎĐĒĔĖĘĚĜĞĠĢĤĦĨĪĬĮİIJĴĶĹĻĽĿŁŃŅŇŊŌŎŐŒŔŖŘ'</pre>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="quackery"> [ dup upper != ] is islower ( c --> b )
 
[ dup lower != ] is isupper ( c --> b )
 
say "Lower case: "
127 times
[ i^ islower if [ i^ emit ] ]
cr
say "Upper case: "
127 times
[ i^ isupper if [ i^ emit ] ]</syntaxhighlight>
 
{{out}}
 
<pre>Lower case: abcdefghijklmnopqrstuvwxyz
Upper case: ABCDEFGHIJKLMNOPQRSTUVWXYZ
</pre>
 
=={{header|Racket}}==
Character sets and utils are defined in [http://docs.racket-lang.org/srfi/srfi-std/srfi-14.html SRFI 14: Character-set Library].
<langsyntaxhighlight lang="racket">#lang racket
(require srfi/14)
(printf "System information: ~a~%" (map system-type (list 'os 'word 'machine)))
(printf "All lowercase characters: ~a~%" (char-set->string char-set:lower-case))
(newline)
(printf "All uppercase characters: ~a~%" (char-set->string char-set:upper-case))</langsyntaxhighlight>
 
{{out}}
Line 669 ⟶ 1,284:
 
=={{header|Prolog}}==
<langsyntaxhighlight Prologlang="prolog">chars :-
findall(Lower, maplist(char_type(Lower), [alpha, ascii, lower]), Lowers),
Line 678 ⟶ 1,293:
findall(Upper, maplist(char_type(Upper), [alpha, ascii, upper]), Uppers),
writeln('-- Upper Case Characters --'),
writeln(Uppers).</langsyntaxhighlight>
{{out}}
<pre>
Line 691 ⟶ 1,306:
 
 
 
=={{header|R}}==
 
R has the builtin variables LETTERS and letters:
 
<syntaxhighlight lang="rsplus">LETTERS
# [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S" "T" "U" "V" "W" "X" "Y" "Z"
letters
# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"</syntaxhighlight>
 
=={{header|Raku}}==
(formerly Perl 6)
Raku supports all the Unicode categories of characters natively. The constant <tt>0x1fffd</tt> is <em>not</em> a typo for <tt>0x10ffff</tt>: we're restricting the range of characters to the first two Unicode planes, since the 3rd plane is reserved for ideographs (category Lo, "letter other"), and the subsequent planes contain no letters (yet).
<syntaxhighlight lang="raku" perl6line>given (0..0x1fffd).chrs {
say "Lowercase: ", .comb(/<:Ll>/);
say "Uppercase: ", .comb(/<:Lu>/);
say "Titlecase: ", .comb(/<:Lt>/);
}</langsyntaxhighlight>
<pre>Lowercase: a b c d e f g h i j k l m n o p q r s t u v w x y z µ ß à á â ã ä å æ ç è é ê ë ì í î ï ð ñ ò ó ô õ ö ø ù ú û ü ý þ ÿ ā ă ą ć ĉ ċ č ď đ ē ĕ ė ę ě ĝ ğ ġ ģ ĥ ħ ĩ ī ĭ į ı ij ĵ ķ ĸ ĺ ļ ľ ŀ ł ń ņ ň ʼn ŋ ō ŏ ő œ ŕ ŗ ř ś ŝ ş š ţ ť ŧ ũ ū ŭ ů ű ų ŵ ŷ ź ż ž ſ ƀ ƃ ƅ ƈ ƌ ƍ ƒ ƕ ƙ ƚ ƛ ƞ ơ ƣ ƥ ƨ ƪ ƫ ƭ ư ƴ ƶ ƹ ƺ ƽ ƾ ƿ dž lj nj ǎ ǐ ǒ ǔ ǖ ǘ ǚ ǜ ǝ ǟ ǡ ǣ ǥ ǧ ǩ ǫ ǭ ǯ ǰ dz ǵ ǹ ǻ ǽ ǿ ȁ ȃ ȅ ȇ ȉ ȋ ȍ ȏ ȑ ȓ ȕ ȗ ș ț ȝ ȟ ȡ ȣ ȥ ȧ ȩ ȫ ȭ ȯ ȱ ȳ ȴ ȵ ȶ ȷ ȸ ȹ ȼ ȿ ɀ ɂ ɇ ɉ ɋ ɍ ɏ ɐ ɑ ɒ ɓ ɔ ɕ ɖ ɗ ɘ ə ɚ ɛ ɜ ɝ ɞ ɟ ɠ ɡ ɢ ɣ ɤ ɥ ɦ ɧ ɨ ɩ ɪ ɫ ɬ ɭ ɮ ɯ ɰ ɱ ɲ ɳ ɴ ɵ ɶ ɷ ɸ ɹ ɺ ɻ ɼ ɽ ɾ ɿ ʀ ʁ ʂ ʃ ʄ ʅ ʆ ʇ ʈ ʉ ʊ ʋ ʌ ʍ ʎ ʏ ʐ ʑ ʒ ʓ ʕ ʖ ʗ ʘ ʙ ʚ ʛ ʜ ʝ ʞ ʟ ʠ ʡ ʢ ʣ ʤ ʥ ʦ ʧ ʨ ʩ ʪ ʫ ʬ ʭ ʮ ʯ ͱ ͳ ͷ ͻ ͼ ͽ ΐ ά έ ή ί ΰ α β γ δ ε ζ η θ ι κ λ μ ν ξ ο π ρ ς σ τ υ φ χ ψ ω ϊ ϋ ό ύ ώ ϐ ϑ ϕ ϖ ϗ ϙ ϛ ϝ ϟ ϡ ϣ ϥ ϧ ϩ ϫ ϭ ϯ ϰ ϱ ϲ ϳ ϵ ϸ ϻ ϼ а б в г д е ж з и й к л м н о п р с т у ф х ц ч ш щ ъ ы ь э ю я ѐ ё ђ ѓ є ѕ і ї ј љ њ ћ ќ ѝ ў џ ѡ ѣ ѥ ѧ ѩ ѫ ѭ ѯ ѱ ѳ ѵ ѷ ѹ ѻ ѽ ѿ ҁ ҋ ҍ ҏ ґ ғ ҕ җ ҙ қ ҝ ҟ ҡ ң ҥ ҧ ҩ ҫ ҭ ү ұ ҳ ҵ ҷ ҹ һ ҽ ҿ ӂ ӄ ӆ ӈ ӊ ӌ ӎ ӏ ӑ ӓ ӕ ӗ ә ӛ ӝ ӟ ӡ ӣ ӥ ӧ ө ӫ ӭ ӯ ӱ ӳ ӵ ӷ ӹ ӻ ӽ ӿ ԁ ԃ ԅ ԇ ԉ ԋ ԍ ԏ ԑ ԓ ԕ ԗ ԙ ԛ ԝ ԟ ԡ ԣ ԥ ԧ ա բ գ դ ե զ է ը թ ժ ի լ խ ծ կ հ ձ ղ ճ մ յ ն շ ո չ պ ջ ռ ս վ տ ր ց ւ փ ք օ ֆ և ᴀ ᴁ ᴂ ᴃ ᴄ ᴅ ᴆ ᴇ ᴈ ᴉ ᴊ ᴋ ᴌ ᴍ ᴎ ᴏ ᴐ ᴑ ᴒ ᴓ ᴔ ᴕ ᴖ ᴗ ᴘ ᴙ ᴚ ᴛ ᴜ ᴝ ᴞ ᴟ ᴠ ᴡ ᴢ ᴣ ᴤ ᴥ ᴦ ᴧ ᴨ ᴩ ᴪ ᴫ ᵫ ᵬ ᵭ ᵮ ᵯ ᵰ ᵱ ᵲ ᵳ ᵴ ᵵ ᵶ ᵷ ᵹ ᵺ ᵻ ᵼ ᵽ ᵾ ᵿ ᶀ ᶁ ᶂ ᶃ ᶄ ᶅ ᶆ ᶇ ᶈ ᶉ ᶊ ᶋ ᶌ ᶍ ᶎ ᶏ ᶐ ᶑ ᶒ ᶓ ᶔ ᶕ ᶖ ᶗ ᶘ ᶙ ᶚ ḁ ḃ ḅ ḇ ḉ ḋ ḍ ḏ ḑ ḓ ḕ ḗ ḙ ḛ ḝ ḟ ḡ ḣ ḥ ḧ ḩ ḫ ḭ ḯ ḱ ḳ ḵ ḷ ḹ ḻ ḽ ḿ ṁ ṃ ṅ ṇ ṉ ṋ ṍ ṏ ṑ ṓ ṕ ṗ ṙ ṛ ṝ ṟ ṡ ṣ ṥ ṧ ṩ ṫ ṭ ṯ ṱ ṳ ṵ ṷ ṹ ṻ ṽ ṿ ẁ ẃ ẅ ẇ ẉ ẋ ẍ ẏ ẑ ẓ ẕ ẖ ẗ ẘ ẙ ẚ ẛ ẜ ẝ ẟ ạ ả ấ ầ ẩ ẫ ậ ắ ằ ẳ ẵ ặ ẹ ẻ ẽ ế ề ể ễ ệ ỉ ị ọ ỏ ố ồ ổ ỗ ộ ớ ờ ở ỡ ợ ụ ủ ứ ừ ử ữ ự ỳ ỵ ỷ ỹ ỻ ỽ ỿ ἀ ἁ ἂ ἃ ἄ ἅ ἆ ἇ ἐ ἑ ἒ ἓ ἔ ἕ ἠ ἡ ἢ ἣ ἤ ἥ ἦ ἧ ἰ ἱ ἲ ἳ ἴ ἵ ἶ ἷ ὀ ὁ ὂ ὃ ὄ ὅ ὐ ὑ ὒ ὓ ὔ ὕ ὖ ὗ ὠ ὡ ὢ ὣ ὤ ὥ ὦ ὧ ὰ ά ὲ έ ὴ ή ὶ ί ὸ ό ὺ ύ ὼ ώ ᾀ ᾁ ᾂ ᾃ ᾄ ᾅ ᾆ ᾇ ᾐ ᾑ ᾒ ᾓ ᾔ ᾕ ᾖ ᾗ ᾠ ᾡ ᾢ ᾣ ᾤ ᾥ ᾦ ᾧ ᾰ ᾱ ᾲ ᾳ ᾴ ᾶ ᾷ ι ῂ ῃ ῄ ῆ ῇ ῐ ῑ ῒ ΐ ῖ ῗ ῠ ῡ ῢ ΰ ῤ ῥ ῦ ῧ ῲ ῳ ῴ ῶ ῷ ℊ ℎ ℏ ℓ ℯ ℴ ℹ ℼ ℽ ⅆ ⅇ ⅈ ⅉ ⅎ ↄ ⰰ ⰱ ⰲ ⰳ ⰴ ⰵ ⰶ ⰷ ⰸ ⰹ ⰺ ⰻ ⰼ ⰽ ⰾ ⰿ ⱀ ⱁ ⱂ ⱃ ⱄ ⱅ ⱆ ⱇ ⱈ ⱉ ⱊ ⱋ ⱌ ⱍ ⱎ ⱏ ⱐ ⱑ ⱒ ⱓ ⱔ ⱕ ⱖ ⱗ ⱘ ⱙ ⱚ ⱛ ⱜ ⱝ ⱞ ⱡ ⱥ ⱦ ⱨ ⱪ ⱬ ⱱ ⱳ ⱴ ⱶ ⱷ ⱸ ⱹ ⱺ ⱻ ⲁ ⲃ ⲅ ⲇ ⲉ ⲋ ⲍ ⲏ ⲑ ⲓ ⲕ ⲗ ⲙ ⲛ ⲝ ⲟ ⲡ ⲣ ⲥ ⲧ ⲩ ⲫ ⲭ ⲯ ⲱ ⲳ ⲵ ⲷ ⲹ ⲻ ⲽ ⲿ ⳁ ⳃ ⳅ ⳇ ⳉ ⳋ ⳍ ⳏ ⳑ ⳓ ⳕ ⳗ ⳙ ⳛ ⳝ ⳟ ⳡ ⳣ ⳤ ⳬ ⳮ ⳳ ⴀ ⴁ ⴂ ⴃ ⴄ ⴅ ⴆ ⴇ ⴈ ⴉ ⴊ ⴋ ⴌ ⴍ ⴎ ⴏ ⴐ ⴑ ⴒ ⴓ ⴔ ⴕ ⴖ ⴗ ⴘ ⴙ ⴚ ⴛ ⴜ ⴝ ⴞ ⴟ ⴠ ⴡ ⴢ ⴣ ⴤ ⴥ ⴧ ⴭ ꙁ ꙃ ꙅ ꙇ ꙉ ꙋ ꙍ ꙏ ꙑ ꙓ ꙕ ꙗ ꙙ ꙛ ꙝ ꙟ ꙡ ꙣ ꙥ ꙧ ꙩ ꙫ ꙭ ꚁ ꚃ ꚅ ꚇ ꚉ ꚋ ꚍ ꚏ ꚑ ꚓ ꚕ ꚗ ꜣ ꜥ ꜧ ꜩ ꜫ ꜭ ꜯ ꜰ ꜱ ꜳ ꜵ ꜷ ꜹ ꜻ ꜽ ꜿ ꝁ ꝃ ꝅ ꝇ ꝉ ꝋ ꝍ ꝏ ꝑ ꝓ ꝕ ꝗ ꝙ ꝛ ꝝ ꝟ ꝡ ꝣ ꝥ ꝧ ꝩ ꝫ ꝭ ꝯ ꝱ ꝲ ꝳ ꝴ ꝵ ꝶ ꝷ ꝸ ꝺ ꝼ ꝿ ꞁ ꞃ ꞅ ꞇ ꞌ ꞎ ꞑ ꞓ ꞡ ꞣ ꞥ ꞧ ꞩ ꟺ ff fi fl ffi ffl ſt st ﬓ ﬔ ﬕ ﬖ ﬗ a b c d e f g h i j k l m n o p q r s t u v w x y z 𐐨 𐐩 𐐪 𐐫 𐐬 𐐭 𐐮 𐐯 𐐰 𐐱 𐐲 𐐳 𐐴 𐐵 𐐶 𐐷 𐐸 𐐹 𐐺 𐐻 𐐼 𐐽 𐐾 𐐿 𐑀 𐑁 𐑂 𐑃 𐑄 𐑅 𐑆 𐑇 𐑈 𐑉 𐑊 𐑋 𐑌 𐑍 𐑎 𐑏 𝐚 𝐛 𝐜 𝐝 𝐞 𝐟 𝐠 𝐡 𝐢 𝐣 𝐤 𝐥 𝐦 𝐧 𝐨 𝐩 𝐪 𝐫 𝐬 𝐭 𝐮 𝐯 𝐰 𝐱 𝐲 𝐳 𝑎 𝑏 𝑐 𝑑 𝑒 𝑓 𝑔 𝑖 𝑗 𝑘 𝑙 𝑚 𝑛 𝑜 𝑝 𝑞 𝑟 𝑠 𝑡 𝑢 𝑣 𝑤 𝑥 𝑦 𝑧 𝒂 𝒃 𝒄 𝒅 𝒆 𝒇 𝒈 𝒉 𝒊 𝒋 𝒌 𝒍 𝒎 𝒏 𝒐 𝒑 𝒒 𝒓 𝒔 𝒕 𝒖 𝒗 𝒘 𝒙 𝒚 𝒛 𝒶 𝒷 𝒸 𝒹 𝒻 𝒽 𝒾 𝒿 𝓀 𝓁 𝓂 𝓃 𝓅 𝓆 𝓇 𝓈 𝓉 𝓊 𝓋 𝓌 𝓍 𝓎 𝓏 𝓪 𝓫 𝓬 𝓭 𝓮 𝓯 𝓰 𝓱 𝓲 𝓳 𝓴 𝓵 𝓶 𝓷 𝓸 𝓹 𝓺 𝓻 𝓼 𝓽 𝓾 𝓿 𝔀 𝔁 𝔂 𝔃 𝔞 𝔟 𝔠 𝔡 𝔢 𝔣 𝔤 𝔥 𝔦 𝔧 𝔨 𝔩 𝔪 𝔫 𝔬 𝔭 𝔮 𝔯 𝔰 𝔱 𝔲 𝔳 𝔴 𝔵 𝔶 𝔷 𝕒 𝕓 𝕔 𝕕 𝕖 𝕗 𝕘 𝕙 𝕚 𝕛 𝕜 𝕝 𝕞 𝕟 𝕠 𝕡 𝕢 𝕣 𝕤 𝕥 𝕦 𝕧 𝕨 𝕩 𝕪 𝕫 𝖆 𝖇 𝖈 𝖉 𝖊 𝖋 𝖌 𝖍 𝖎 𝖏 𝖐 𝖑 𝖒 𝖓 𝖔 𝖕 𝖖 𝖗 𝖘 𝖙 𝖚 𝖛 𝖜 𝖝 𝖞 𝖟 𝖺 𝖻 𝖼 𝖽 𝖾 𝖿 𝗀 𝗁 𝗂 𝗃 𝗄 𝗅 𝗆 𝗇 𝗈 𝗉 𝗊 𝗋 𝗌 𝗍 𝗎 𝗏 𝗐 𝗑 𝗒 𝗓 𝗮 𝗯 𝗰 𝗱 𝗲 𝗳 𝗴 𝗵 𝗶 𝗷 𝗸 𝗹 𝗺 𝗻 𝗼 𝗽 𝗾 𝗿 𝘀 𝘁 𝘂 𝘃 𝘄 𝘅 𝘆 𝘇 𝘢 𝘣 𝘤 𝘥 𝘦 𝘧 𝘨 𝘩 𝘪 𝘫 𝘬 𝘭 𝘮 𝘯 𝘰 𝘱 𝘲 𝘳 𝘴 𝘵 𝘶 𝘷 𝘸 𝘹 𝘺 𝘻 𝙖 𝙗 𝙘 𝙙 𝙚 𝙛 𝙜 𝙝 𝙞 𝙟 𝙠 𝙡 𝙢 𝙣 𝙤 𝙥 𝙦 𝙧 𝙨 𝙩 𝙪 𝙫 𝙬 𝙭 𝙮 𝙯 𝚊 𝚋 𝚌 𝚍 𝚎 𝚏 𝚐 𝚑 𝚒 𝚓 𝚔 𝚕 𝚖 𝚗 𝚘 𝚙 𝚚 𝚛 𝚜 𝚝 𝚞 𝚟 𝚠 𝚡 𝚢 𝚣 𝚤 𝚥 𝛂 𝛃 𝛄 𝛅 𝛆 𝛇 𝛈 𝛉 𝛊 𝛋 𝛌 𝛍 𝛎 𝛏 𝛐 𝛑 𝛒 𝛓 𝛔 𝛕 𝛖 𝛗 𝛘 𝛙 𝛚 𝛜 𝛝 𝛞 𝛟 𝛠 𝛡 𝛼 𝛽 𝛾 𝛿 𝜀 𝜁 𝜂 𝜃 𝜄 𝜅 𝜆 𝜇 𝜈 𝜉 𝜊 𝜋 𝜌 𝜍 𝜎 𝜏 𝜐 𝜑 𝜒 𝜓 𝜔 𝜖 𝜗 𝜘 𝜙 𝜚 𝜛 𝜶 𝜷 𝜸 𝜹 𝜺 𝜻 𝜼 𝜽 𝜾 𝜿 𝝀 𝝁 𝝂 𝝃 𝝄 𝝅 𝝆 𝝇 𝝈 𝝉 𝝊 𝝋 𝝌 𝝍 𝝎 𝝐 𝝑 𝝒 𝝓 𝝔 𝝕 𝝰 𝝱 𝝲 𝝳 𝝴 𝝵 𝝶 𝝷 𝝸 𝝹 𝝺 𝝻 𝝼 𝝽 𝝾 𝝿 𝞀 𝞁 𝞂 𝞃 𝞄 𝞅 𝞆 𝞇 𝞈 𝞊 𝞋 𝞌 𝞍 𝞎 𝞏 𝞪 𝞫 𝞬 𝞭 𝞮 𝞯 𝞰 𝞱 𝞲 𝞳 𝞴 𝞵 𝞶 𝞷 𝞸 𝞹 𝞺 𝞻 𝞼 𝞽 𝞾 𝞿 𝟀 𝟁 𝟂 𝟄 𝟅 𝟆 𝟇 𝟈 𝟉 𝟋
Uppercase: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö Ø Ù Ú Û Ü Ý Þ Ā Ă Ą Ć Ĉ Ċ Č Ď Đ Ē Ĕ Ė Ę Ě Ĝ Ğ Ġ Ģ Ĥ Ħ Ĩ Ī Ĭ Į İ IJ Ĵ Ķ Ĺ Ļ Ľ Ŀ Ł Ń Ņ Ň Ŋ Ō Ŏ Ő Œ Ŕ Ŗ Ř Ś Ŝ Ş Š Ţ Ť Ŧ Ũ Ū Ŭ Ů Ű Ų Ŵ Ŷ Ÿ Ź Ż Ž Ɓ Ƃ Ƅ Ɔ Ƈ Ɖ Ɗ Ƌ Ǝ Ə Ɛ Ƒ Ɠ Ɣ Ɩ Ɨ Ƙ Ɯ Ɲ Ɵ Ơ Ƣ Ƥ Ʀ Ƨ Ʃ Ƭ Ʈ Ư Ʊ Ʋ Ƴ Ƶ Ʒ Ƹ Ƽ DŽ LJ NJ Ǎ Ǐ Ǒ Ǔ Ǖ Ǘ Ǚ Ǜ Ǟ Ǡ Ǣ Ǥ Ǧ Ǩ Ǫ Ǭ Ǯ DZ Ǵ Ƕ Ƿ Ǹ Ǻ Ǽ Ǿ Ȁ Ȃ Ȅ Ȇ Ȉ Ȋ Ȍ Ȏ Ȑ Ȓ Ȕ Ȗ Ș Ț Ȝ Ȟ Ƞ Ȣ Ȥ Ȧ Ȩ Ȫ Ȭ Ȯ Ȱ Ȳ Ⱥ Ȼ Ƚ Ⱦ Ɂ Ƀ Ʉ Ʌ Ɇ Ɉ Ɋ Ɍ Ɏ Ͱ Ͳ Ͷ Ά Έ Ή Ί Ό Ύ Ώ Α Β Γ Δ Ε Ζ Η Θ Ι Κ Λ Μ Ν Ξ Ο Π Ρ Σ Τ Υ Φ Χ Ψ Ω Ϊ Ϋ Ϗ ϒ ϓ ϔ Ϙ Ϛ Ϝ Ϟ Ϡ Ϣ Ϥ Ϧ Ϩ Ϫ Ϭ Ϯ ϴ Ϸ Ϲ Ϻ Ͻ Ͼ Ͽ Ѐ Ё Ђ Ѓ Є Ѕ І Ї Ј Љ Њ Ћ Ќ Ѝ Ў Џ А Б В Г Д Е Ж З И Й К Л М Н О П Р С Т У Ф Х Ц Ч Ш Щ Ъ Ы Ь Э Ю Я Ѡ Ѣ Ѥ Ѧ Ѩ Ѫ Ѭ Ѯ Ѱ Ѳ Ѵ Ѷ Ѹ Ѻ Ѽ Ѿ Ҁ Ҋ Ҍ Ҏ Ґ Ғ Ҕ Җ Ҙ Қ Ҝ Ҟ Ҡ Ң Ҥ Ҧ Ҩ Ҫ Ҭ Ү Ұ Ҳ Ҵ Ҷ Ҹ Һ Ҽ Ҿ Ӏ Ӂ Ӄ Ӆ Ӈ Ӊ Ӌ Ӎ Ӑ Ӓ Ӕ Ӗ Ә Ӛ Ӝ Ӟ Ӡ Ӣ Ӥ Ӧ Ө Ӫ Ӭ Ӯ Ӱ Ӳ Ӵ Ӷ Ӹ Ӻ Ӽ Ӿ Ԁ Ԃ Ԅ Ԇ Ԉ Ԋ Ԍ Ԏ Ԑ Ԓ Ԕ Ԗ Ԙ Ԛ Ԝ Ԟ Ԡ Ԣ Ԥ Ԧ Ա Բ Գ Դ Ե Զ Է Ը Թ Ժ Ի Լ Խ Ծ Կ Հ Ձ Ղ Ճ Մ Յ Ն Շ Ո Չ Պ Ջ Ռ Ս Վ Տ Ր Ց Ւ Փ Ք Օ Ֆ Ⴀ Ⴁ Ⴂ Ⴃ Ⴄ Ⴅ Ⴆ Ⴇ Ⴈ Ⴉ Ⴊ Ⴋ Ⴌ Ⴍ Ⴎ Ⴏ Ⴐ Ⴑ Ⴒ Ⴓ Ⴔ Ⴕ Ⴖ Ⴗ Ⴘ Ⴙ Ⴚ Ⴛ Ⴜ Ⴝ Ⴞ Ⴟ Ⴠ Ⴡ Ⴢ Ⴣ Ⴤ Ⴥ Ⴧ Ⴭ Ḁ Ḃ Ḅ Ḇ Ḉ Ḋ Ḍ Ḏ Ḑ Ḓ Ḕ Ḗ Ḙ Ḛ Ḝ Ḟ Ḡ Ḣ Ḥ Ḧ Ḩ Ḫ Ḭ Ḯ Ḱ Ḳ Ḵ Ḷ Ḹ Ḻ Ḽ Ḿ Ṁ Ṃ Ṅ Ṇ Ṉ Ṋ Ṍ Ṏ Ṑ Ṓ Ṕ Ṗ Ṙ Ṛ Ṝ Ṟ Ṡ Ṣ Ṥ Ṧ Ṩ Ṫ Ṭ Ṯ Ṱ Ṳ Ṵ Ṷ Ṹ Ṻ Ṽ Ṿ Ẁ Ẃ Ẅ Ẇ Ẉ Ẋ Ẍ Ẏ Ẑ Ẓ Ẕ ẞ Ạ Ả Ấ Ầ Ẩ Ẫ Ậ Ắ Ằ Ẳ Ẵ Ặ Ẹ Ẻ Ẽ Ế Ề Ể Ễ Ệ Ỉ Ị Ọ Ỏ Ố Ồ Ổ Ỗ Ộ Ớ Ờ Ở Ỡ Ợ Ụ Ủ Ứ Ừ Ử Ữ Ự Ỳ Ỵ Ỷ Ỹ Ỻ Ỽ Ỿ Ἀ Ἁ Ἂ Ἃ Ἄ Ἅ Ἆ Ἇ Ἐ Ἑ Ἒ Ἓ Ἔ Ἕ Ἠ Ἡ Ἢ Ἣ Ἤ Ἥ Ἦ Ἧ Ἰ Ἱ Ἲ Ἳ Ἴ Ἵ Ἶ Ἷ Ὀ Ὁ Ὂ Ὃ Ὄ Ὅ Ὑ Ὓ Ὕ Ὗ Ὠ Ὡ Ὢ Ὣ Ὤ Ὥ Ὦ Ὧ Ᾰ Ᾱ Ὰ Ά Ὲ Έ Ὴ Ή Ῐ Ῑ Ὶ Ί Ῠ Ῡ Ὺ Ύ Ῥ Ὸ Ό Ὼ Ώ ℂ ℇ ℋ ℌ ℍ ℐ ℑ ℒ ℕ ℙ ℚ ℛ ℜ ℝ ℤ Ω ℨ K Å ℬ ℭ ℰ ℱ Ⅎ ℳ ℾ ℿ ⅅ Ↄ Ⰰ Ⰱ Ⰲ Ⰳ Ⰴ Ⰵ Ⰶ Ⰷ Ⰸ Ⰹ Ⰺ Ⰻ Ⰼ Ⰽ Ⰾ Ⰿ Ⱀ Ⱁ Ⱂ Ⱃ Ⱄ Ⱅ Ⱆ Ⱇ Ⱈ Ⱉ Ⱊ Ⱋ Ⱌ Ⱍ Ⱎ Ⱏ Ⱐ Ⱑ Ⱒ Ⱓ Ⱔ Ⱕ Ⱖ Ⱗ Ⱘ Ⱙ Ⱚ Ⱛ Ⱜ Ⱝ Ⱞ Ⱡ Ɫ Ᵽ Ɽ Ⱨ Ⱪ Ⱬ Ɑ Ɱ Ɐ Ɒ Ⱳ Ⱶ Ȿ Ɀ Ⲁ Ⲃ Ⲅ Ⲇ Ⲉ Ⲋ Ⲍ Ⲏ Ⲑ Ⲓ Ⲕ Ⲗ Ⲙ Ⲛ Ⲝ Ⲟ Ⲡ Ⲣ Ⲥ Ⲧ Ⲩ Ⲫ Ⲭ Ⲯ Ⲱ Ⲳ Ⲵ Ⲷ Ⲹ Ⲻ Ⲽ Ⲿ Ⳁ Ⳃ Ⳅ Ⳇ Ⳉ Ⳋ Ⳍ Ⳏ Ⳑ Ⳓ Ⳕ Ⳗ Ⳙ Ⳛ Ⳝ Ⳟ Ⳡ Ⳣ Ⳬ Ⳮ Ⳳ Ꙁ Ꙃ Ꙅ Ꙇ Ꙉ Ꙋ Ꙍ Ꙏ Ꙑ Ꙓ Ꙕ Ꙗ Ꙙ Ꙛ Ꙝ Ꙟ Ꙡ Ꙣ Ꙥ Ꙧ Ꙩ Ꙫ Ꙭ Ꚁ Ꚃ Ꚅ Ꚇ Ꚉ Ꚋ Ꚍ Ꚏ Ꚑ Ꚓ Ꚕ Ꚗ Ꜣ Ꜥ Ꜧ Ꜩ Ꜫ Ꜭ Ꜯ Ꜳ Ꜵ Ꜷ Ꜹ Ꜻ Ꜽ Ꜿ Ꝁ Ꝃ Ꝅ Ꝇ Ꝉ Ꝋ Ꝍ Ꝏ Ꝑ Ꝓ Ꝕ Ꝗ Ꝙ Ꝛ Ꝝ Ꝟ Ꝡ Ꝣ Ꝥ Ꝧ Ꝩ Ꝫ Ꝭ Ꝯ Ꝺ Ꝼ Ᵹ Ꝿ Ꞁ Ꞃ Ꞅ Ꞇ Ꞌ Ɥ Ꞑ Ꞓ Ꞡ Ꞣ Ꞥ Ꞧ Ꞩ Ɦ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 𐐀 𐐁 𐐂 𐐃 𐐄 𐐅 𐐆 𐐇 𐐈 𐐉 𐐊 𐐋 𐐌 𐐍 𐐎 𐐏 𐐐 𐐑 𐐒 𐐓 𐐔 𐐕 𐐖 𐐗 𐐘 𐐙 𐐚 𐐛 𐐜 𐐝 𐐞 𐐟 𐐠 𐐡 𐐢 𐐣 𐐤 𐐥 𐐦 𐐧 𝐀 𝐁 𝐂 𝐃 𝐄 𝐅 𝐆 𝐇 𝐈 𝐉 𝐊 𝐋 𝐌 𝐍 𝐎 𝐏 𝐐 𝐑 𝐒 𝐓 𝐔 𝐕 𝐖 𝐗 𝐘 𝐙 𝐴 𝐵 𝐶 𝐷 𝐸 𝐹 𝐺 𝐻 𝐼 𝐽 𝐾 𝐿 𝑀 𝑁 𝑂 𝑃 𝑄 𝑅 𝑆 𝑇 𝑈 𝑉 𝑊 𝑋 𝑌 𝑍 𝑨 𝑩 𝑪 𝑫 𝑬 𝑭 𝑮 𝑯 𝑰 𝑱 𝑲 𝑳 𝑴 𝑵 𝑶 𝑷 𝑸 𝑹 𝑺 𝑻 𝑼 𝑽 𝑾 𝑿 𝒀 𝒁 𝒜 𝒞 𝒟 𝒢 𝒥 𝒦 𝒩 𝒪 𝒫 𝒬 𝒮 𝒯 𝒰 𝒱 𝒲 𝒳 𝒴 𝒵 𝓐 𝓑 𝓒 𝓓 𝓔 𝓕 𝓖 𝓗 𝓘 𝓙 𝓚 𝓛 𝓜 𝓝 𝓞 𝓟 𝓠 𝓡 𝓢 𝓣 𝓤 𝓥 𝓦 𝓧 𝓨 𝓩 𝔄 𝔅 𝔇 𝔈 𝔉 𝔊 𝔍 𝔎 𝔏 𝔐 𝔑 𝔒 𝔓 𝔔 𝔖 𝔗 𝔘 𝔙 𝔚 𝔛 𝔜 𝔸 𝔹 𝔻 𝔼 𝔽 𝔾 𝕀 𝕁 𝕂 𝕃 𝕄 𝕆 𝕊 𝕋 𝕌 𝕍 𝕎 𝕏 𝕐 𝕬 𝕭 𝕮 𝕯 𝕰 𝕱 𝕲 𝕳 𝕴 𝕵 𝕶 𝕷 𝕸 𝕹 𝕺 𝕻 𝕼 𝕽 𝕾 𝕿 𝖀 𝖁 𝖂 𝖃 𝖄 𝖅 𝖠 𝖡 𝖢 𝖣 𝖤 𝖥 𝖦 𝖧 𝖨 𝖩 𝖪 𝖫 𝖬 𝖭 𝖮 𝖯 𝖰 𝖱 𝖲 𝖳 𝖴 𝖵 𝖶 𝖷 𝖸 𝖹 𝗔 𝗕 𝗖 𝗗 𝗘 𝗙 𝗚 𝗛 𝗜 𝗝 𝗞 𝗟 𝗠 𝗡 𝗢 𝗣 𝗤 𝗥 𝗦 𝗧 𝗨 𝗩 𝗪 𝗫 𝗬 𝗭 𝘈 𝘉 𝘊 𝘋 𝘌 𝘍 𝘎 𝘏 𝘐 𝘑 𝘒 𝘓 𝘔 𝘕 𝘖 𝘗 𝘘 𝘙 𝘚 𝘛 𝘜 𝘝 𝘞 𝘟 𝘠 𝘡 𝘼 𝘽 𝘾 𝘿 𝙀 𝙁 𝙂 𝙃 𝙄 𝙅 𝙆 𝙇 𝙈 𝙉 𝙊 𝙋 𝙌 𝙍 𝙎 𝙏 𝙐 𝙑 𝙒 𝙓 𝙔 𝙕 𝙰 𝙱 𝙲 𝙳 𝙴 𝙵 𝙶 𝙷 𝙸 𝙹 𝙺 𝙻 𝙼 𝙽 𝙾 𝙿 𝚀 𝚁 𝚂 𝚃 𝚄 𝚅 𝚆 𝚇 𝚈 𝚉 𝚨 𝚩 𝚪 𝚫 𝚬 𝚭 𝚮 𝚯 𝚰 𝚱 𝚲 𝚳 𝚴 𝚵 𝚶 𝚷 𝚸 𝚹 𝚺 𝚻 𝚼 𝚽 𝚾 𝚿 𝛀 𝛢 𝛣 𝛤 𝛥 𝛦 𝛧 𝛨 𝛩 𝛪 𝛫 𝛬 𝛭 𝛮 𝛯 𝛰 𝛱 𝛲 𝛳 𝛴 𝛵 𝛶 𝛷 𝛸 𝛹 𝛺 𝜜 𝜝 𝜞 𝜟 𝜠 𝜡 𝜢 𝜣 𝜤 𝜥 𝜦 𝜧 𝜨 𝜩 𝜪 𝜫 𝜬 𝜭 𝜮 𝜯 𝜰 𝜱 𝜲 𝜳 𝜴 𝝖 𝝗 𝝘 𝝙 𝝚 𝝛 𝝜 𝝝 𝝞 𝝟 𝝠 𝝡 𝝢 𝝣 𝝤 𝝥 𝝦 𝝧 𝝨 𝝩 𝝪 𝝫 𝝬 𝝭 𝝮 𝞐 𝞑 𝞒 𝞓 𝞔 𝞕 𝞖 𝞗 𝞘 𝞙 𝞚 𝞛 𝞜 𝞝 𝞞 𝞟 𝞠 𝞡 𝞢 𝞣 𝞤 𝞥 𝞦 𝞧 𝞨 𝟊
Line 707 ⟶ 1,331:
Both versions will work correctly on an ASCII or EBCDIC system.
===non-spaced list===
<langsyntaxhighlight lang="rexx">/*REXX program determines what characters are lowercase and uppercase (Latin) letters.*/
$L= /*set lowercase alphabet string to null*/
$U= /* " uppercase " " " " */
Line 718 ⟶ 1,342:
say ' lowercase letters: ' $L /*display all the lowercase letters. */
say ' uppercase letters: ' $U /* " " " uppercase " */
/*stick a fork in it, we're all done. */</langsyntaxhighlight>
'''output'''
<pre>
Line 726 ⟶ 1,350:
 
===a spaced list===
<langsyntaxhighlight lang="rexx">/*REXX program determines what characters are lowercase and uppercase (Latin) letters.*/
$L= /*set lowercase alphabet string to null*/
$U= /* " uppercase " " " " */
Line 737 ⟶ 1,361:
say ' lowercase letters: ' $L /*display all the lowercase letters. */
say ' uppercase letters: ' $U /* " " " uppercase " */
/*stick a fork in it, we're all done. */</langsyntaxhighlight>
'''output'''
<pre>
Line 745 ⟶ 1,369:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring"># Project : Idiomatically determine all the lowercase and uppercase letters
 
aList = "a":"z"
Line 757 ⟶ 1,381:
for n=1 to len(aList)
see aList[n]
next</langsyntaxhighlight>
Output:
Lower case : abcdefghijklmnopqrstuvwxyz
Upper case : ABCDEFGHIJKLMNOPQRSTUVWXYZ
 
=={{header|RPL}}==
RPL use a proprietary set of 8-bit characters, which coding system matches with ASCII from space (ASCII 32) to tilde (ASCII 126).
≪ "" "A" NUM "Z" NUM '''FOR''' c c CHR + '''NEXT'''
"" "a" NUM "z" NUM '''FOR''' c c CHR + '''NEXT'''
≫ EVAL
{{out}}
<pre>
2: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1: "abcdefghijklmnopqrstuvwxyz"
</pre>
 
=={{header|Ruby}}==
 
<langsyntaxhighlight Rubylang="ruby">puts "Lowercase:", [*"a".."z"].join, "Uppercase:", [*"A".."Z"].join</langsyntaxhighlight>
{{Out}}<pre>
Lowercase:
Line 773 ⟶ 1,408:
 
=={{header|Rust}}==
<langsyntaxhighlight Rustlang="rust">fn main() {
println!(
let small_a_as_u8= 'a' as u8;
"Lowercase letters: {}",
let small_z_as_u8= 'z' as u8;
(b'a'..=b'z').map(|c| c as char).collect::<String>()
let capital_a_as_u8= 'A' as u8;
);
let capital_z_as_u8= 'Z' as u8;
println!(
print!( "LowercaseUppercase letters: {}");,
(b'A'..=b'Z').map(|c| c as char).collect::<String>()
for small_letter in small_a_as_u8..small_z_as_u8+1 {
);
print!("{}", small_letter as char);
}
print!("\n");
print!("Uppercase letters: ");
for capital_letter in capital_a_as_u8..capital_z_as_u8+1 {
print!("{}", capital_letter as char);
}
}
</syntaxhighlight>
</lang>
 
{{Out}}<pre>
Lowercase letters: abcdefghijklmnopqrstuvwxyz
Uppercase letters: ABCDEFGHIJKLMNOPQRSTUVWXYZ
</pre>
 
=={{header|S-BASIC}}==
S-BASIC has been implemented only for computers using the Z80 CPU and the CP/M operating system and only
supports the ASCII character set. In S-BASIC, CHAR is equivalent to BYTE, and variables declared as such
may be treated in most contexts simply as small integers, avoiding the need to use conversion functions
such as ASC() and CHR$() needed in many other BASIC dialects (though S-BASIC does support them also).
<syntaxhighlight lang = "BASIC")>
var c = byte
print "Upper Case: ";
for c = 'A' to 'Z'
print c;
next c
print
print "Lower Case: ";
for c = 'a' to 'z'
print c;
next c
print
 
end
</syntaxhighlight>
{{out}}
<pre>
Upper Case: ABCDEFGHIJKLMNOPQRSTUVWXYZ
Lower Case: abcdefghijklmnopqrstuvwxyz
</pre>
 
=={{header|Scala}}==
{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/p0kJmlW/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/EkNsvoHyREG2izH4GcKiuQ Scastie (remote JVM)].
<langsyntaxhighlight Scalalang="scala">object IdiomaticallyDetermineLowercaseUppercase extends App {
 
println("Upper case: "
Line 808 ⟶ 1,461:
+ (0 to 0x10FFFF).map(_.toChar).filter(_.isLower).take(72).mkString + "...")
 
}</langsyntaxhighlight>
 
=={{header|Tcl}}==
Tcl has supported the Basic Multilingual Plane of Unicode since Tcl 8.1.
<langsyntaxhighlight lang="tcl">for {set c 0} {$c <= 0xffff} {incr c} {
set ch [format "%c" $c]
if {[string is upper $ch]} {lappend upper $ch}
Line 818 ⟶ 1,471:
}
puts "Upper: $upper"
puts "Lower: $lower"</langsyntaxhighlight>
{{out}}
<pre>
Line 827 ⟶ 1,480:
=={{header|Wren}}==
Wren doesn't have a separate character class but it is easy enough to generate the lower and upper case Latin alphabet from the raw bytes.
<langsyntaxhighlight ecmascriptlang="wren">for (i in 97..122) System.write(String.fromByte(i))
System.print()
for (i in 65..90) System.write(String.fromByte(i))
System.print()</langsyntaxhighlight>
 
{{out}}
Line 836 ⟶ 1,489:
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
</pre>
 
=={{header|XBS}}==
<syntaxhighlight lang="xbs">func printChars(from,to,st){
set arr=[];
for(c=from;to;1){
arr->push(string.byte(c));
}
log(st," ",arr);
del arr;
}
 
printChars(0x61,0x7a,"lowercase");
printChars(0x41,0x5a,"UPPERCASE");</syntaxhighlight>
{{out}}
<pre>
lowercase a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z
UPPERCASE A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">char C;
[for C:= 0 to 255 do
if C >=^a & C<=^z then ChOut(0, C);
CrLf(0);
for C:= 0 to 255 do
if C >=^A & C<=^Z then ChOut(0, C);
CrLf(0);
]</syntaxhighlight>
 
{{out}}
<pre>
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
</pre>
 
=={{header|Z80 Assembly}}==
 
Code is left unoptimized (but valid) for clarity.
<syntaxhighlight lang="z80">printChar equ &bb5a ;amstrad cpc bios call, prints the ascii code in accumulator to screen and increments text cursor.
org &8000
 
ld a,'A'
 
UpperLoop:
call PrintChar ;print accumulator
inc a ;next letter
cp 'Z'+1 ;is it whatever comes after Z?
jr nz,upperLoop ;if not, print the next letter
 
ld a,'a'
 
LowerLoop:
call PrintChar
inc a
cp 'z'+1
jr nz,LowerLoop
 
ret ;return to basic</syntaxhighlight>
 
{{out}}
<pre>
Ready
call &8000
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn
opqrstuvwxyz
</pre>
 
=={{header|ZX Spectrum Basic}}==
<langsyntaxhighlight lang="zxbasic">10 FOR x=CODE "a" TO CODE "z"
20 PRINT CHR$ x;
30 NEXT x
Line 845 ⟶ 1,564:
50 FOR x=CODE "A" TO CODE "Z"
60 PRINT CHR$ x;
70 NEXT x</langsyntaxhighlight>
{{out}}
<pre>abcdefghijklmnopqrstuvwxyz
9,476

edits