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

ELENA 5.0 :

import system'collections;

{

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 ( index -- addr ) \ index the string like an array (return an address)

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

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

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

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

=={{header|MIPS Assembly}}==

li $t0,'a'

li $t1,26

end_program:

j end_program ;halt the cpu - we're done

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