Generate lower case ASCII alphabet: Difference between revisions

 

During code review it's not immediate obvious to spot the bug in a Tcl line like this contained in a page of code:

 

 

=={{header|0815}}==

This creates the list in the queue

 

=={{header|11l}}==

{{out}}

<pre>

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.

LOWER CSECT

USING LOWER,R15 set base register

PG DS CL26 buffer

YREGS

{{out}}

<pre>

=={{header|6502 Assembly}}==

Stores the lower-case ASCII alphabet as a null-terminated string beginning at address 2000 hex. Register contents are preserved.

TXA ; shall be using onto the stack

PHA

TAX ; the stack

PLA

 

=={{header|68000 Assembly}}==

Called as a subroutine (i.e. "JSR Ascii_Low" if far away or "BSR Ascii_Low" if nearby)

 

Ascii_Low:

MOVEM.L D0/A0,-(SP) ;store D0 and A0 on stack

 

rts

 

=={{header|8080 Assembly}}==

in the form of an <code>$</code>-terminated string that CP/M syscalls can use.

 

jmp test

 

 

buf: ds 27 ; buffer to keep the alphabet in

 

=={{header|8086 Assembly}}==

 

cpu 8086

org 100h

ret

section .bss

 

=={{header|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:

"" ( 'a n:+ s:+ ) 0 25 loop

. cr

{{out}}

<pre>

=={{header|ABAP}}==

=== Example with simple write statement ===

 

 

=== Example with / without space using CL_DEMO_OUTPUT class ===

 

cl_demo_output=>new(

ELSE |{ out } { COND string( WHEN char <> strlen( sy-abcde ) THEN sy-abcde+char(1) ) }| ) )

)->write( |Or use the system field: { sy-abcde }|

 

=={{header|Action!}}==

 

Proc Main()

Od

 

{{Out}}

<pre>abcdefghijklmnopqrstuvwxyz</pre>

We start with a strong type definition: A character range that can only hold lower-case letters:

 

 

Now we define an array type and initialize the Array A of that type with the 26 letters:

 

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:

 

begin

B(B'First) := 'a';

for I in B'First .. B'Last-1 loop

B(I+1) := Lower_Case'Succ(B(I));

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.6.win32}}

# so we can declare an array of 26 characters and assign a string #

# containing the lower-case letters to it #

 

[ 26 ]CHAR lc := "abcdefghijklmnopqrstuvwxyz"

Alternative version

# they are consecutive in the character set, as they are in ASCII #

 

DO

lc[ i ] := REPR ( ABS "a" + ( i - 1 ) )

 

=={{header|ALGOL W}}==

string(26) lc;

 

=={{header|APL}}==

{{works with|Dyalog APL}}

 

=={{header|AppleScript}}==

 

on run

unlines(map(concat, ¬

set my text item delimiters to dlm

s

{{Out}}

<pre>abcdefghijklmnopqrstuvwxyz

A minor variation would be to perform a mass conversion and character extraction at the end instead of twenty-six individual <tt>character id i</tt> conversions:

 

repeat with i from id of "a" to id of "z"

set end of l to i

end repeat

 

{{Out}}

 

=={{header|Applesoft BASIC}}==

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:

 

=={{header|ARM Assembly}}==

This code generates the lower case ASCII set, stores it in RAM as a string literal, and prints that string to the screen.

 

mov sp,#0x03000000 ;Init Stack Pointer

 

forever:

{{out}}

[https://ibb.co/4SbsgzP Picture of output]

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|ATS}}==

(* ****** ****** *)

//

//

} (* end of [main0] *)

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

Loop, 26

 

=={{header|AutoIt}}==

Func _a2z()

Local $a2z = ""

Return $a2z

EndFunc

 

=={{header|AWK}}==

Note this is dependent on the locale-setting,

and options, e.g. --traditional and --posix

# syntax: GAWK -f GENERATE_LOWER_CASE_ASCII_ALPHABET.AWK

BEGIN {

exit(0)

}

{{Output}}

<pre>

=={{header|BASIC}}==

==={{header|BBC BASIC}}===

FOR i%=0TO25

lower&(i%)=ASC"a"+i%

NEXT

 

==={{header|BASIC256}}===

# generate lowercase ascii alphabet

# basic256 1.1.4.0

print a$[i] + " ";

next i

{{out}}

<pre>

 

==={{header|Commodore BASIC}}===

20 A$ = A$+CHR$(I)

30 NEXT

40 PRINT CHR$(14) : REM 'SWITCH CHARACTER SET TO LOWER/UPPER CASES

 

==={{header|FreeBASIC}}===

 

' Create a string buffer to store the alphabet plus a final null byte

Print "Press any key to quit"

Sleep

 

{{out}}

 

==={{header|IS-BASIC}}===

110 LET ALPHA$=""

120 FOR I=ORD("a") TO ORD("z")

130 LET ALPHA$=ALPHA$&CHR$(I)

140 NEXT

 

==={{header|PureBasic}}===

For i = 0 To ArraySize(lower_case())

lower_case(i) = i + 'a'

 

==={{header|QBasic}}===

{{works with|QuickBasic|4.5}}

{{works with|True BASIC}}

 

FOR i = 1 to 26

PRINT a$(i);

NEXT i

 

==={{header|True BASIC}}===

{{works with|QBasic|1.1}}

{{works with|QuickBasic|4.5}}

 

FOR i = 1 to 26

PRINT a$(i);

NEXT i

 

==={{header|Yabasic}}===

{{works with|QuickBasic|4.5}}

{{works with|Run BASIC}}

print chr$(i);

 

==={{header|Run BASIC}}===

print chr$(i);

<pre>abcdefghijklmnopqrstuvwxyz</pre>

 

==={{header|uBasic/4tH}}===

 

==={{header|ZX Spectrum Basic}}===

{{trans|BBC_BASIC}}

20 FOR i=1 TO 26

30 LET l$(i)=CHR$ (init+i)

40 NEXT i

 

==={{header|BaCon}}===

Using the inline loop construct.

{{out}}

<pre>abcdefghijklmnopqrstuvwxyz</pre>

 

=={{header|Batch File}}==

@echo off

setlocal enabledelayedexpansion

echo %alphabet%

pause>nul

{{out}}

<pre>

=={{header|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.

 

=={{header|BQN}}==

 

=={{header|Bracmat}}==

& whl

' ( chr$(asc$!c+1):~>z:?c

& !seq !c:?seq

)

 

=={{header|Brainf***}}==

 

>>>>>>>>>>>>>

>>>>>>>>>>>>>

Print each cell

>[.>]

 

Uncommented:

+[>]>]<<[+++++++++++++++++++++++++++++++++++++++++++++++++++++

 

A smaller and faster solution:

 

++++++++++++++++++++++++++ ++++++

++++++++++++++++++++++++++ ++++++

++++++++++++++++++++++++++ ++++++

 

{{out}}

 

=={{header|Burlesque}}==

 

=={{header|C}}==

 

#define N 26

return EXIT_SUCCESS;

}

 

=={{header|C sharp}}==

Simple Linq 1 liner solution

using System.Linq;

 

Console.WriteLine(String.Concat(Enumerable.Range('a', 26).Select(c => (char)c)));

}

 

