Generate lower case ASCII alphabet: Difference between revisions

{{task|String_manipulation}}

 

 

 

 

 

=={{header|0815}}==

This creates the list in the queue

 

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

LOWER CSECT

USING LOWER,R15 set base register

PG DS CL26 buffer

YREGS

{{out}}

<pre>

abcdefghijklmnopqrstuvwxyz

</pre>

 

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

 

=={{header|Ada}}==

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

</pre>

 

FOR i%=0TO25

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

NEXT

 

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

& whl

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

& !seq !c:?seq

)

 

=={{header|C}}==

 

#define N 26

return EXIT_SUCCESS;

}

 

 

 

{

using System;

}

}

 

=={{header|Clojure}}==

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

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

 

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

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

 

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

 

var

write(ch);

end;

 

=={{header|EchoLisp}}==

;; 1)

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

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

→ abcdefghijklmnopqrstuvwxyz

 

=={{header|Elixir}}==

'abcdefghijklmnopqrstuvwxyz'

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

 

=={{header|Erlang}}==

 

{{Output}}

<pre>"abcdefghijklmnopqrstuvwxyz"</pre>

 

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

abcdefghijklmnopqrstuvwxyz

абвгдеёжзийклмнопрстуфхцчшщъыьэюя</pre>

 

=={{header|Forth}}==

Generate a string filled with the lowercase ASCII alphabet

 

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

p := make([]byte, 26)

for i := range p {

}

return string(p)

 

=={{header|Groovy}}==

Test

 

=={{header|Haskell}}==

 

 

=={{header|Icon}} and {{header|Unicon}}==

You can just use the keyword:

<pre>&lcase</pre>

 

E.g.

 

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

 

<pre>lower ascii: abcdefghijklmnopqrstuvwxyz, length: 26</pre>

=={{header|JavaScript}}==

 

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

 

=={{header|jq}}==

produces:

 

<tt>"abcdefghijklmnopqrstuvwxyz"</tt>

 

=={{header|Julia}}==

 

 

 

 

=={{header|Logo}}==

Straightforward, assuming ASCII:

Slightly less straightforward, but without the magic numbers:

Same output either way:

{{Out}}

 

=={{header|Lua}}==

end

 

local alpha = getAlphabet()

{{Out}}

<pre>yay</pre>

 

{{Out}}

 

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

:- interface.

 

io.print_line(Alphabet, !IO).

 

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

var

begin

 

=={{header|Perl}}==

 

 

 

=={{header|PHP}}==

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

var_dump($lower);

 

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

abcdefghijklmnopqrstuvwxyz

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

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

</pre>

 

=={{header|Python}}==

from string import ascii_lowercase

 

# Generation:

 

 

 

=={{header|R}}==

letters

 

=={{header|Racket}}==

 

=={{header|REXX}}==

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

 

===idiomatic version===

'''output'''

<pre>

</pre>

 

 

 

=={{header|Rust}}==

// An iterator over the lowercase alpha's

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

{{libheader|Scala}}

// Now several tests

'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'),

 

println(s"Successfully completed without errors. [within ${

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

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

C:\>cscript /nologo ascii_sequence.vbs A..F

A B C D E F</pre>

 

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

for c in range(0, 25)

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

 

or:

 

=={{header|xEec}}==

 

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