Generate lower case ASCII alphabet: Difference between revisions
Puppydrum64 (talk | contribs) m →{{header|68000 Assembly}}: code doesn't use the NEOGEO hardware in any meaningful way so removed the works with template |
add fermat |
||
Line 1,271: | Line 1,271: | ||
{{Out}} |
{{Out}} |
||
<pre>abcdefghijklmnopqrstuvwxyz</pre> |
<pre>abcdefghijklmnopqrstuvwxyz</pre> |
||
=={{header|Fermat}}== |
|||
<lang fermat>Array locase[1,26]; |
|||
[locase]:=[<i=1,26>'a'+i-1]; |
|||
!([locase:char);</lang> |
|||
{{out}}<pre>abcdefghijklmnopqrstuvwxyz</pre> |
|||
=={{header|Forth}}== |
=={{header|Forth}}== |
Revision as of 13:10, 21 November 2021
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
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.
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>
- Metrics
- Counting
- Word frequency
- Letter frequency
- Jewels and stones
- I before E except after C
- Bioinformatics/base count
- Count occurrences of a substring
- Count how many vowels and consonants occur in a string
- Remove/replace
- XXXX redacted
- Conjugate a Latin verb
- Remove vowels from a string
- String interpolation (included)
- Strip block comments
- Strip comments from a string
- Strip a set of characters from a string
- Strip whitespace from a string -- top and tail
- Strip control codes and extended characters from a string
- Anagrams/Derangements/shuffling
- Word wheel
- ABC problem
- Sattolo cycle
- Knuth shuffle
- Ordered words
- Superpermutation minimisation
- Textonyms (using a phone text pad)
- Anagrams
- Anagrams/Deranged anagrams
- Permutations/Derangements
- Find/Search/Determine
- ABC words
- Odd words
- Word ladder
- Semordnilap
- Word search
- Wordiff (game)
- String matching
- Tea cup rim text
- Alternade words
- Changeable words
- State name puzzle
- String comparison
- Unique characters
- Unique characters in each string
- Extract file extension
- Levenshtein distance
- Palindrome detection
- Common list elements
- Longest common suffix
- Longest common prefix
- Compare a list of strings
- Longest common substring
- Find common directory path
- Words from neighbour ones
- Change e letters to i in words
- Non-continuous subsequences
- Longest common subsequence
- Longest palindromic substrings
- Longest increasing subsequence
- Words containing "the" substring
- Sum of the digits of n is substring of n
- Determine if a string is numeric
- Determine if a string is collapsible
- Determine if a string is squeezable
- Determine if a string has all unique characters
- Determine if a string has all the same characters
- Longest substrings without repeating characters
- Find words which contains all the vowels
- Find words which contain the most consonants
- Find words which contains more than 3 vowels
- Find words whose first and last three letters are equal
- Find words with alternating vowels and consonants
- Formatting
- Substring
- Rep-string
- Word wrap
- String case
- Align columns
- Literals/String
- Repeat a string
- Brace expansion
- Brace expansion using ranges
- Reverse a string
- Phrase reversals
- Comma quibbling
- Special characters
- String concatenation
- Substring/Top and tail
- Commatizing numbers
- Reverse words in a string
- Suffixation of decimal numbers
- Long literals, with continuations
- Numerical and alphabetical suffixes
- Abbreviations, easy
- Abbreviations, simple
- Abbreviations, automatic
- Song lyrics/poems/Mad Libs/phrases
- Mad Libs
- Magic 8-ball
- 99 bottles of beer
- The Name Game (a song)
- The Old lady swallowed a fly
- The Twelve Days of Christmas
- Tokenize
- Text between
- Tokenize a string
- Word break problem
- Tokenize a string with escaping
- Split a character string based on change of character
- Sequences
0815
This creates the list in the queue <lang 0815><:61:~}:000:>>&{~<:7a:-#:001:<:1:+^:000:</lang>
11l
<lang 11l>print(Array(‘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]
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>
68000 Assembly
Stores the lower-case ASCII alphabet as a null-terminated string beginning at address 100000 hex. Register contents are preserved.
Called as a subroutine (i.e. "JSR Ascii_Low" if far away or "BSR Ascii_Low" if nearby)
<lang 68000devpac> Ascii_Low: MOVEM.L D0/A0,-(SP) ;store D0 and A0 on stack
LEA $00100000,A0 ;could also have used MOVE.L since the address is static MOVE.B #$61,D0 ;ascii "a"
loop_AsciiLow: MOVE.B D0,(A0)+ ;store letter in address and increment pointer by 1 ADDQ.B #1,D0 ;add 1 to D0 to get the next letter CMP.B #$7B,D0 ;Are we done yet? (7B is the first character after lowercase "z") BNE loop_AsciiLow ;if not, loop again MOVE.B #0,(A0) ;store the null terminator
MOVEM.L (SP)+,D0/A0 ;pop D0 and A0
rts </lang>
8080 Assembly
This routine takes a memory location in HL, and stores the alphabet there
in the form of an $
-terminated string that CP/M syscalls can use.
<lang 8080asm> org 100h jmp test
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Store the lowercase alphabet as a CP/M string ;; ($-terminated), starting at HL. ;; Destroys: b, c
alph: lxi b,611ah ; set B='a' and C=26 (counter) aloop: mov m,b ; store letter in memory inr b ; next letter inx h ; next memory position dcr c ; one fewer letter left jnz aloop ; go do the next letter if there is one mvi m,'$' ; terminate the string ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Test code test: lxi h,buf ; select buffer call alph ; generate alphabet
lxi d,buf ; print string in buffer mvi c,9 call 5 rst 0
buf: ds 27 ; buffer to keep the alphabet in
</lang>
8086 Assembly
<lang asm> bits 16 cpu 8086 org 100h section .text jmp demo ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Store the lowercase alphabet starting at [ES:DI] ;;; Destroys AX, CX, DI alph: mov cx,13 ; 2*13 words = 26 bytes mov ax,'ab' ; Do two bytes at once .loop: stosw ; Store AX at ES:DI and add 2 to DI add ax,202h ; Add 2 to both bytes (CD, EF, ...) loop .loop mov al,'$' ; MS-DOS string terminator stosb ret ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; demo: mov di,buf ; Pointer to buffer call alph ; Generate the alphabet mov dx,buf ; Print the contents of the buffer mov ah,9 int 21h ret section .bss buf: resb 27 ; Buffer to store the alphabet in</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
Example with simple write statement
<lang ABAP>REPORT lower_case_ascii.
WRITE: / to_lower( sy-abcde ).</lang>
Example with / without space using CL_DEMO_OUTPUT class
<lang ABAP>REPORT lower_case_ascii.
cl_demo_output=>new(
)->begin_section( |Generate lower case ASCII alphabet| )->write( REDUCE string( INIT out TYPE string FOR char = 1 UNTIL char > strlen( sy-abcde ) NEXT out = COND #( WHEN out IS INITIAL THEN sy-abcde(1) ELSE |{ out } { COND string( WHEN char <> strlen( sy-abcde ) THEN sy-abcde+char(1) ) }| ) ) )->write( |Or use the system field: { sy-abcde }| )->display( ).</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>
ALGOL W
<lang algolw> % set lc to the lower case alphabet %
string(26) lc; for c := 0 until 25 do lc( c // 1 ) := code( decode( "a" ) + c );</lang>
APL
<lang apl> ⎕UCS 96+⍳26</lang>
AppleScript
<lang AppleScript>-------------------- ALPHABETIC SERIES ------------------- on run
unlines(map(concat, ¬ ({enumFromTo("a", "z"), ¬ enumFromTo("🐟", "🐐"), ¬ enumFromTo("z", "a"), ¬ enumFromTo("α", "ω")})))
end run
GENERIC FUNCTIONS -------------------
-- concat :: a -> [a] -- concat :: [String] -> String on concat(xs)
set lng to length of xs if 0 < lng and string is class of (item 1 of xs) then set acc to "" else set acc to {} end if repeat with i from 1 to lng set acc to acc & item i of xs end repeat acc
end concat
-- enumFromTo :: Enum a => a -> a -> [a] on enumFromTo(m, n)
if class of m is integer then enumFromToInt(m, n) else enumFromToChar(m, n) end if
end enumFromTo
-- enumFromToChar :: Char -> Char -> [Char] on enumFromToChar(m, n)
set {intM, intN} to {id of m, id of n} set xs to {} repeat with i from intM to intN by signum(intN - intM) set end of xs to character id i end repeat return xs
end enumFromToChar
-- mReturn :: First-class m => (a -> b) -> m (a -> b) on mReturn(f)
-- 2nd class handler function lifted into 1st class script wrapper. if script is class of f then f else script property |λ| : f end script end if
end mReturn
-- map :: (a -> b) -> [a] -> [b] on map(f, xs)
-- The list obtained by applying f -- to each element of xs. tell mReturn(f) set lng to length of xs set lst to {} repeat with i from 1 to lng set end of lst to |λ|(item i of xs, i, xs) end repeat return lst end tell
end map
-- signum :: Num -> Num on signum(x)
if x < 0 then -1 else if x = 0 then 0 else 1 end if
end signum
-- unlines :: [String] -> String on unlines(xs)
-- A single string formed by the intercalation -- of a list of strings with the newline character. set {dlm, my text item delimiters} to ¬ {my text item delimiters, linefeed} set s to xs as text set my text item delimiters to dlm s
end unlines</lang>
- Output:
abcdefghijklmnopqrstuvwxyz 🐟🐞🐝🐜🐛🐚🐙🐘🐗🐖🐕🐔🐓🐒🐑🐐 zyxwvutsrqponmlkjihgfedcba αβγδεζηθικλμνξοπρςστυφχψω
A minor variation would be to perform a mass conversion and character extraction at the end instead of twenty-six individual character id i conversions:
<lang applescript>set l to {} repeat with i from id of "a" to id of "z"
set end of l to i
end repeat
return characters of string id l</lang>
- Output:
<lang applescript>{"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>
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>
ARM Assembly
Uses VASM syntax. PrintString
routine courtesy of Chibiakumas
Hardware: Game Boy Advance (ARM7TDMI)
This code generates the lower case ASCII set, stores it in RAM as a string literal, and prints that string to the screen.
<lang ARM Assembly>ProgramStart: mov sp,#0x03000000 ;Init Stack Pointer
mov r4,#0x04000000 ;DISPCNT -LCD Control mov r2,#0x403 ;4= Layer 2 on / 3= ScreenMode 3 str r2,[r4] ;hardware specific routine, activates Game Boy's bitmap mode
mov r0,#0x61 ;ASCII "a" mov r2,#ramarea mov r1,#26
rep_inc_stosb: ;repeatedly store a byte into memory, incrementing the destination and the value stored
; each time.
strB r0,[r2] add r0,r0,#1 add r2,r2,#1 subs r1,r1,#1 bne rep_inc_stosb mov r0,#255 strB r0,[r2] ;store a 255 terminator into r1
mov r1,#ramarea bl PrintString ;Prints a 255-terminated string using a pre-defined bitmap font. Code omitted for brevity
forever:
b forever ;halt the cpu</lang>
- Output:
Arturo
<lang rebol>print to [:char] 97..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
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_ÿ
BASIC
BBC BASIC
<lang bbcbasic> DIM lower&(25)
FOR i%=0TO25 lower&(i%)=ASC"a"+i% NEXT END</lang>
BASIC256
<lang basic256>
- generate lowercase ascii alphabet
- basic256 1.1.4.0
dim a$(27) # populating array for possible future use
for i = 1 to 26
a$[i] = chr(i + 96) print a$[i] + " ";
next i </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
Commodore BASIC
<lang gwbasic>10 FOR I=ASC("A") TO ASC("Z") 20 A$ = A$+CHR$(I) 30 NEXT 40 PRINT CHR$(14) : REM 'SWITCH CHARACTER SET TO LOWER/UPPER CASES 50 PRINT A$</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
IS-BASIC
<lang IS-BASIC>100 STRING ALPHA$*26 110 LET ALPHA$="" 120 FOR I=ORD("a") TO ORD("z") 130 LET ALPHA$=ALPHA$&CHR$(I) 140 NEXT 150 PRINT ALPHA$</lang>
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>
Run BASIC
<lang Runbasic>for i = asc("a") to asc("z")
print chr$(i);
next i</lang>Output:
abcdefghijklmnopqrstuvwxyz
uBasic/4tH
<lang>For x= ORD("a") To ORD("z") : @(x - ORD("a")) = x : Next</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>
BaCon
Using the inline loop construct. <lang bacon>PRINT LOOP$(26, CHR$(96+_))</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
Batch File
<lang dos> @echo off setlocal enabledelayedexpansion
- This code appends the ASCII characters from 97-122 to %alphabet%, removing any room for error.
for /l %%i in (97,1,122) do (
cmd /c exit %%i set "alphabet=!alphabet! !=exitcodeAscii!"
) echo %alphabet% pause>nul </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
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>
BQN
<lang bqn>'a'+↕26</lang>
Bracmat
<lang bracmat> a:?seq:?c & whl
' ( chr$(asc$!c+1):~>z:?c & !seq !c:?seq )
& !seq</lang>
Brainf***
<lang bf>Make room for 26 characters >>>>>>>>>>>>> >>>>>>>>>>>>> Set counter to 26 >> +++++++++++++ +++++++++++++ Generate the numbers 1 to 26 [-<< Decrement counter
[+<] Add one to each nonzero cell moving right to left + Add one to first zero cell encountered [>]> Return head to counter
] << Add 96 to each cell [ ++++++++++++++++ ++++++++++++++++ ++++++++++++++++ ++++++++++++++++ ++++++++++++++++ ++++++++++++++++ <] Print each cell >[.>] ++++++++++. \n</lang>
Uncommented: <lang bf>>>>>>>>>>>>>>>>>>>>>>>>>>>>>++++++++++++++++++++++++++[-<<[+<] +[>]>]<<[+++++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++++++++++++++++<]>[.>]++++++++++.</lang>
A smaller and faster solution:
<lang bf>++++++++++++++++++++++++++ > ++++++++++++++++++++++++++ ++++++ ++++++++++++++++++++++++++ ++++++ ++++++++++++++++++++++++++ ++++++ < [ - > + . < ]</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
Burlesque
<lang burlesque>blsq ) @azr\sh abcdefghijklmnopqrstuvwxyz</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#
Simple Linq 1 liner solution <lang csharp>using System; using System.Linq;
internal class Program {
private static void Main() { Console.WriteLine(String.Concat(Enumerable.Range('a', 26).Select(c => (char)c))); }
}</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
Old style Property and enumerable based solution <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
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>
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>
Comal
<lang comal>dim alphabet$ of 26 for i := 1 to 26
alphabet$(i) := chr$(ord("a") - 1 + i)
endfor i print alphabet$</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
Common Lisp
;; as a list <lang lisp>(defvar *lower*
(loop with a = (char-code #\a) for i below 26 collect (code-char (+ a i))))</lang>
;; as a string <lang lisp>(defvar *lowercase-alphabet-string*
(map 'string #'code-char (loop
for c from (char-code #\a) to (char-code #\z) collect c))
"The 26 lower case letters in alphabetical order.")</lang>
;; verify <lang lisp>(assert (= 26 (length *lowercase-alphabet-string*) (length *lower*))) (assert (every #'char< *lowercase-alphabet-string* (subseq *lowercase-alphabet-string* 1))) (assert (apply #'char< *lower*)) (assert (string= *lowercase-alphabet-string* (coerce *lower* 'string)))</lang>
Cowgol
<lang cowgol>include "cowgol.coh";
- Generate the alphabet and store it at the given location
- It is assumed that there is enough space (27 bytes)
sub alph(buf: [uint8]): (out: [uint8]) is
out := buf; var letter: uint8 := 'a'; while letter <= 'z' loop [buf] := letter; letter := letter + 1; buf := @next buf; end loop; [buf] := 0;
end sub;
- Use the subroutine to print the alphabet
var buf: uint8[27]; # make room for the alphabet print(alph(&buf as [uint8]));</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
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>
dc
Construct the numerical representation of the desired output and print it. <lang dc>122 [ d 1 - d 97<L 256 * + ] d sL x P</lang> Output:
abcdefghijklmnopqrstuvwxyz
Delphi
<lang delphi>program atoz;
var
ch : char;
begin
for ch in ['a'..'z'] do begin write(ch); end;
end.</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
DUP
In DUP, strings between double quotes are stored in a numerically addressed array. The integer before the first "
which gets pushed on the data stack, defines the cell address in which the ASCII value of first character of the string will be stored. All following characters will be stored like an array as values in the following cells. At the end, DUP pushes the length of the string on the data stack.
<lang DUP>0"abcdefghijklmnopqrstuvwxyz" {store character values of string in cells 0..length of string-1} 26[$][^^-;,1-]# {Loop from 26-26 to 26-0, print the respective cell contents to STDOUT}</lang>
Output:
abcdefghijklmnopqrstuvwxyz
Dyalect
Generates a lazy sequence and prints it to a standard output:
<lang dyalect>print('a'..'z')</lang>
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>
Elena
ELENA 5.0 : <lang elena>import extensions; import system'collections;
singleton Alphabet : Enumerable {
Enumerator enumerator() = new Enumerator { char current; get() = current; bool next() { if (nil==current) { current := $97 } else if (current != $122) { current := (current.toInt() + 1).toChar() } else { ^ false }; ^ true } reset() { current := nil } enumerable() = self; };
}
public program() {
console.printLine(Alphabet)
}</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
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"
Excel
LAMBDA
Binding the name showAlphabet to the following lambda expression in the Name Manager of the Excel WorkBook:
(See LAMBDA: The ultimate Excel worksheet function)
<lang lisp>showAlphabet =LAMBDA(az,
ENUMFROMTOCHAR( MID(az, 1, 1) )( MID(az, 2, 1) )
)</lang>
and also assuming the following generic binding in the Name Manager for the WorkBook:
<lang lisp>ENUMFROMTOCHAR =LAMBDA(a,
LAMBDA(z, LET( aCode, UNICODE(a), zCode, UNICODE(z), UNICHAR( IF(zCode >= aCode, SEQUENCE( 1, 1 + zCode - aCode, aCode, 1 ), SEQUENCE( 1, 1 + aCode - zCode, aCode, -1 ) ) ) ) )
)</lang>
- Output:
The formula in cell B2, for example, defines an array which populates the whole range B2:AA2
fx | =showAlphabet(A2) | ||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
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 | AA | AB | ||
1 | From to | ||||||||||||||||||||||||||||
2 | az | 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 | ||
3 | αω | α | β | γ | δ | ε | ζ | η | θ | ι | κ | λ | μ | ν | ξ | ο | π | ρ | ς | σ | τ | υ | φ | χ | ψ | ω | |||
4 | את | א | ב | ג | ד | ה | ו | ז | ח | ט | י | ך | כ | ל | ם | מ | ן | נ | ס | ע | ף | פ | ץ | צ | ק | ר | ש | ת | |
5 | תא | ת | ש | ר | ק | צ | ץ | פ | ף | ע | ס | נ | ן | מ | ם | ל | כ | ך | י | ט | ח | ז | ו | ה | ד | ג | ב | א | |
6 | za | z | y | x | w | v | u | t | s | r | q | p | o | n | m | l | k | j | i | h | g | f | e | d | c | b | a | ||
7 | ωα | ω | ψ | χ | φ | υ | τ | σ | ς | ρ | π | ο | ξ | ν | μ | λ | κ | ι | θ | η | ζ | ε | δ | γ | β | α |
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 абвгдеёжзийклмнопрстуфхцчшщъыьэюя
FALSE
<lang FALSE>'a[$'z>~][$,1+]#%</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
Fermat
<lang fermat>Array locase[1,26]; [locase]:=[<i=1,26>'a'+i-1]; !([locase:char);</lang>
- Output:
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>
Free Pascal
One can use set constructors like in Delphi. alphabet’s type will be set of char. <lang pascal>program lowerCaseAscii(input, output, stdErr); const alphabet = ['a'..'z']; begin end.</lang> Note, Pascal does not define that the letters A through Z are contiguous, the set constructor above assumes that, though. However, the FPC – the FreePascal compiler – virtually only works on systems, that use at least ASCII as common denominator.
Frink
The following produces a lazy enumerating sequence of the characters.
<lang frink>map["char", char["a"] to char["z"]]</lang>
To produce a non-lazy array of the characters, you can wrap the above in a toArray
call:
<lang frink>toArray[map["char", char["a"] to char["z"]]]</lang>
Furor
<lang Furor>
- k 'a 'z ++ {|| {} print SPACE |} NL end
</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
Gambas
Click this link to run this code <lang gambas>Public Sub Main() Dim siCount As Short
For siCount = Asc("a") To Asc("z")
Print Chr(siCount);
Next
End</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 = print lower</lang>
Or, equivalently: <lang haskell>alpha :: String alpha = enumFromTo 'a' 'z'
main :: IO () main = print alpha</lang>
- Output:
"abcdefghijklmnopqrstuvwxyz"
Huginn
<lang huginn>import Algorithms as algo; import Text as text;
main() {
print( "{}\n".format( text.character_class( text.CHARACTER_CLASS.LOWER_CASE_LETTER ) ) ); print( "{}\n".format( algo.materialize( algo.map( algo.range( integer( 'a' ), integer( 'z' ) + 1 ), character ), string ) ) );
}</lang>
- Output:
abcdefghijklmnopqrstuvwxyz abcdefghijklmnopqrstuvwxyz
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>(() => {
// enumFromTo :: Enum a => a -> a -> [a] const enumFromTo = (m, n) => { const [intM, intN] = [m, n].map(fromEnum), f = typeof m === 'string' ? ( (_, i) => chr(intM + i) ) : (_, i) => intM + i; return Array.from({ length: Math.floor(intN - intM) + 1 }, f); };
// GENERIC FUNCTIONS ------------------------------------------------------
// compose :: (b -> c) -> (a -> b) -> (a -> c) const compose = (f, g) => x => f(g(x));
// chr :: Int -> Char const chr = x => String.fromCodePoint(x);
// ord :: Char -> Int const ord = c => c.codePointAt(0);
// fromEnum :: Enum a => a -> Int const fromEnum = x => { const type = typeof x; return type === 'boolean' ? ( x ? 1 : 0 ) : type === 'string' ? ord(x) : x; };
// map :: (a -> b) -> [a] -> [b] const map = (f, xs) => xs.map(f);
// show :: a -> String const show = x => JSON.stringify(x);
// uncurry :: Function -> Function const uncurry = f => args => f.apply(null, args);
// unlines :: [String] -> String const unlines = xs => xs.join('\n');
// unwords :: [String] -> String const unwords = xs => xs.join(' ');
// TEST ------------------------------------------------------------------- return unlines(map(compose(unwords, uncurry(enumFromTo)), [ ['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"
Jsish
<lang javascript>/* Generate the lower case alphabet with Jsish, assume ASCII */ var letterA = "a".charCodeAt(0); var lowers = Array(26); for (var i = letterA; i < letterA + 26; i++) {
lowers[i - letterA] = Util.fromCharCode(i);
} puts(lowers); puts(lowers.join()); puts(lowers.length);
/*
!EXPECTSTART!
[ "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" ] abcdefghijklmnopqrstuvwxyz 26
!EXPECTEND!
- /</lang>
- Output:
prompt$ jsish generate-lowers.jsi [ "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" ] abcdefghijklmnopqrstuvwxyz 26 prompt$ jsish -u generate-lowers.jsi [PASS] generate-lowers.jsi
Julia
<lang julia>@show collect('a':'z') @show join('a':'z')</lang>
- Output:
collect('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'] join('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"
Keg
<lang keg>a(55*|:1+)</lang>
Kotlin
<lang scala>// version 1.3.72
fun main() {
val alphabet = CharArray(26) { (it + 97).toChar() }.joinToString("")
println(alphabet)
}</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
Lambdatalk
<lang scheme>
1) We define code2char & char2code as primitives:
{script LAMBDATALK.DICT["char2code"] = function() {
var args = arguments[0].trim(); return args.charCodeAt(0);
};
LAMBDATALK.DICT["code2char"] = function() {
var args = arguments[0].trim(); return String.fromCharCode(args);
}; }
2) and we use them:
{S.map code2char {S.serie {char2code a} {char2code 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
{S.map code2char {S.serie {char2code 0} {char2code 9}}} -> 0 1 2 3 4 5 6 7 8 9 </lang>
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
Lingo
<lang lingo>alphabet = [] repeat with i = 97 to 122
alphabet.add(numtochar(i))
end repeat put alphabet -- ["a", "b", "c", ... , "x", "y", "z"]</lang>
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
to table
<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
to string
<lang Lua>#!/usr/bin/env luajit local function ascii(f,t) local tab={} for i=f,t do tab[#tab+1]=string.char(i) end return table.concat(tab) end print(ascii(97,122))</lang>
- Output:
> ./lowercaseascii.lua abcdefghijklmnopqrstuvwxyz
M2000 Interpreter
<lang M2000 Interpreter> \\ old style Basic, including a Binary.Or() function Module OldStyle {
10 LET A$="" 20 FOR I=ASC("A") TO ASC("Z") 30 LET A$=A$+CHR$(BINARY.OR(I, 32)) 40 NEXT I 50 PRINT A$
} CALL OldStyle </lang>
Maple
<lang Maple>seq(StringTools:-Char(c), c = 97 .. 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"
Mathcad
Note: ":=" is the definition operator "=" is the evaluation operator
The actual Mathcad worksheet is at https://community.ptc.com/t5/PTC-Mathcad/Rosetta-Code-Generate-Lower-Case-ASCII-Alphabet/m-p/670829#M190552
The Haskell-like '--' marker preceding each comment is not necessary in Mathcad, and is only there to indicate text rather than an expression.
Method 1: Using a Range Variable.
<lang Mathcad> -- user-defined function that returns the ASCII code for string character ch. code(ch):=str2vec(ch)[0
-- number of lower-case ASCII characters N:=26
-- range variable covering the relative indices of the lower-case characters within the ASCII character set (0 = 'a', 25 = 'z'). k:=0..N-1
-- ASCII code for letter 'a' (a=97 ). a:=code("a")
-- iterate over k to produce a vector of lower case ASCII character codes lcCodes[k:=k+a
-- convert vector to string of ordered ASCII lower-case characters. lcString:=vec2str(lcCodes) lcString="abcdefghijklmnopqrstuvwxyz"
-- Characters are indexable within the string; for example: substr(lcString,3,1)="d" </lang>
Method 2: Using a Function.
<lang Mathcad> -- Mathcad Express lacks the programming capability of Mathcad Prime, so uses the built-in if function to implement a recursive solution (if(predicate,true expr, false expr)).
-- char(cd): return the string character with code cd. char(cd):=vec2str([cd])
-- charseq(m,n): return a string containing an ordered list of the characters whose codes lie between m and n, inclusive. charseq(m,n):=if(m>=n,char(m),concat(char(m),charseq(m+1,n)))
charseq(code("a"),code("z"))="abcdefghijklmnopqrstuvwxyz" charseq(code("A"),code("Z"))="ABCDEFGHIJKLMNOPQRSTUVWXYZ" charseq(code("0"),code("9"))="0123456789" charseq(code("а"),code("я"))="абвгдежзийклмнопрстуфхцчшщъыьэюя" charseq(code("α"),code("ω"))="αβγδεζηθικλμνξοπρςστυφχψω"
</lang>
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
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]
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']
MiniScript
<lang MiniScript>letters = [] for i in range(code("a"), code("z"))
letters.push char(i)
end for
print letters</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"]
MUMPS
<lang MUMPS> LOWASCMIN
set lowstr = "" for i = 97:1:122 set delim = $select(i=97:"",1:",") set lowstr = lowstr_delim_$char(i) write lowstr quit
</lang>
- Output:
SAMPLES>DO ^LOWASCMIN 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
Nanoquery
<lang nanoquery>lowercase = list() for i in range(ord("a"), ord("z"))
lowercase.append(chr(i))
end println lowercase</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]
Neko
<lang ActionScript>/**
<doc>Generate lower case ASCII, in Neko</doc>
- /
var slot = 25 var generated = $smake(slot + 1) var lower_a = $sget("a", 0)
/* 'a'+25 down to 'a'+0 */ while slot >= 0 {
$sset(generated, slot, slot + lower_a) slot -= 1
}
$print(generated, "\n")</lang>
- Output:
prompt$ nekoc generate-lower.neko prompt$ neko generate-lower.n abcdefghijklmnopqrstuvwxyz
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>
OCaml
<lang ocaml># Array.make 26 'a' |> Array.mapi (fun i c -> int_of_char c + i |> char_of_int);; - : char array = [|'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>
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 lowerCaseAscii(input, output, stdErr); var alphabet: set of char; begin // as per ISO 7185, 'a'..'z' do not necessarily have to be contiguous alphabet := [ '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' ]; end.</lang>
Perl
<lang Perl>print 'a'..'z'</lang>
Phix
string az = "" for ch='a' to 'z' do az &= ch end for ?az ?tagset('z','a')
Using tagset() is obviously easier, but you have to remember its parameters are (finish,start=1,step=1), that way round so that start can be omitted and default to 1 (ditto step).
In Phix there is really not much difference between 1..26 and 'a'..'z', and none at all between 'a'..'z' and 97..122.
- Output:
"abcdefghijklmnopqrstuvwxyz" "abcdefghijklmnopqrstuvwxyz"
Phixmonti
<lang Phixmonti>0 tolist 'a' 'z' 2 tolist for
tochar 0 put
endfor print</lang> Simplest <lang Phixmonti>include ..\Utilitys.pmt ( 'a' 'z' ) for tochar print endfor</lang>
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
PL/SQL
<lang PL/SQL>Declare
sbAlphabet varchar2(100);
Begin
For nuI in 97..122 loop if sbAlphabet is null then sbAlphabet:=chr(nuI); Else sbAlphabet:=sbAlphabet||','||chr(nuI); End if; End loop; Dbms_Output.Put_Line(sbAlphabet);
End;</lang> Output:
PL/SQL block, executed in 0 ms 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 Total execution time 16 ms
Plain English
<lang plainenglish>To run: Start up. Generate the lowercase ASCII alphabet giving a string. Write the string on the console. Wait for the escape key. Shut down.
To generate the lowercase ASCII alphabet giving a string: Put the little-a byte into a letter. Loop. Append the letter to the string. If the letter is the little-z byte, exit. Add 1 to the letter. Repeat.</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
Alternative: <lang PowerShell> -join [Char[]] (97..122) </lang>
- Output:
abcdefghijklmnopqrstuvwxyz
Alternative as of PowerShell-v6.0.0rc: <lang PowerShell> -join ('a'..'z') </lang>
- Output:
abcdefghijklmnopqrstuvwxyz
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].
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>
Or, as a particular instance of a more general enumeration pattern:
<lang python>Enumeration a-z
from inspect import signature import enum
- TEST ----------------------------------------------------
def main():
Testing particular instances of a general pattern: print( fTable(__doc__ + ':\n')(repr)(showList)( uncurry(enumFromTo) )([ ('a', 'z'), ('α', 'ω'), ('א', 'ת'), (1, 10), (round((5**(1 / 2) - 1) / 2, 5), 5), ('🌱', '🍂') ]) )
- GENERIC -------------------------------------------------
- enumFromTo :: Enum a => a -> a -> [a]
def enumFromTo(m):
Enumeration of values [m..n] def go(x, y): t = type(m) i = fromEnum(x) d = 0 if t != float else (x - i) return list(map( lambda x: toEnum(t)(d + x), range(i, 1 + fromEnum(y)) ) if int != t else range(x, 1 + y)) return lambda n: go(m, n)
- fromEnum :: Enum a => a -> Int
def fromEnum(x):
Index integer for enumerable value. Enum = enum.Enum return ord(x) if isinstance(x, str) else ( x.value if isinstance(x, Enum) else int(x) )
- toEnum :: Type -> Int -> a
def toEnum(t):
Enumerable value from index integer dct = { int: int, float: float, str: chr, bool: bool } return lambda x: dct[t](x) if t in dct else t(x)
- uncurry :: (a -> b -> c) -> ((a, b) -> c)
def uncurry(f):
A function over a tuple, derived from a vanilla or curried function. if 1 < len(signature(f).parameters): return lambda xy: f(*xy) else: return lambda xy: f(xy[0])(xy[1])
- FORMATTING -------------------------------------------------
- fTable :: String -> (a -> String) ->
- (b -> String) -> (a -> b) -> [a] -> String
def fTable(s):
Heading -> x display function -> fx display function -> f -> xs -> tabular string. def go(xShow, fxShow, f, xs): ys = [xShow(x) for x in xs] w = max(map(len, ys)) return s + '\n' + '\n'.join(map( lambda x, y: y.rjust(w, ' ') + ' -> ' + fxShow(f(x)), xs, ys )) return lambda xShow: lambda fxShow: lambda f: lambda xs: go( xShow, fxShow, f, xs )
- showList :: [a] -> String
def showList(xs):
Stringification of a list. return '[' + ','.join(str(x) for x in xs) + ']'
- MAIN ---
if __name__ == '__main__':
main()</lang>
- Output:
Enumeration a-z: ('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] ('α', 'ω') -> [α,β,γ,δ,ε,ζ,η,θ,ι,κ,λ,μ,ν,ξ,ο,π,ρ,ς,σ,τ,υ,φ,χ,ψ,ω] ('א', 'ת') -> [א,ב,ג,ד,ה,ו,ז,ח,ט,י,ך,כ,ל,ם,מ,ן,נ,ס,ע,ף,פ,ץ,צ,ק,ר,ש,ת] (1, 10) -> [1,2,3,4,5,6,7,8,9,10] (0.61803, 5) -> [0.61803,1.61803,2.61803,3.61803,4.61803,5.61803] ('🌱', '🍂') -> [🌱,🌲,🌳,🌴,🌵,🌶,🌷,🌸,🌹,🌺,🌻,🌼,🌽,🌾,🌿,🍀,🍁,🍂]
Quackery
The word constant causes the preceding nest to be evaluated during compilation so alpha$ is a literal, not an expression computed during program evaluation.
<lang Quackery>[ [] 26 times [ i^ char a + join ] ] constant is alpha$ ( --> $ )
alpha$ echo$</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
R
<lang R># From constants built into R: letters
- Or generate the same with:
sapply(97:122, intToUtf8)</lang>
Racket
<lang racket>(define lowercase-letters (build-list 26 (lambda (x) (integer->char (+ x (char->integer #\a))))))</lang>
Raku
(formerly Perl 6)
<lang perl6>say my @letters = 'a'..'z';</lang>
'a'..'z'
is a range literal, it constructs an immutableRange
object.- Assigning to an
@
variable flattens it into anArray
.
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>
Rust
<lang rust>fn main() {
// An iterator over the lowercase alpha's let ascii_iter = (0..26) .map(|x| (x + b'a') as char); println!("{:?}", ascii_iter.collect::<Vec<char>>());
}</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 lowAlpha = 'a' to 'z' //That's all // Now several tests assert(lowAlpha.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 alphabet.") assert(lowAlpha.size == 26, "No 26 characters in alphabet") assert(lowAlpha.start == 'a', "Character 'a' not first char! ???") assert(lowAlpha.head == 'a', "Character 'a' not heading! ???") assert(lowAlpha.head == lowAlpha(0), "Heading char is not first char.") assert(lowAlpha contains 'n', "Character n not present.") assert(lowAlpha.indexOf('n') == 13, "Character n not on the 14th position.") assert(lowAlpha.last == lowAlpha(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>
Snobol
<lang sml> &ALPHABET ('a' LEN(25)) . OUTPUT ;* Works in ASCII but not EBCDIC.</lang>
SPL
<lang spl>> i, 1..26
d = [i+96,0] a[i] = #.str(d)
< 'now A is an array of letters a..z
> i, 1..#.size(a,1)
#.output(a[i],#.rs)
<</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
Standard ML
<lang sml>val lowercase_letters = List.tabulate (26, fn x => chr (x + ord #"a"));</lang>
Stata
<lang stata>// built-in: lowercase and uppercase letters display c(alpha) display c(ALPHA)
// generate a variable with the letters clear set obs 26 gen a=char(96+_n)
// or in Mata mata char(97..122) end</lang>
SuperCollider
Previously, it was claimed that the method that maps ascii number to character is polymorphic on collections. However, that doesn't seem to be the case – at least not anymore in the newer version (3.10.2). A fix was added below the original code. <lang SuperCollider> (97..122).asAscii; // This example unfortunately throws an error
// for me when running it on version 3.10.2
// Apparently, the message 'asAscii' cannot be understood by // an Array, so I used the message 'collect' to apply the function // enclosed in {} to each individual element of the Array, // passing them the message 'asAscii':
(97..122).collect({|asciiCode| asciiCode.asAscii});
// Instead of writing the ascii codes directly as numbers, // one could also pass the chars a and z the message 'ascii' to convert // them to ascii codes – perhaps making the code a bit clearer:
($a.ascii..$z.ascii).collect({|asciiCode| asciiCode.asAscii});
// both examples 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 ]
</lang>
Backwards:
<lang SuperCollider>
"abcdefghijklmnopqrstuvwxyz".ascii
// answers [ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122 ]
</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>
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>
VBA
<lang vb> Option Explicit
Sub Main_Lower_Case_Ascii_Alphabet() Dim Alpha() As String
Alpha = Alphabet(97, 122) Debug.Print Join(Alpha, ", ")
End Sub
Function Alphabet(FirstAscii As Byte, LastAscii As Byte) As String() Dim strarrTemp() As String, i&
ReDim strarrTemp(0 To LastAscii - FirstAscii) For i = FirstAscii To LastAscii strarrTemp(i - FirstAscii) = Chr(i) Next Alphabet = strarrTemp Erase strarrTemp
End Function </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
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>
Visual Basic
The #VBA example works in VB6 as well, without any change.
Visual Basic .NET
Used Asc(Char) [returns Integer value of Char passed] and Chr(Integer) [returns Char value of Integer passed] functions.
String.Join() is used to print the list, converted to array, without looping through it.
<lang vbnet>Module LowerASCII
Sub Main() Dim alphabets As New List(Of Char) For i As Integer = Asc("a") To Asc("z") alphabets.Add(Chr(i)) Next Console.WriteLine(String.Join("", alphabets.ToArray)) End Sub
End Module </lang>
- Output:
abcdefghijklmnopqrstuvwxyz
Wren
<lang javascript>var alpha = [] for (c in 97..122) alpha.add(String.fromByte(c)) System.print(alpha.join())</lang>
- Output:
abcdefghijklmnopqrstuvwxyz
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>
XPL0
<lang XPL0>char I, A(26); for I:= 0 to 26-1 do A(I):= I+^a</lang>
Z80 Assembly
<lang z80> org &8000 ld a,'a' ;data ld b,26 ;loop counter ld hl,Alphabet ;destination loop: ld (hl),a ;store "a" into ram inc a ;next letter inc hl ;next storage byte djnz loop ;repeat until 26 letters were stored.
call Monitor_MemDump ;hexdumps the specified address and bytecount to screen - created by Keith S. of Chibiakumas byte 32 ;number of bytes to display word Alphabet ;address to dump from
ret ;return to basic
Alphabet:
ds 26,0 ;reserve 26 bytes of ram, init all to zero.</lang>
- Output:
8013: 61 62 63 64 65 66 67 68 abcdefgh 69 6A 6B 6C 6D 6E 6F 70 ijklmnop 71 72 73 74 75 76 77 78 qrstuvwx 79 7A 00 00 00 00 00 00 yz
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>
- Programming Tasks
- String manipulation
- 0815
- 11l
- 360 Assembly
- 6502 Assembly
- 68000 Assembly
- 8080 Assembly
- 8086 Assembly
- 8th
- ABAP
- Ada
- ALGOL 68
- ALGOL W
- APL
- AppleScript
- Applesoft BASIC
- ARM Assembly
- Arturo
- ATS
- AutoHotkey
- AutoIt
- AWK
- BASIC
- BBC BASIC
- BASIC256
- Commodore BASIC
- FreeBASIC
- IS-BASIC
- PureBasic
- Run BASIC
- UBasic/4tH
- ZX Spectrum Basic
- BaCon
- Batch File
- Befunge
- BQN
- Bracmat
- Brainf***
- Burlesque
- C
- C sharp
- C++
- Clojure
- COBOL
- CoffeeScript
- Comal
- Common Lisp
- Cowgol
- D
- Dc
- Delphi
- DUP
- Dyalect
- EchoLisp
- Elena
- Elixir
- Erlang
- Excel
- F Sharp
- Factor
- FALSE
- Fermat
- Forth
- Fortran
- Free Pascal
- Frink
- Furor
- Gambas
- Go
- Groovy
- Haskell
- Huginn
- Icon
- Unicon
- J
- Java
- JavaScript
- Jq
- Jsish
- Julia
- K
- Keg
- Kotlin
- Lambdatalk
- LC3 Assembly
- Lingo
- Logo
- Lua
- M2000 Interpreter
- Maple
- Mathcad
- None
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- Maxima
- Mercury
- MiniScript
- MUMPS
- Nanoquery
- Neko
- NESL
- Nim
- OCaml
- Oforth
- PARI/GP
- Pascal
- Perl
- Phix
- Phixmonti
- PHP
- PicoLisp
- PL/I
- PL/SQL
- Plain English
- PowerShell
- Prolog
- Python
- Quackery
- R
- Racket
- Raku
- REXX
- Ring
- Ruby
- Rust
- S-lang
- Scala
- Scheme
- Seed7
- Sidef
- Smalltalk
- Snobol
- SPL
- Standard ML
- Stata
- SuperCollider
- Swift
- Tcl
- UNIX Shell
- Ursa
- VBA
- VBScript
- Vim Script
- Visual Basic
- Visual Basic .NET
- Wren
- XEec
- XLISP
- XPL0
- Z80 Assembly
- Zkl