Old style Property and enumerable based solution

{

using System;

}

}

 

=={{header|C++}}==

C++ can do the task in the identical way as C, or else, it can use a STL function.

{{works with|C++11}}

#include <numeric>

 

 

std::iota(lower.begin(), lower.end(), 'a');

 

=={{header|Clojure}}==

{{out}}

<pre>

 

=={{header|CLU}}==

a: int := char$c2i('a')

letters: array[char] := array[char]$predict(1,26)

start_up = proc ()

stream$putl(stream$primary_output(), alph())

{{out}}

<pre>abcdefghijklmnopqrstuvwxyz</pre>

=={{header|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.

program-id. lower-case-alphabet-program.

data division.

add-next-letter-paragraph.

add 97 to loop-counter giving character-code.

{{out}}

<pre>abcdefghijklmnopqrstuvwxyz</pre>

 

=={{header|CoffeeScript}}==

(String.fromCharCode(x) for x in [97..122])

 

=={{header|Comal}}==

for i := 1 to 26

alphabet$(i) := chr$(ord("a") - 1 + i)

endfor i

{{Out}}

<pre>abcdefghijklmnopqrstuvwxyz</pre>

=={{header|Common Lisp}}==

<nowiki>;; as a list</nowiki>

(loop with a = (char-code #\a)

for i below 26

 

<nowiki>;; as a string</nowiki>

(map 'string #'code-char (loop

for c from (char-code #\a) to (char-code #\z)

collect c))

 

<nowiki>;; verify</nowiki>

(assert (every #'char< *lowercase-alphabet-string* (subseq *lowercase-alphabet-string* 1)))

(assert (apply #'char< *lower*))

 

=={{header|Cowgol}}==

 

# Generate the alphabet and store it at the given location

# Use the subroutine to print the alphabet

var buf: uint8[27]; # make room for the alphabet

 

{{out}}

=={{header|D}}==

The lower case ASCII letters of the Phobos standard library:

 

 

The generation of the ASCII alphabet array:

char['z' - 'a' + 1] arr;

 

foreach (immutable i, ref c; arr)

c = 'a' + i;

 

An alternative version:

import std.range, std.algorithm, std.array;

 

char[26] arr = 26.iota.map!(i => cast(char)('a' + i)).array;

Another version:

char[] arr;

 

 

assert(arr == "abcdefghijklmnopqrstuvwxyz");

 

=={{header|dc}}==

Construct the numerical representation of the desired output and print it.

Output:

<pre>

 

=={{header|Delphi}}==

 

var

write(ch);

end;

 

=={{header|Draco}}==

proc alph(*char buf) *char:

channel output text ch;

[27] char buf; /* one byte extra for the string terminator */

writeln(alph(&buf[0]))

{{out}}

<pre>abcdefghijklmnopqrstuvwxyz</pre>

In DUP, strings between double quotes are stored in a numerically addressed array. The integer before the first <code>"</code> 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.

 

 

Output:

Generates a lazy sequence and prints it to a standard output:

 

 

=={{header|EchoLisp}}==

;; 1)

(define \a (first (string->unicode "a")))

(for/string ((letter ["a" .. "z"])) letter)

→ abcdefghijklmnopqrstuvwxyz

 

=={{header|Elena}}==

import system'collections;

char current;

bool next()

{

console.printLine(Alphabet)

{{out}}

<pre>

 

=={{header|Elixir}}==

'abcdefghijklmnopqrstuvwxyz'

iex(2)> Enum.to_list(?a .. ?z) |> List.to_string

 

=={{header|Erlang}}==

 

{{Output}}

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(az,

ENUMFROMTOCHAR(

MID(az, 2, 1)

)

 

and also assuming the following generic binding in the Name Manager for the WorkBook:

 

=LAMBDA(a,

LAMBDA(z,

)

)

 

{{Out}}

 

=={{header|F_Sharp|F#}}==

 

 

=={{header|Factor}}==

Strings are represented as fixed-size mutable sequences of Unicode code points.

 

 

ALPHABET print

: russian-alphabet-without-io ( -- str ) 0x0430 0x0450 [a,b) >string ;

: russian-alphabet ( -- str ) 0x0451 6 russian-alphabet-without-io insert-nth ;

{{out}}

<pre>abcdefghijklmnopqrstuvwxyz

 

=={{header|FALSE}}==

 

{{Out}}

 

=={{header|Fermat}}==

[locase]:=[<i=1,26>'a'+i-1];

{{out}}<pre>abcdefghijklmnopqrstuvwxyz</pre>

 

=={{header|Forth}}==

Generate a string filled with the lowercase ASCII alphabet

Or coded another way

 

We could do something more complicated and allocate space for a string and fill it.

Two methods are demonstrated below

 

 

lalpha char+ + ;

 

: Loadit s" abcdefghijklmnopqrstuvwxyz" lalpha PLACE ;

 

 

{{Output}}Test at the console

 

fillit ok

loadit ok

lalpha count type abcdefghijklmnopqrstuvwxyz ok

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

integer :: i

 

do i = 1, 26

alpha(i:i) = achar(iachar('a') + i - 1)

 

=={{header|Free Pascal}}==

One can use ''set constructors'' like in [[#Delphi|Delphi]].

<tt>alphabet</tt>’s type will be <tt>set of char</tt>.

const

alphabet = ['a'..'z'];

begin

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.

=={{header|Frink}}==

The following produces a lazy enumerating sequence of the characters.

To produce a non-lazy array of the characters, you can wrap the above in a <CODE>toArray</CODE> call:

 

=={{header|Furor}}==

#k 'a 'z ++ {|| {} print SPACE |} NL end

{{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

</pre>

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=debd3987d4db75099032a86927978046 Click this link to run this code]'''

Dim siCount As Short

 

Next

 

Output:

<pre>

 

=={{header|Go}}==

p := make([]byte, 26)

for i := range p {

}

return string(p)

 

=={{header|Groovy}}==

Test

 

=={{header|Haskell}}==

 

 

Or, equivalently:

alpha = enumFromTo 'a' 'z'

 

main :: IO ()

 

{{Out}}

<pre>"abcdefghijklmnopqrstuvwxyz"</pre>

 

=={{header|Huginn}}==

import Text as text;

 

)

);

{{Out}}

<pre>abcdefghijklmnopqrstuvwxyz

 

E.g.

 

procedure lower_case_letters() # entry point for function lower_case_letters

return &lcase # returning lower caser letters represented by the set &lcase

write(lower_case_letters()) # output of result of function lower_case_letters()

end

 

=={{header|J}}==

thru&.(a.&i.)/'az'

and, obviously, other variations are possible.

 

=={{header|Java}}==

 

public static void main(String[] args) {

System.out.printf("lower ascii: %s, length: %s", sb, sb.length());

}

 

Output:

For Unicode characters beyond this range, in ES5 we have to enter a pair of Unicode number escapes.

 

 

function cRange(cFrom, cTo) {

return cRange(cFrom, cTo);

 

 

Returns:

 

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

 

 

function cRange(cFrom, cTo) {

['a', 'z'],

['🐐', '🐟']

 

Output:

 

 

{{works with|ECMAScript|6}}

for (var i = 97; i <= 122; i++) {

letters.push(String.fromCodePoint(i))

 

Or, if we want to write a more general ES6 function:

 

// enumFromTo :: Enum a => a -> a -> [a]

const enumFromTo = (m, n) => {

['🐐', '🐟']

]));

{{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

א ב ג ד ה ו ז ח ט י ך כ ל ם מ ן נ ס ע ף פ ץ צ ק ר ש ת

🐐 🐑 🐒 🐓 🐔 🐕 🐖 🐗 🐘 🐙 🐚 🐛 🐜 🐝 🐞 🐟</pre>

 

=={{header|jq}}==

produces:

 

 

=={{header|Jsish}}==

var letterA = "a".charCodeAt(0);

var lowers = Array(26);

26

=!EXPECTEND!=

 

{{out}}

{{works with|Julia|0.6}}

 

 

{{out}}

=={{header|K}}==

<tt>`c$</tt> casts a list of integers to a string of characters; <tt>!26</tt> produces a list of the integers from 0 to 25. So the lower-case ASCII alphabet can be generated using:

{{out}}

<pre>"abcdefghijklmnopqrstuvwxyz"</pre>

 

=={{header|Keg}}==

 

=={{header|Kotlin}}==

 

fun main() {

 

println(alphabet)

 

{{out}}

 

=={{header|Lambdatalk}}==

 

1) We define code2char & char2code as primitives:

{S.map code2char {S.serie {char2code 0} {char2code 9}}}

-> 0 1 2 3 4 5 6 7 8 9

 

=={{header|LC3 Assembly}}==

 

LD R0,ASCIIa

 

ASCIIa .FILL 0x61

Output:

<pre>abcdefghijklmnopqrstuvwxyz</pre>

 

=={{header|Lingo}}==

repeat with i = 97 to 122

alphabet.add(numtochar(i))

end repeat

put alphabet

 

=={{header|Logo}}==

Straightforward, assuming ASCII:

Slightly less straightforward, but without the magic numbers:

Same output either way:

{{Out}}

=={{header|Lua}}==

===to table===

local letters = {}

for ascii = 97, 122 do table.insert(letters, string.char(ascii)) end

 

local alpha = getAlphabet()

{{Out}}

<pre>yay</pre>

 

===to string===

local function ascii(f,t) local tab={} for i=f,t do tab[#tab+1]=string.char(i) end

return table.concat(tab)

end

{{Out}}

<pre>> ./lowercaseascii.lua

 

=={{header|M2000 Interpreter}}==

\\ old style Basic, including a Binary.Or() function

Module OldStyle {

}

CALL OldStyle

 

=={{header|Maple}}==

{{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"</pre>

'''Method 1''': Using a Range Variable.

 

-- user-defined function that returns the ASCII code for string character ch.

code(ch):=str2vec(ch)[0

 

-- Characters are indexable within the string; for example: substr(lcString,3,1)="d"

 

'''Method 2''': Using a Function.

 

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

 

charseq(code("α"),code("ω"))="αβγδεζηθικλμνξοπρςστυφχψω"

 

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

{{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"}</pre>

 

=={{header|MATLAB}} / {{header|Octave}}==

or alternatively

{{Out}}<pre> abcdefghijklmnopqrstuvwxyz</pre>

 

=={{header|Maxima}}==

{{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] </pre>

 

=={{header|Mercury}}==

:- interface.

 

io.print_line(Alphabet, !IO).

 

{{out}}

<pre>

 

=={{header|MiniScript}}==

for i in range(code("a"), code("z"))

letters.push char(i)

end for

 

 

{{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"]</pre>

 

=={{header|MUMPS}}==

===Caché===

{{works with|Caché ObjectScript}}

LOWASCMIN

set lowstr = ""

write lowstr

quit

 

{{out}}<pre>

===Standard MUMPS===

{{works with|DSM, MSM}}

LONG SET D=""

FOR X=97:1:122 WRITE D,$C(X) SET D=","

W !

Q

 

{{out}}<pre>

 

=={{header|Nanoquery}}==

for i in range(ord("a"), ord("z"))

lowercase.append(chr(i))

end

{{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]</pre>

 

=={{header|Neko}}==

<doc>Generate lower case ASCII, in Neko</doc>

**/

}

 

 

{{out}}

 

=={{header|NESL}}==

 

=={{header|Nim}}==

let alpha: Slice[char] = 'a'..'z'

echo alpha # (a: a, b: z)

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]

 

=={{header|OCaml}}==

- : char array =

[|'a'; 'b'; 'c'; 'd'; 'e'; 'f'; 'g'; 'h'; 'i'; 'j'; 'k'; 'l'; 'm'; 'n'; 'o';

 

=={{header|Oforth}}==

Oforth characters are integers. This list is a list of 26 integers

 

If necessary, these integers can be added to a string to have a indexed string of chars

 

=={{header|PARI/GP}}==

 

 

Output:<pre>"abcdefghijklmnopqrstuvwxyz"</pre>

 

=={{header|Pascal}}==

var

alphabet: set of char;

'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'

];

 

=={{header|Perl}}==

 

=={{header|Phix}}==

<span style="color: #004080;">string</span> <span style="color: #000000;">az</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">az</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'z'</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'a'</span><span style="color: #0000FF;">)</span>

In Phix there is really not much difference between 1..26 and 'a'..'z', and none ''at all'' between 'a'..'z' and 97..122.

{{out}}

<pre>

"abcdefghijklmnopqrstuvwxyz"

"abcdefghijklmnopqrstuvwxyz"

 

=={{header|Phixmonti}}==

'a' 'z' 2 tolist

for

tochar 0 put

endfor

Simplest

 

=={{header|PHP}}==

$lower = range('a', 'z');

var_dump($lower);

 

=={{header|Picat}}==

Alpha1 = (0'a..0'z).map(chr),

println(Alpha1),

Alpha2 = [chr(I) : I in 97..122],

 

{{out}}

 

=={{header|PicoLisp}}==

 

=={{header|PL/I}}==

declare 1 ascii union,

2 letters (26) character (1),

put edit (letters) (a);

 

Output:

<pre>

</pre>

Alternative, using library:

 

letter = lowercase('A');

i = index(collate(), letter);

Output:

<pre>

 

=={{header|PL/M}}==

 

/* CP/M BDOS SYSTEM CALL */

CALL PR$STRING( .LC );

 

{{out}}

<pre>

 

=={{header|PL/SQL}}==

sbAlphabet varchar2(100);

Begin

End loop;

Dbms_Output.Put_Line(sbAlphabet);

Output:

<pre>

 

=={{header|Plain English}}==

Start up.

Generate the lowercase ASCII alphabet giving a string.

If the letter is the little-z byte, exit.

Add 1 to the letter.

{{out}}

<pre>

 

=={{header|PowerShell}}==

$asString = 97..122 | ForEach-Object -Begin {$asArray = @()} -Process {$asArray += [char]$_} -End {$asArray -join('')}

$asString

{{Out}}

<pre>

abcdefghijklmnopqrstuvwxyz

</pre>

$asArray

{{Out}}

<pre>

 

'''Alternative:'''

-join [Char[]] (97..122)

{{Out}}

<pre>

 

'''Alternative as of PowerShell-v6.0.0rc:'''

-join ('a'..'z')

{{Out}}

<pre>

=={{header|Prolog}}==

Works with SWI-Prolog 6.5.3

maplist(atom_codes, [From, To], [[C_From], [C_To]]),

bagof([C], between(C_From, C_To, C), L1),

maplist(atom_codes,L, L1).

Output :

<pre> ?- a_to_z(a, z, L).

 

=={{header|Python}}==

from string import ascii_lowercase

 

# Generation:

 

Or, as a particular instance of a more general enumeration pattern:

{{Works with|Python|3.7}}

 

from inspect import signature

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Enumeration a-z:

The word ''constant'' causes the preceding nest to be evaluated during compilation so ''alpha$'' is a literal, not an expression computed during program evaluation.

 

 

 

{{Out}}

 

=={{header|R}}==

letters

 

# Or generate the same with:

 

=={{header|Racket}}==

 

=={{header|Raku}}==

{{works with|rakudo|2015-10-21}}

 

 

* <code>'a'..'z'</code> is a range literal, it constructs an immutable <code>Range</code> object.

===ASCII version===

This version only works under ASCII machines &nbsp; (where the values of the lowercase '''a''' through the lowercase '''z''' characters are contiguous (and consecutive).

* 08.02.2014 Walter Pachl

*--------------------------------------------------------------------*/

'''Output:'''

<pre>abcdefghijklmnopqrstuvwxyz</pre>

Note that on an '''EBCDIC''' system, &nbsp; there are &nbsp; '''41''' &nbsp; characters between (lowercase) &nbsp; <big><big> a </big></big> &nbsp; ──► &nbsp; <big><big> z </big></big> &nbsp; &nbsp;

<br>(inclusive), &nbsp; some of which don't have viewable/displayable glyphs.

$= /*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 ──► $ */

'''output'''

<pre>

 

=={{header|Ring}}==

put i

 

=={{header|Ruby}}==

 

=={{header|Rust}}==

// An iterator over the lowercase alpha's

let ascii_iter = (0..26)

println!("{:?}", ascii_iter.collect::<Vec<char>>());

{{out}}

<pre>

=={{header|S-lang}}==

Char_Type is just an integer-type so a "range array" can be easily created:

If you need single-char strings, convert thusly:

Let's take a peek:

foreach a (alpha_ch)

() = printf("%c ", a);

{{out}}

<pre>"x"

=={{header|Scala}}==

{{libheader|Scala}}

val lowAlpha = 'a' to 'z' //That's all

// Now several tests

scala.compat.Platform.currentTime - executionStart

} ms]")

Successfully completed without errors. [within 675 ms]

=={{header|Scheme}}==

{{works with|Gauche Scheme}}

{{output}}

<pre>

 

=={{header|Seed7}}==

 

const proc: main is func

end for;

writeln(lower);

 

{{out}}

 

=={{header|Sidef}}==

 

=={{header|Smalltalk}}==

asciiLower := String new.

97 to: 122 do: [:asciiCode |

asciiLower := asciiLower , asciiCode asCharacter

].

 

=={{header|Snobol}}==

 

=={{header|SPL}}==

d = [i+96,0]

a[i] = #.str(d)

> i, 1..#.size(a,1)

#.output(a[i],#.rs)

{{out}}

<pre>

 

=={{header|Standard ML}}==

 

=={{header|Stata}}==

display c(alpha)

display c(ALPHA)

mata

char(97..122)

 

=={{header|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.

(97..122).asAscii; // This example unfortunately throws an error

// for me when running it on version 3.10.2

 

 

Backwards:

"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 ]

 

=={{header|Swift}}==

 

for i in 97...122 {

let char = Character(UnicodeScalar(i))

letters.append(char)

 

=={{header|Tcl}}==

The most common way of doing this in Tcl would be to use a simple literal; it's only 51 characters after all:

Though it could be done like this as well:

scan "az" "%c%c" from to

for {set i $from} {$i <= $to} {incr i} {

}

return $l

 

=={{header|UNIX Shell}}==

In bash or ksh93 with <tt>braceexpand</tt> set:

 

In zsh with <tt>braceccl</tt> set:

 

Either way, you can display the result like this:

 

 

{{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</pre>

=={{header|Ursa}}==

Creates a string named low containing the lower case ASCII alphabet.

decl string low

for (set i (ord "a")) (< i (+ (ord "z") 1)) (inc i)

set low (+ low (chr i))

end for

 

=={{header|VBA}}==

{{works with|Visual Basic|6}}

 

Option Explicit

 

Erase strarrTemp

End Function

{{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</pre>

 

=={{header|VBScript}}==

arr = Split(range,"..")

For i = Asc(arr(0)) To Asc(arr(1))

 

WScript.StdOut.Write ASCII_Sequence(WScript.Arguments(0))

{{out}}

<pre>C:\>cscript /nologo ascii_sequence.vbs a..z

 

=={{header|Verilog}}==

integer i;

end

endmodule

{{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 </pre>

 

=={{header|Vim Script}}==

for c in range(0, 25)

let lower += [nr2char(c + char2nr("a"))]

 

or:

 

=={{header|Visual Basic}}==

String.Join() is used to print the list, converted to array, without looping through it.

 

 

Sub Main()

 

End Module

 

{{out}}

</pre>

 

mut p := []u8{len: 26}

for i in 97..123 {

}

return p.bytestr()

 

=={{header|WebAssembly}}==

 

(import "wasi_unstable" "fd_write"

drop

)

 

{{out}}

 

=={{header|Wren}}==

for (c in 97..122) alpha.add(String.fromByte(c))

 

{{out}}

 

=={{header|xEec}}==

 

=={{header|XLISP}}==

(defun add-chars (x y s)

(if (<= x y)

(add-chars (+ x 1) y (string-append s (string (integer->char x))))

s))

 

=={{header|XPL0}}==

 

=={{header|Z80 Assembly}}==

ld a,'a' ;data

ld b,26 ;loop counter

 

Alphabet:

 

{{out}}

 

=={{header|zkl}}==

["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"

 

=={{header|Zig}}==

 

pub fn main() !void {

try stdout_wr.print("{c} ", .{l});

try stdout_wr.writeByte('\n');