Generate lower case ASCII alphabet
Generate an array, list, lazy sequence, or even an indexable string of all the lower case ASCII characters, from a to z. If the standard library contains such a sequence, show how to access it, but don't fail to show how to generate a similar sequence.
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
For this basic task use a reliable style of coding, a style fit for a very large program, and use strong typing if available. It's bug prone to enumerate all the lowercase characters manually in the code. During code review it's not immediate obvious to spot the bug in a Tcl line like this contained in a page of code:
<lang tcl>set alpha {a b c d e f g h i j k m n o p q r s t u v w x y z}</lang>
0815
This creates the list in the queue <lang 0815><:61:~}:000:>>&{~<:7a:-#:001:<:1:+^:000:</lang>
360 Assembly
In EBCDIC coding there are more than 24 characters between a and z. So we have to get rid of characters between i and j and also between r and s. <lang 360asm>* Generate lower case alphabet - 15/10/2015 LOWER CSECT
USING LOWER,R15 set base register LA R7,PG pgi=@pg SR R6,R6 clear IC R6,=C'a' char='a' BCTR R6,0 char=char-1
LOOP LA R6,1(R6) char=char+1
STC R6,CHAR CLI CHAR,C'i' if char>'i' BNH OK CLI CHAR,C'j' and char<'j' BL SKIP then skip CLI CHAR,C'r' if char>'r' BNH OK CLI CHAR,C's' and char<'s' BL SKIP then skip
OK MVC 0(1,R7),CHAR output char
LA R7,1(R7) pgi=pgi+1
SKIP CLI CHAR,C'z' if char='z'
BNE LOOP loop XPRNT PG,26 print buffer XR R15,R15 set return code BR R14 return to caller
CHAR DS C character PG DS CL26 buffer
YREGS END LOWER</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
6502 Assembly
Stores the lower-case ASCII alphabet as a null-terminated string beginning at address 2000 hex. Register contents are preserved. <lang asm6502>ASCLOW: PHA ; push contents of registers that we
TXA ; shall be using onto the stack PHA LDA #$61 ; ASCII "a" LDX #$00
ALLOOP: STA $2000,X
INX CLC ADC #$01 CMP #$7B ; have we got beyond ASCII "z"? BNE ALLOOP LDA #$00 ; terminate the string with ASCII NUL STA $2000,X PLA ; retrieve register contents from TAX ; the stack PLA RTS ; return</lang>
8th
We take an empty string, and use the "loop" word to create a new character using "'a n:+". The loop passes the current index to the code being iterated, so it starts with 0 and up to 25, adding to the "'a" - which is the numeric value of lowercase "a", and the resultant number is then appended to the string. That converts the number to the appropriate character and appends it: <lang forth> "" ( 'a n:+ s:+ ) 0 25 loop . cr </lang>
- Output:
abcdefghijklmnopqrstuvwxyz
ABAP
<lang ABAP>DATA(alpha) = to_lower( sy-abcde ).</lang>
Ada
We start with a strong type definition: A character range that can only hold lower-case letters:
<lang Ada> type Lower_Case is new Character range 'a' .. 'z';</lang>
Now we define an array type and initialize the Array A of that type with the 26 letters: <lang Ada> type Arr_Type is array (Integer range <>) of Lower_Case;
A : Arr_Type (1 .. 26) := "abcdefghijklmnopqrstuvwxyz";</lang>
Strong typing would catch two errors: (1) any upper-case letters or other symbols in the string assigned to A, and (2) too many or too few letters assigned to A. However, a letter might still appear twice (or more) in A, at the cost of one or more other letters. Array B is safe even against such errors:
<lang Ada> B : Arr_Type (1 .. 26); begin
B(B'First) := 'a'; for I in B'First .. B'Last-1 loop B(I+1) := Lower_Case'Succ(B(I)); end loop; -- now all the B(I) are different</lang>
ALGOL 68
<lang algol68> # in ALGOL 68, a STRING is an array of characters with flexible bounds #
# so we can declare an array of 26 characters and assign a string # # containing the lower-case letters to it #
[ 26 ]CHAR lc := "abcdefghijklmnopqrstuvwxyz"
</lang> Alternative version <lang algol68> # fills lc with the 26 lower-case letters, assuming that #
# they are consecutive in the character set, as they are in ASCII #
[ 26 ]CHAR lc;
FOR i FROM LWB lc TO UPB lc DO lc[ i ] := REPR ( ABS "a" + ( i - 1 ) ) OD</lang>
APL
<lang apl> ⎕UCS 96+⍳26</lang>
AppleScript
<lang AppleScript>-- showCharRange :: String -> String -> [String] on showCharRange(strFrom, strTo)
-- showChar :: Int -> String script showChar on lambda(intID) character id intID end lambda end script map(showChar, range(id of strFrom, id of strTo))
end showCharRange
-- TEST
on run
{showCharRange("a", "z"), ¬ showCharRange("🐐", "🐟")}
end run
-- GENERIC FUNCTIONS
-- map :: (a -> b) -> [a] -> [b] on map(f, xs)
set mf to mReturn(f) set lng to length of xs set lst to {} repeat with i from 1 to lng set end of lst to mf's lambda(item i of xs, i, xs) end repeat return lst
end map
-- range :: Int -> Int -> [Int] on range(m, n)
if n < m then set d to -1 else set d to 1 end if set lst to {} repeat with i from m to n by d set end of lst to i end repeat return lst
end range
-- Lift 2nd class handler function into 1st class script wrapper -- mReturn :: Handler -> Script on mReturn(f)
if class of f is script then f else script property lambda : f end script end if
end mReturn</lang>
- Output:
{{"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"}, {"🐐", "🐑", "🐒", "🐓", "🐔", "🐕", "🐖", "🐗", "🐘", "🐙", "🐚", "🐛", "🐜", "🐝", "🐞", "🐟"}}
Applesoft BASIC
<lang ApplesoftBasic>L$="abcdefghijklmnopqrstuvwxyz"</lang> On the older model Apple II and Apple II plus, it is difficult to enter lower case characters. The following code generates the same string: <lang ApplesoftBasic>L$="":FORI=1TO26:L$=L$+CHR$(96+I):NEXT</lang>
ATS
<lang ATS> (* ****** ****** *) // // How to compile: // // patscc -DATS_MEMALLOC_LIBC -o lowercase lowercase.dats // (* ****** ****** *) //
- include
"share/atspre_staload.hats" // (* ****** ****** *)
implement main0 () = { // val N = 26 // val A = arrayref_tabulate_cloref<char> (
i2sz(N), lam(i) => int2char0(char2int0('a') + sz2i(i))
) (* end of [val] *) // } (* end of [main0] *) </lang>
AutoHotkey
<lang AutoHotkey>a :={} Loop, 26 a.Insert(Chr(A_Index + 96))</lang>
AutoIt
<lang AutoIt> Func _a2z() Local $a2z = "" For $i = 97 To 122 $a2z &= Chr($i) Next Return $a2z EndFunc </lang>
AWK
Generate all character codes, and test each one if it matches the POSIX character class for "lowercase".
Note this is dependent on the locale-setting, and options, e.g. --traditional and --posix <lang AWK>
- syntax: GAWK -f GENERATE_LOWER_CASE_ASCII_ALPHABET.AWK
BEGIN {
for (i=0; i<=255; i++) { c = sprintf("%c",i) if (c ~ /lower:/) { lower_chars = lower_chars c } } printf("%s %d: %s\n",ARGV[0],length(lower_chars),lower_chars) exit(0)
} </lang>
- Output:
gawk_3_1_8 26: abcdefghijklmnopqrstuvwxyz gawk_4_1_0 65: abcdefghijklmnopqrstuvwxyzƒsozªµºßàáâaäåæçèéêëìíîïdñòóôoöoùúûüy_ÿ
BBC BASIC
<lang bbcbasic> DIM lower&(25)
FOR i%=0TO25 lower&(i%)=ASC"a"+i% NEXT END</lang>
Befunge
The left hand side pushes the sequence 'a' to 'z' onto the stack in reverse order with a null terminator (a fairly typical Befunge pattern). The right hand side is just printing it out again to test. <lang Befunge>0"z":>"a"`#v_ >:#,_$@
^:- 1:<</lang>
Bracmat
<lang bracmat> a:?seq:?c & whl
' ( chr$(asc$!c+1):~>z:?c & !seq !c:?seq )
& !seq</lang>
C
<lang c>#include <stdlib.h>
- define N 26
int main() {
unsigned char lower[N];
for (size_t i = 0; i < N; i++) { lower[i] = i + 'a'; }
return EXIT_SUCCESS;
} </lang>
C++
C++ can do the task in the identical way as C, or else, it can use a STL function.
<lang cpp>#include <string>
- include <numeric>
int main() {
std::string lower(26,' ');
std::iota(lower.begin(), lower.end(), 'a');
}</lang>
C#
<lang csharp>namespace RosettaCode.GenerateLowerCaseASCIIAlphabet {
using System; using System.Collections.Generic;
internal class Program { private static IEnumerable<char> Alphabet { get { for (var character = 'a'; character <= 'z'; character++) { yield return character; } } }
private static void Main() { Console.WriteLine(string.Join(string.Empty, Alphabet)); } }
}</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
Clojure
<lang clojure>(map char (range (int \a) (inc (int \z))))</lang>
- Output:
(\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)
COBOL
Strings in COBOL are mutable and can be subscripted: each time we go round the loop, we assign to a one-character-long section of the string we are building. <lang cobol>identification division. program-id. lower-case-alphabet-program. data division. working-storage section. 01 ascii-lower-case.
05 lower-case-alphabet pic a(26). 05 character-code pic 999. 05 loop-counter pic 99.
procedure division. control-paragraph.
perform add-next-letter-paragraph varying loop-counter from 1 by 1 until loop-counter is greater than 26. display lower-case-alphabet upon console. stop run.
add-next-letter-paragraph.
add 97 to loop-counter giving character-code. move function char(character-code) to lower-case-alphabet(loop-counter:1).</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
CoffeeScript
<lang coffeescript> (String.fromCharCode(x) for x in [97..122]) </lang>
Common Lisp
<lang lisp>(defvar *lower*
(loop with a = (char-code #\a) for i upto 25 collect (code-char (+ a i))))</lang>
D
The lower case ASCII letters of the Phobos standard library: <lang d>import std.ascii: lowercase;
void main() {}</lang>
The generation of the ASCII alphabet array: <lang d>void main() {
char['z' - 'a' + 1] arr;
foreach (immutable i, ref c; arr) c = 'a' + i;
}</lang>
An alternative version: <lang d>void main() {
import std.range, std.algorithm, std.array;
char[26] arr = 26.iota.map!(i => cast(char)('a' + i)).array;
}</lang> Another version: <lang d>void main() {
char[] arr;
foreach (immutable char c; 'a' .. 'z' + 1) arr ~= c;
assert(arr == "abcdefghijklmnopqrstuvwxyz");
}</lang>
Delphi
<lang delphi>program atoz;
var
ch : char;
begin
for ch in ['a'..'z'] do begin write(ch); end;
end.</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
EchoLisp
<lang scheme>
- 1)
(define \a (first (string->unicode "a"))) (for/list ((i 25)) (unicode->string (+ i \a)))
→ (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)
- 2) using a sequence
(lib 'sequences)
(take ["a" .. "z"] 26)
→ (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)
- or
(for/string ((letter ["a" .. "z"])) letter)
→ abcdefghijklmnopqrstuvwxyz
</lang>
Elixir
<lang elixir>iex(1)> Enum.to_list(?a .. ?z) 'abcdefghijklmnopqrstuvwxyz' iex(2)> Enum.to_list(?a .. ?z) |> List.to_string "abcdefghijklmnopqrstuvwxyz"</lang>
Erlang
<lang erlang>lists:seq($a,$z).</lang>
- Output:
"abcdefghijklmnopqrstuvwxyz"
F#
<lang fsharp>let lower = ['a'..'z']
printfn "%A" lower</lang>
Factor
Strings are represented as fixed-size mutable sequences of Unicode code points.
<lang factor>USING: spelling ; ! ALPHABET
ALPHABET print 0x61 0x7A [a,b] >string print
- russian-alphabet-without-io ( -- str ) 0x0430 0x0450 [a,b) >string ;
- russian-alphabet ( -- str ) 0x0451 6 russian-alphabet-without-io insert-nth ;
russian-alphabet print</lang>
- Output:
abcdefghijklmnopqrstuvwxyz abcdefghijklmnopqrstuvwxyz абвгдеёжзийклмнопрстуфхцчшщъыьэюя
Forth
Generate a string filled with the lowercase ASCII alphabet <lang Forth>: printit 26 0 do [char] a I + emit loop ;</lang> Or coded another way <lang Forth>: printit2 [char] z 1+ [char] a do I emit loop ;</lang>
We could do something more complicated and allocate space for a string and fill it. Two methods are demonstrated below
<lang>create lalpha 27 chars allot \ create a string in memory for 26 letters and count byte
- ]lalpha ( index -- addr ) \ index the string like an array (return an address)
lalpha char+ + ;
\ method 1: fill memory with ascii values using a loop
- fillit ( -- )
26 0 do [char] a I + \ calc. the ASCII value, leave on the stack I ]lalpha c! \ store the value on stack in the string at index I loop 26 lalpha c! ; \ store the count byte at the head of the string
\ method 2: load with a string literal
- Loadit s" abcdefghijklmnopqrstuvwxyz" lalpha PLACE ;
</lang>
- Output:
Test at the console
<lang>printit abcdefghijklmnopqrstuvwxyz ok
fillit ok lalpha count type abcdefghijklmnopqrstuvwxyz ok lalpha count erase ok lalpha count type ok loadit ok lalpha count type abcdefghijklmnopqrstuvwxyz ok </lang>
Fortran
<lang fortran> character(26) :: alpha
integer :: i
do i = 1, 26 alpha(i:i) = achar(iachar('a') + i - 1) end do</lang>
FreeBASIC
<lang freebasic>' FB 1.05.0 Win64
' Create a string buffer to store the alphabet plus a final null byte Dim alphabet As Zstring * 27
' ASCII codes for letters a to z are 97 to 122 respectively For i As Integer = 0 To 25
alphabet[i] = i + 97
Next
Print alphabet Print Print "Press any key to quit" Sleep </lang>
- Output:
abcdefghijklmnopqrstuvwxyz
Go
<lang go>func loweralpha() string { p := make([]byte, 26) for i := range p { p[i] = 'a' + byte(i) } return string(p) }</lang>
Groovy
<lang groovy>def lower = ('a'..'z')</lang> Test <lang groovy>assert 'abcdefghijklmnopqrstuvwxyz' == lower.join()</lang>
Haskell
<lang haskell>lower = ['a' .. 'z']
main = do
print lower</lang>
Icon and Unicon
You can just use the keyword:
&lcase
(although this technically produces a character set instead of a string, it can be used as a string, so string subscripting, generation, etc., all work).
E.g. <lang unicon>every a := put([], !&lcase) # array of 1 character per element c := create !&lcase # lazy generation of letters in sequence</lang>
<lang icon> procedure lower_case_letters() # entry point for function lower_case_letters return &lcase # returning lower caser letters represented by the set &lcase end
procedure main(param) # main procedure as entry point write(lower_case_letters()) # output of result of function lower_case_letters() end </lang>
J
Solution:<lang j> thru=: <. + i.@(+*)@-~
thru&.(a.&i.)/'az'
abcdefghijklmnopqrstuvwxyz</lang> or<lang J> u:97+i.26 abcdefghijklmnopqrstuvwxyz</lang> and, obviously, other variations are possible.
Java
<lang java>public class LowerAscii {
public static void main(String[] args) { StringBuilder sb = new StringBuilder(26); for (char ch = 'a'; ch <= 'z'; ch++) sb.append(ch); System.out.printf("lower ascii: %s, length: %s", sb, sb.length()); }
}</lang>
Output:
lower ascii: abcdefghijklmnopqrstuvwxyz, length: 26
JavaScript
ES5
In ES5, we can use String.fromCharCode(), which suffices for Unicode characters which can be represented with one 16 bit number.
For Unicode characters beyond this range, in ES5 we have to enter a pair of Unicode number escapes.
<lang JavaScript>(function (cFrom, cTo) {
function cRange(cFrom, cTo) { var iStart = cFrom.charCodeAt(0);
return Array.apply( null, Array(cTo.charCodeAt(0) - iStart + 1) ).map(function (_, i) {
return String.fromCharCode(iStart + i);
}); }
return cRange(cFrom, cTo);
})('a', 'z');</lang>
Returns: <lang JavaScript>["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"]</lang>
ES6
In ES6, the new String.fromCodePoint() method can can return 4-byte characters (such as Emoji, for example) as well as the usual 2-byte characters.
<lang JavaScript>(function (lstRanges) {
function cRange(cFrom, cTo) { var iStart = cFrom.codePointAt(0);
return Array.apply( null, Array(cTo.codePointAt(0) - iStart + 1) ).map(function (_, i) {
return String.fromCodePoint(iStart + i);
}); }
return lstRanges.map(function (lst) { return cRange(lst[0], lst[1]); });
})([
['a', 'z'], ['🐐', '🐟']
]);</lang>
Output:
<lang JavaScript>[["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"],
["🐐", "🐑", "🐒", "🐓", "🐔", "🐕", "🐖", "🐗", "🐘", "🐙", "🐚", "🐛", "🐜", "🐝", "🐞", "🐟"]]</lang>
<lang JavaScript>var letters = [] for (var i = 97; i <= 122; i++) {
letters.push(String.fromCodePoint(i))
}</lang>
Or, if we want to write a more general ES6 function:
<lang JavaScript>(lstRanges => {
// charRange :: Char -> Char -> [Char] function charRange(cFrom, cTo) { let [m, n] = [cFrom, cTo] .map(s => s.codePointAt(0)); return Array.from({ length: (n - m) + 1 }, (_, i) => String.fromCodePoint(m + i)); } // TEST return lstRanges .map(([from, to]) => charRange(from, to).join(' ')) .join('\n')
})([['a', 'z'], ['א','ת'],['α', 'ω'],['🐐', '🐟']]);</lang>
- Output:
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 א ב ג ד ה ו ז ח ט י ך כ ל ם מ ן נ ס ע ף פ ץ צ ק ר ש ת α β γ δ ε ζ η θ ι κ λ μ ν ξ ο π ρ ς σ τ υ φ χ ψ ω 🐐 🐑 🐒 🐓 🐔 🐕 🐖 🐗 🐘 🐙 🐚 🐛 🐜 🐝 🐞 🐟
jq
<lang jq>"az" | explode | [range( .[0]; 1+.[1] )] | implode'</lang> produces:
"abcdefghijklmnopqrstuvwxyz"
Julia
<lang Julia>['a':'z']
[c for c = 'a':'z']
string('a':'z'...)</lang>
- Output:
julia> show(['a':'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'] julia> string('a':'z'...) "abcdefghijklmnopqrstuvwxyz"
K
`c$ casts a list of integers to a string of characters; !26 produces a list of the integers from 0 to 25. So the lower-case ASCII alphabet can be generated using: <lang k>`c$97+!26</lang>
- Output:
"abcdefghijklmnopqrstuvwxyz"
LC3 Assembly
<lang lc3asm> .ORIG 0x3000
LD R0,ASCIIa LD R1,ASCIIz NOT R1,R1
LOOP OUT
ADD R0,R0,1 ADD R2,R0,R1 BRN LOOP
HALT
ASCIIa .FILL 0x61 ASCIIz .FILL 0x7A</lang> Output:
abcdefghijklmnopqrstuvwxyz
Logo
Straightforward, assuming ASCII: <lang logo>show map "char iseq 97 122</lang> Slightly less straightforward, but without the magic numbers: <lang logo>show map "char apply "iseq map "ascii [a z]</lang> Same output either way:
- Output:
[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]
Lua
<lang Lua>function getAlphabet ()
local letters = {} for ascii = 97, 122 do table.insert(letters, string.char(ascii)) end return letters
end
local alpha = getAlphabet() print(alpha[25] .. alpha[1] .. alpha[25]) </lang>
- Output:
yay
Maxima
<lang Maxima> delete([], makelist(if(alphacharp(ascii(i))) then parse_string(ascii(i)) else [], i, 96, 122));</lang>
- Output:
[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]
Mathematica / Wolfram Language
<lang Mathematica>start = 97; lowerCaseLetters = Table[FromCharacterCode[start + i], {i, 0, 25}]</lang>
- Output:
{"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"}
MATLAB / Octave
<lang MATLAB> 'a':'z'</lang> or alternatively <lang MATLAB> char(96+[1:26])</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
Mercury
<lang mercury>:- module gen_lowercase_ascii.
- - interface.
- - import_module io.
- - pred main(io::di, io::uo) is det.
- - implementation.
- - import_module char, int, list.
main(!IO) :-
list.map(char.det_from_int, 0'a .. 0'z, Alphabet), io.print_line(Alphabet, !IO).
- - end_module gen_lowercase_ascii.</lang>
- Output:
['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']
NESL
<lang nesl>lower_case_ascii = {code_char(c) : c in [97:123]};</lang>
Nim
<lang nim># A slice just contains the first and last value let alpha: Slice[char] = 'a'..'z' echo alpha # (a: a, b: z)
- but can be used to check if a character is in it:
echo 'f' in alpha # true echo 'G' in alpha # false
- A set contains all elements as a bitvector:
let alphaSet: set[char] = {'a'..'z'} echo alphaSet # {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} echo 'f' in alphaSet # true var someChars = {'a','f','g'} echo someChars <= alphaSet # true
import sequtils
- A sequence:
let alphaSeq = toSeq 'a'..'z' echo alphaSeq # @[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] echo alphaSeq[10] # k</lang>
Oforth
Oforth characters are integers. This list is a list of 26 integers <lang Oforth>'a' 'z' seqFrom</lang>
If necessary, these integers can be added to a string to have a indexed string of chars <lang Oforth>StringBuffer new 'a' 'z' seqFrom apply(#<<c)</lang>
PARI/GP
<lang parigp>Strchr(Vecsmall([97..122]))</lang>
Output:
"abcdefghijklmnopqrstuvwxyz"
Pascal
<lang pascal>program atoz; type
tlowAlphabet = 'a'..'z';
var
ch : tlowAlphabet;
begin
for ch := low(ch) to High(ch) do write(ch); writeln;
end.</lang> output
abcdefghijklmnopqrstuvwxyz
Perl
<lang Perl>print 'a'..'z'</lang>
Perl 6
<lang Perl 6>my @letters = 'a'..'z';</lang>
'a'..'z'
is a range literal, it constructs an immutableRange
object.- Assigning to an
@
variable flattens it into anArray
.
Phix
<lang Phix>string az = ""
for ch='a' to 'z' do az &= ch end for
?az</lang> Alternative version <lang Phix>puts(1,sq_add(tagset(26),'a'-1)&"\n")</lang>
- Output:
"abcdefghijklmnopqrstuvwxyz" abcdefghijklmnopqrstuvwxyz
PHP
<lang php><?php $lower = range('a', 'z'); var_dump($lower); ?></lang>
PicoLisp
<lang>(mapcar char (range (char "a") (char "z")))</lang>
PL/I
<lang PL/I>gen: procedure options (main); /* 7 April 2014. */
declare 1 ascii union, 2 letters (26) character (1), 2 iletters(26) unsigned fixed binary (8), letter character(1); declare i fixed binary;
letters(1), letter = lowercase('A'); do i = 2 to 26; iletters(i) = iletters(i-1) + 1; end; put edit (letters) (a);
end gen;</lang> Output:
abcdefghijklmnopqrstuvwxyz
Alternative, using library: <lang> /* Accessing library lower-case ASCII (PC only). */
letter = lowercase('A'); i = index(collate(), letter); put skip list (substr(collate, i, 26));</lang>
Output:
abcdefghijklmnopqrstuvwxyz
PowerShell
<lang PowerShell> $asString = 97..122 | ForEach-Object -Begin {$asArray = @()} -Process {$asArray += [char]$_} -End {$asArray -join()} $asString </lang>
- Output:
abcdefghijklmnopqrstuvwxyz
<lang PowerShell> $asArray </lang>
- Output:
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
Prolog
Works with SWI-Prolog 6.5.3 <lang Prolog>a_to_z(From, To, L) :- maplist(atom_codes, [From, To], [[C_From], [C_To]]), bagof([C], between(C_From, C_To, C), L1), maplist(atom_codes,L, L1). </lang> Output :
?- a_to_z(a, z, L). L = [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].
PureBasic
<lang purebasic>Dim lower_case('z' - 'a') ;indexing goes from 0 -> 25 For i = 0 To ArraySize(lower_case())
lower_case(i) = i + 'a'
Next</lang>
Python
<lang Python># From the standard library: from string import ascii_lowercase
- Generation:
lower = [chr(i) for i in range(ord('a'), ord('z') + 1)]</lang>
R
<lang R>
- From constants built into R:
letters </lang>
Racket
<lang racket>(define lowercase-letters (build-list 26 (lambda (x) (integer->char (+ x (char->integer #\a))))))</lang>
REXX
ASCII version
This version only works under ASCII machines (where the values of the lowercase a through the lowercase z characters are contiguous (and consecutive). <lang rexx>/* REXX ---------------------------------------------------------------
- 08.02.2014 Walter Pachl
- --------------------------------------------------------------------*/
say xrange('a','z')</lang> Output:
abcdefghijklmnopqrstuvwxyz
idiomatic version
This REXX version shows how to generate an indexable string of a similar sequence as per the
lowercase ASCII alphabet (or rather, the Latin [English] alphabet), using a reliable style of coding
(for both ASCII and EBCDIC systems).
This version also works on non-ASCII systems (such as EBCDIC) and isn't dependent on the
consecutiveness nature of any particular ASCII character subsequence.
Note that on an EBCDIC system, there are 41 characters between (lowercase) a ──► z
(inclusive), some of which don't have viewable/displayable glyphs.
<lang rexx>/*REXX program creates an indexable string of lowercase ASCII or EBCDIC characters: a─►z*/
$= /*set lowercase letters list to null. */
do j=0 for 2**8; _=d2c(j) /*convert decimal J to a character. */ if datatype(_, 'L') then $=$ || _ /*Is lowercase? Then add it to $ list.*/ end /*j*/ /* [↑] add lowercase letters ──► $ */
say $ /*stick a fork in it, we're all done. */</lang> output
abcdefghijklmnopqrstuvwxyz
Ring
<lang ring> for i = ascii("a") to ascii("z")
see char(i);
next i </lang>
Ruby
<lang ruby>p ('a' .. 'z').to_a p [*'a' .. 'z']</lang>
Run BASIC
<lang Runbasic>for i = asc("a") to asc("z")
print chr$(i);
next i</lang>Output:
abcdefghijklmnopqrstuvwxyz
Rust
<lang rust> fn main() {
// An iterator over the lowercase alpha's let ascii_iter = (0..26).map(|x| (x + 'a' as u8) as char);
println!("{:?}", ascii_iter.collect::<Vec<_>>());
} </lang>
- Output:
['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']
S-lang
Char_Type is just an integer-type so a "range array" can be easily created: <lang S-lang>variable alpha_ch = ['a':'z'], a;</lang> If you need single-char strings, convert thusly: <lang S-lang>variable alpha_st = array_map(String_Type, &char, alpha_ch);</lang> Let's take a peek: <lang S-lang>print(alpha_st[23]); foreach a (alpha_ch)
() = printf("%c ", a);
</lang>
- Output:
"x" 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
Scala
<lang scala>object Abc extends App {
val lowAlfa = 'a' to 'z' //That's all // Now several tests assert(lowAlfa.toSeq == Seq('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'), "No complete lowercase alfabet.") assert(lowAlfa.size == 26, "No 26 characters in alfabet") assert(lowAlfa.start == 'a', "Character 'a' not first char! ???") assert(lowAlfa.head == 'a', "Character 'a' not heading! ???") assert(lowAlfa.head == lowAlfa(0), "Heading char is not first char.") assert(lowAlfa contains 'n', "Character n not present.") assert(lowAlfa.indexOf('n') == 13, "Character n not on the 14th position.") assert(lowAlfa.last == lowAlfa(25), "Expected character (z)on the last and 26th pos.")
println(s"Successfully completed without errors. [within ${ scala.compat.Platform.currentTime - executionStart } ms]")
}</lang>
- Output:
Successfully completed without errors. [within 675 ms] Process finished with exit code 0
Scheme
<lang Scheme>(map integer->char (iota 26 (char->integer #\a)))</lang>
- Output:
(#\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)
Seed7
<lang seed7>$ include "seed7_05.s7i";
const proc: main is func
local var string: lower is ""; var char: ch is ' '; begin for ch range 'a' to 'z' do lower &:= ch; end for; writeln(lower); end func;</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
Sidef
<lang ruby>var arr = 'a'..'z'; say arr.join(' ');</lang>
Smalltalk
<lang smalltalk>| asciiLower | asciiLower := String new. 97 to: 122 do: [:asciiCode |
asciiLower := asciiLower , asciiCode asCharacter
]. ^asciiLower</lang>
Standard ML
<lang sml>val lowercase_letters = List.tabulate (26, fn x => chr (x + ord #"a"));</lang>
Swift
<lang Swift>var letters = [Character]()
for i in 97...122 {
let char = Character(UnicodeScalar(i)) letters.append(char)
}</lang>
Tcl
The most common way of doing this in Tcl would be to use a simple literal; it's only 51 characters after all: <lang tcl>set alpha {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}</lang> Though it could be done like this as well: <lang tcl>set alpha [apply {{} {
scan "az" "%c%c" from to for {set i $from} {$i <= $to} {incr i} { lappend l [format "%c" $i] } return $l
}}]</lang>
uBasic/4tH
<lang>For x= ORD("a") To ORD("z") : @(x - ORD("a")) = x : Next</lang>
UNIX Shell
In bash or ksh93 with braceexpand set: <lang sh>lower=({a..z})</lang>
In zsh with braceccl set: <lang sh>lower=({a-z})</lang>
Either way, you can display the result like this:
<lang sh>echo "${lower[@]}"</lang>
- Output:
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
Ursa
Creates a string named low containing the lower case ASCII alphabet. <lang ursa>decl int i decl string low for (set i (ord "a")) (< i (+ (ord "z") 1)) (inc i)
set low (+ low (chr i))
end for out low endl console</lang>
VBScript
<lang vb>Function ASCII_Sequence(range) arr = Split(range,"..") For i = Asc(arr(0)) To Asc(arr(1)) ASCII_Sequence = ASCII_Sequence & Chr(i) & " " Next End Function
WScript.StdOut.Write ASCII_Sequence(WScript.Arguments(0)) WScript.StdOut.WriteLine</lang>
- Output:
C:\>cscript /nologo ascii_sequence.vbs a..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 C:\>cscript /nologo ascii_sequence.vbs A..F A B C D E F
Vim Script
<lang vim>let lower = [] for c in range(0, 25)
let lower += [nr2char(c + char2nr("a"))]
endfor</lang>
or: <lang vim>echo map(range(char2nr('a'), char2nr('z')), 'nr2char(v:val)')</lang>
xEec
<lang xEec>h$` h$` >0_0 t h$y ms p h? jn00_0 p r h#1 ma t jn0_0 >00_0 p p r p</lang>
XLISP
<lang lisp>(defun ascii-lower ()
(defun add-chars (x y s) (if (<= x y) (add-chars (+ x 1) y (string-append s (string (integer->char x)))) s)) (add-chars 97 122 ""))</lang>
zkl
<lang zkl>["a".."z"] // lasy list ["a".."z"].walk() //-->L("a","b","c","d","e",... "a".toAsc().pump(26,List,"toChar") // another way to create the list "a".toAsc().pump(26,String,"toChar") // create a string
//-->"abcdefghijklmnopqrstuvwxyz"
Utils.Helpers.lowerLetters // string const</lang>
ZX Spectrum Basic
<lang zxbasic>10 DIM l$(26): LET init= CODE "a"-1 20 FOR i=1 TO 26 30 LET l$(i)=CHR$ (init+i) 40 NEXT i 50 PRINT l$</lang>