Idiomatically determine all the lowercase and uppercase letters: Difference between revisions
Idiomatically determine all the lowercase and uppercase letters (view source)
Revision as of 11:09, 10 December 2023
, 5 months ago→{{header|Wren}}: Changed to Wren S/H
Drkameleon (talk | contribs) (Added Arturo implementation) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
(32 intermediate revisions by 21 users not shown) | |||
Line 27:
{{trans|Kotlin}}
<
L(ch) ‘a’..‘z’
print(ch, end' ‘’)
Line 34:
L(ch) ‘A’..‘Z’
print(ch, end' ‘’)
print()</
{{out}}
Line 40:
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;
Line 62 ⟶ 205:
New_Line;
end Main;
</syntaxhighlight>
{{Output}}
<pre>
Line 72 ⟶ 215:
{{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.
<
STRING uc := "";
FOR c FROM 0 TO max abs char DO
Line 80 ⟶ 223:
OD;
print( ( "lower: """ + lc + """", newline ) );
print( ( "upper: """ + uc + """", newline ) )</
{{out}}
<pre>
Line 89 ⟶ 232:
=={{header|Arturo}}==
<
print ["uppercase letters:" `A`..`Z`]</
{{out}}
Line 98 ⟶ 241:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f IDIOMATICALLY_DETERMINE_ALL_THE_LOWERCASE_AND_UPPERCASE_LETTERS.AWK
BEGIN {
Line 115 ⟶ 258:
exit(0)
}
</syntaxhighlight>
<p>output using Microsoft Windows 8 version 6.2.9200 with code page 437 in a DOS window</p>
<pre>
Line 126 ⟶ 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}}==
<
int main(int argc, char const *argv[]) {
Line 136 ⟶ 402:
putchar('\n');
return 0;
}</
{{out}}
<pre>
Line 151 ⟶ 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.
<
program-id. determine.
Line 228 ⟶ 494:
goback.
end program determine.</
{{out}}
Line 237 ⟶ 503:
=={{header|Common Lisp}}==
<
(flet ((do-case (converter)
;; A = 10, B = 11, ... Z = 35
Line 248 ⟶ 514:
;; Using a local function reduces code duplication
(do-case #'char-downcase) (do-case #'char-upcase))
</syntaxhighlight>
{{out}}
<
;;; Code Full Name Appearance
97 #\LATIN_SMALL_LETTER_A #\a
Line 305 ⟶ 571:
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;
Line 344 ⟶ 625:
writeln('...');
readln;
end.</
{{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#}}==
<
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>
{{out}}
<pre>
Line 361 ⟶ 654:
=={{header|Factor}}==
<
USE: math.ranges
CHAR: A CHAR: Z [a,b] >string print
CHAR: a CHAR: z [a,b] >string print
</syntaxhighlight>
{{out}}
<pre>
Line 373 ⟶ 666:
=={{header|FreeBASIC}}==
<
LOWER = -1, UPPER = 1, NOTLETTER = 0
end enum
Line 393 ⟶ 686:
if letter_case(chr(i)) = UPPER then print chr(i);
next i
print</
{{out}}
<pre>
Line 399 ⟶ 692:
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.
<
import (
Line 458 ⟶ 768:
fmt.Println()
}
}</
{{Out}}
<pre>
Line 513 ⟶ 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.
<
putStrLn $ "Upper: " ++ ['A'..'Z']</
{{out}}
<pre>Lower: abcdefghijklmnopqrstuvwxyz
Line 520 ⟶ 830:
And if we want to generalise a little beyond a narrowly Anglo-Saxon notion of
<syntaxhighlight lang="haskell">import Control.Monad (join)
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
(
( partition
isUpper
( ((bool [] . pure) <*> isPrint) . chr
=<< [1 .. 0x10ffff]
)
)
--------------------------- TEST -------------------------
main :: IO ()
main =
bimap
("Upper:" :)
("\nLower:" :)
$ join bimap (chunksOf 70) uppersAndLowers</syntaxhighlight>
{{Out}}
<pre>Upper:
Line 590 ⟶ 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 597 ⟶ 947:
That said:
<
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz</
Note that, as hinted at above, we get the same result using UCS-2:
<
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz</
=={{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}}
<
public class Letters {
Line 625 ⟶ 994:
System.out.println("...");
}
}</
<pre>Upper case: ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞĀĂĄĆĈĊČĎĐĒĔĖĘĚĜĞ...
Line 634 ⟶ 1,003:
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.
<
# "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);</
'''The number of lowercase Unicode characters:'''
<
generate("Ll"; 0; maxu) | length #=> 1607</
'''The number of uppercase Unicode characters:'''
<
'''Examples''':
Lowercase letters amongst the first 1024 Unicode codepoints:
<
{{out}}
<syntaxhighlight lang
Uppercase letters amongst the first 1024 Unicode codepoints:
<
{{Out}}
<syntaxhighlight lang
=={{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.
<
function countunicode()
englishlettercodes = [Int(c) for c in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"]
Line 690 ⟶ 1,059:
println("lowercase: $lcletters and uppercase: $ucletters.")
</syntaxhighlight>
{{output}}
There are 267753 valid Chars and the English ones are lowercase: abcdefghijklmnopqrstuvwxyz and uppercase: ABCDEFGHIJKLMNOPQRSTUVWXYZ.
=={{header|Kotlin}}==
<
fun main(args: Array<String>) {
Line 703 ⟶ 1,072:
for (ch in 'A'..'Z') print(ch)
println()
}</
{{out}}
Line 713 ⟶ 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.
<
local matchString, ch = ""
for charNum = 0, 255 do
Line 726 ⟶ 1,095:
print(ASCIIstring("%l"))
print(ASCIIstring("%u"))
</syntaxhighlight>
{{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:
<
for i in seq.indexes
seq[i] = char(seq[i])
Line 741 ⟶ 1,128:
print toChars(range(code("a"), code("z")))
print toChars(range(code("A"), code("Z")))</
{{out}}
Line 750 ⟶ 1,137:
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.
The following program displays the lowercase and uppercase ASCII letters.
<syntaxhighlight lang="nim">import sequtils, strutils
echo "Lowercase characters:"
Line 758 ⟶ 1,147:
echo ""
echo "Uppercase characters:"
echo toSeq('A'..'Z').join()</
{{out}}
Line 769 ⟶ 1,158:
=={{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
<
Upper ASCII (not to be confused with ISO Latin-1) has the following letters:
<
=={{header|Perl}}==
<syntaxhighlight lang
use utf8;
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:]]/;
}
{{out}}
<pre>abcdefghijklmnopqrstuvwxyzªµºßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ
ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ</pre>
=={{header|Phix}}==
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)-->
<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>
<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>
<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>
<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>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<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>
<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>
<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>
<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 818 ⟶ 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.
=={{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.
<
str.isdigit, str.isidentifier, str.isnumeric, str.isprintable,
str.isspace, str.istitle)
Line 832 ⟶ 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]))</
{{out}}
Line 867 ⟶ 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].
<
(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))</
{{out}}
Line 885 ⟶ 1,284:
=={{header|Prolog}}==
<
findall(Lower, maplist(char_type(Lower), [alpha, ascii, lower]), Lowers),
Line 894 ⟶ 1,293:
findall(Upper, maplist(char_type(Upper), [alpha, ascii, upper]), Uppers),
writeln('-- Upper Case Characters --'),
writeln(Uppers).</
{{out}}
<pre>
Line 907 ⟶ 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"
say "Lowercase: ", .comb(/<:Ll>/);
say "Uppercase: ", .comb(/<:Lu>/);
say "Titlecase: ", .comb(/<:Lt>/);
}</
<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 923 ⟶ 1,331:
Both versions will work correctly on an ASCII or EBCDIC system.
===non-spaced list===
<
$L= /*set lowercase alphabet string to null*/
$U= /* " uppercase " " " " */
Line 934 ⟶ 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. */</
'''output'''
<pre>
Line 942 ⟶ 1,350:
===a spaced list===
<
$L= /*set lowercase alphabet string to null*/
$U= /* " uppercase " " " " */
Line 953 ⟶ 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. */</
'''output'''
<pre>
Line 961 ⟶ 1,369:
=={{header|Ring}}==
<
aList = "a":"z"
Line 973 ⟶ 1,381:
for n=1 to len(aList)
see aList[n]
next</
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}}==
<
{{Out}}<pre>
Lowercase:
Line 989 ⟶ 1,408:
=={{header|Rust}}==
<
println!(
"Lowercase letters: {}",
(b'a'..=b'z').map(|c| c as char).collect::<String>()
);
println!(
(b'A'..=b'Z').map(|c| c as char).collect::<String>()
);
}
</syntaxhighlight>
{{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)].
<
println("Upper case: "
Line 1,024 ⟶ 1,461:
+ (0 to 0x10FFFF).map(_.toChar).filter(_.isLower).take(72).mkString + "...")
}</
=={{header|Tcl}}==
Tcl has supported the Basic Multilingual Plane of Unicode since Tcl 8.1.
<
set ch [format "%c" $c]
if {[string is upper $ch]} {lappend upper $ch}
Line 1,034 ⟶ 1,471:
}
puts "Upper: $upper"
puts "Lower: $lower"</
{{out}}
<pre>
Line 1,043 ⟶ 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.
<
System.print()
for (i in 65..90) System.write(String.fromByte(i))
System.print()</
{{out}}
Line 1,052 ⟶ 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}}==
<
[for C:= 0 to 255 do
if C >=^a & C<=^z then ChOut(0, C);
Line 1,062 ⟶ 1,517:
if C >=^A & C<=^Z then ChOut(0, C);
CrLf(0);
]</
{{out}}
Line 1,068 ⟶ 1,523:
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}}==
<
20 PRINT CHR$ x;
30 NEXT x
Line 1,077 ⟶ 1,564:
50 FOR x=CODE "A" TO CODE "Z"
60 PRINT CHR$ x;
70 NEXT x</
{{out}}
<pre>abcdefghijklmnopqrstuvwxyz
|