Print the Christmas alphabet

Question

Write a program to print or return one of these strings verbatim:

abcdefghijkmnopqrstuvwxyz ABCDEFGHIJKMNOPQRSTUVWXYZ

Notice that there is no L.

Probably worth saying "Note that there's Noel in there!" to avoid any confusion. — Jonathan Allan
– Jonathan Allan, Commented Nov 23, 2023 at 21:31
Does it have to be printed or can it be returned from a function? — Yousername
– Yousername, Commented Nov 23, 2023 at 21:51

Level River St · Accepted Answer · 2023-11-23 22:47:32Z

brainfuck, 49 bytes

+++++++++++++[->+>+++++>+<<<]>--[->.+<]>>+[-<+.>]

Try it online!

Starting with a cell containing 13 we set up 3 cells containing 13,65,13. The 65 is the ASCII code of the letter to be printed and the other cells are down-counters (which are adjusted to 11 and 14 before use.) A nice feature is that the loop for printing the first 11 letters increments the ASCII code after printing and the loop printing the last 14 letters increments the ASCII code before printing, thereby skipping L naturally.

Neil · Accepted Answer · 2023-11-24 00:17:06Z

Charcoal, 3 bytes

⁻βl

Try it online! Link is to verbose version of code. Explanation: β is a Charcoal variable predefined to the lowercase alphabet.

⁻αL

Try it online! Link is to verbose version of code. Explanation: α is a Charcoal variable predefined to the uppercase alphabet.

Luis Mendo · Accepted Answer · 2023-11-24 10:37:13Z

Octave / MATLAB, 21 18 bytes

Anonymous function that takes no inputs and outputs the string with uppercase letters.

@()['A':'K' 77:90]

Try it online!

How it works

The code concatenates the two ranges of letters: before and after the 'L'. The second range is defined numerically to save two bytes. This can be done because concatenating chars and numbers implicitly converts each number to the char with the corresponding codepoint.

Jonah · Accepted Answer · 2023-11-24 17:45:32Z

8

Bash, 23 bytes, original answer

printf %s {a..k} {m..z}

Try it online!

Bash, 21 bytes, thanks to Nahuel Fouilleul

echo {a..z}|tr -d \ l

Try it online!

edited Nov 24, 2023 at 17:45

answered Nov 23, 2023 at 23:17

Jonah

34.1k4 gold badges41 silver badges95 bronze badges

3

\$\begingroup\$ -2bytes Try it online! \$\endgroup\$

Nahuel Fouilleul
– Nahuel Fouilleul

2023-11-24 09:10:08 +00:00
Commented Nov 24, 2023 at 9:10
\$\begingroup\$ @NahuelFouilleul Nice one, added as separate entry. \$\endgroup\$

Jonah
– Jonah

2023-11-24 17:46:08 +00:00
Commented Nov 24, 2023 at 17:46

Add a comment |

Giuseppe · Accepted Answer · 2023-11-25 20:14:04Z

8

R, 22 bytes

!Map(cat,letters[-12])

Try it online!

Exits with an error; credit to ovs.

R, 23 bytes

x=Map(cat,letters[-12])

Try it online!

Also credit to ovs.

R, 24 bytes

cat(letters[-12],sep="")

Try it online!

edited Nov 25, 2023 at 20:14

answered Nov 23, 2023 at 21:48

Giuseppe

29.4k3 gold badges33 silver badges106 bronze badges

4

\$\begingroup\$ x=Map(cat,letters[-12]) saves one I think. Could also think about exiting with error with !Map... \$\endgroup\$

ovs
– ovs

2023-11-23 23:21:03 +00:00
Commented Nov 23, 2023 at 23:21
\$\begingroup\$ @ovs thanks, both great improvements! \$\endgroup\$

Giuseppe
– Giuseppe

2023-11-25 20:14:14 +00:00
Commented Nov 25, 2023 at 20:14

Add a comment |

Neil · Accepted Answer · 2023-11-24 09:39:08Z

Retina, 14 bytes

 26*# Y`#`l l

Try it online! Outputs in lowercase but if the program is uppercased then it will output in uppercase instead. Explanation:

 26*#

Insert 26 #s. (I can't use the default _ because that's a special transliteration character.)

Y`#`l

Translate each # in turn into the next character of the alphabet. (It's possible to skip the l here but it's longer overall.)

Remove the l.

The best I could do in Retina 0.8.2 without resorting to 26-byte hard-coding was 27 bytes, but with some inspiration from @FryAmTheEggman I got it down to 16 15 bytes:

T`l`_l }`$ z l

Try it online! Outputs in lowercase but if the program is uppercased then it will output in uppercase instead. Explanation:

T`l`_l

Move all of the letters so far one step backwards in the alphabet, but delete any a.

$ z

Append a z to the current string.

}`

Repeat the above until the transformation becomes idempotent. This happens when the string is the entire alphabet; the a is deleted, the b-z get transliterated into a-y, and another z is appended.

Remove the l.

I was fiddling in Retina 1 but didn't think of manually inserting the correct number of things. Luckily, my idea didn't use any new features. — FryAmTheEggman
– FryAmTheEggman, Commented Nov 24, 2023 at 3:27
@FryAmTheEggman That's a great idea... but I still golfed some more bytes off! — Neil
– Neil, Commented Nov 24, 2023 at 8:48
... and also a lot of bytes off of two of my other Retina 0.8.2 answers... — Neil
– Neil, Commented Nov 24, 2023 at 10:07
Nice! Using the transliterate to also remove the byte and close the loop makes it a very clean looking solution. — FryAmTheEggman
– FryAmTheEggman, Commented Nov 24, 2023 at 16:03

Albert.Lang · Accepted Answer · 2023-11-27 06:55:35Z

Python, 39 bytes

print(25*"%c"%(*{*range(65,91)}-{76},))

Attempt This Online!

Only 5 bytes longer than hardcoding the entire thing ...

How?

Unlike dictionaries, sets are in general not guaranteed to preserve insertion order, so why does this work?

C-Python implementation detail: (small) integers are their own hash values.

ATaco · Accepted Answer · 2023-11-23 21:57:42Z

Various Languages, 25 bytes

abcdefghijkmnopqrstuvwxyz

or

ABCDEFGHIJKMNOPQRSTUVWXYZ

In many languages, the shortest solution is also the least interesting.

Works in: ///, ARBLE, PHP, ReRegex, ...

Nick Kennedy · Accepted Answer · 2023-11-23 22:23:17Z

6

Vyxal 3,, 4 bytes

n'l-

Try it Online!

First Vyxal answer, so I’m sure there may be a more concise way, but I like that it almost reads ‘no el’!

answered Nov 23, 2023 at 22:23

Nick Kennedy

21.2k3 gold badges18 silver badges44 bronze badges

2

\$\begingroup\$ What’s nice with this one is that it almost reads as "noel"! \$\endgroup\$

Pierre Paquette
– Pierre Paquette

2023-11-24 07:08:01 +00:00
Commented Nov 24, 2023 at 7:08

Add a comment |

user314159 · Accepted Answer · 2023-11-23 23:24:23Z

PowerShell Core, 25 bytes

-join$('a'..'k';'m'..'z')

Try it online!

I think solving that with 25 bytes has a certain je ne sais quoi.
Only works in PowerShell Core, Windows PowerShell can't enumerate characters.

PowerShell, all flavors, 27 bytes

'abcdefghijkmnopqrstuvwxyz'

Try it online!

The boring/trivial solution with 27, which would end up as National Fruitcake Day. Somewhat related to CodeGolf, as golfed code and fruitcake have a similar density.

PowerShell, all flavors, 31 bytes

-join([char[]]$(65..75;77..90))

Try it online!

So here's New Year's Eve.
Which is what we also get from the trivial solution in Batch:

Windows Batch, 31 bytes

@echo abcdefghijkmnopqrstuvwxyz

You can even go down to 21 bytes :) And 26 for the all flavours version: Try it online! — Julian
– Julian, Commented Nov 24, 2023 at 0:22

m90 · Accepted Answer · 2023-11-24 10:02:48Z

x86-64 machine code, 17 15 bytes

B0 E6 04 5B AA 2C 4B 3C 01 14 F1 75 F5 AA C3

Try it online!

Following the standard calling convention for Unix-like systems (from the System V AMD64 ABI), this takes in RDI a memory address at which to place the result, as a null-terminated byte string.

In assembly:

f: mov al, -26 # Set AL to -26. r: add al, 'Z'+1 # Add this value to AL to produce a letter. stosb # Write AL to the output string, advancing the pointer. sub al, 'K' # Subtract 'K' from AL. cmp al, 1 # Set flags from calculating AL - 1. CF is 1 iff AL is 0. adc al, 'K'-'Z' # Add (this value + CF) to AL. The net change is +1 or +2. jnz r # If the result is nonzero, repeat the loop. stosb # Write AL (0) to the output string, advancing the pointer. ret # Return.

Arnauld · Accepted Answer · 2023-11-24 11:50:46Z

CP-1610 machine code, 14 DECLEs¹ = 17.5 bytes

_{1. CP-1610 instructions are encoded with 10-bit values (0x000 to 0x3FF), known as DECLEs. Although the Intellivision is also able to work on 16-bit data, programs were really stored in 10-bit ROM back then.}

A routine that writes the Christmas alphabet at R4.

The method used here would be more relevant if there were several letters to skip. With just one letter, using SLLC / ADCR only saves a few CPU cycles compared to CMPI / BEQ.

 ROMW 10 ; use 10-bit ROM ORG $4800 ; map our code at $4800 4800 02BC 0200 MVII #$200, R4 ; R4 = BACKTAB pointer 4802 0004 0148 000D CALL alpha ; invoke our routine 4805 02BD 0030 MVII #$30, R5 ; R5 = pointer into STIC registers 4807 01C0 CLRR R0 4808 0268 MVO@ R0, R5 ; no horizontal delay 4809 0268 MVO@ R0, R5 ; no vertical delay 480A 0268 MVO@ R0, R5 ; no border extension 480B 0002 EIS ; enable interrupts 480C 0017 DECR R7 ; loop forever ;; our routine alpha PROC 480D 02B8 010F MVII #$010F, R0 ; R0 = letter code, initialized to 'A' 480F 02B9 0010 MVII #$0010, R1 ; R1 = mask used to skip 'L' 4811 0059 @loop SLLC R1 ; left-shift the mask into the carry 4812 002F ADCR R7 ; add the carry to the program counter ; (i.e. skip MVO@ if the carry is set) 4813 0260 MVO@ R0, R4 ; write the letter 4814 02F8 0008 ADDI #8, R0 ; update R0 to the next letter 4816 0378 01D7 CMPI #$01D7, R0 ; compare with 'Z' 4818 0226 0008 BLE @loop ; loop if less than or equal 481A 00AF MOVR R5, R7 ; return ENDP

Output

Congratulations on your 200th k-c post and therefore gold k-c tag badge! (I'm guessing that this one was your 200th, given your badge award date...) — Neil
– Neil, Commented Dec 22, 2023 at 16:59
@Neil It probably was this one indeed. Thank you! And congrats on your 402nd k-c post. ;-) — Arnauld
– Arnauld, Commented Dec 22, 2023 at 17:05

ATaco · Accepted Answer · 2023-11-23 21:47:55Z

RProgN 2, 4 bytes

a`l-

Try it online!

Or for upper-case

A`L-

Try it online!

Just removes literal L from the alphabet builtin.

tsh · Accepted Answer · 2023-11-24 02:55:32Z

5

V (vim), 14 bytes

:h<_ jjYZZPtmx

Try it online!

Yet another post uses the trick found by Lynn.

answered Nov 24, 2023 at 2:55

tsh

36.2k2 gold badges36 silver badges133 bronze badges

Add a comment |

CoffeeCrash · Accepted Answer · 2023-11-24 03:34:26Z

5

Python 3, 71 bytes

import string as s print(s.ascii_lowercase[:11]+s.ascii_lowercase[12:])

Try it online!

answered Nov 24, 2023 at 3:34

CoffeeCrash

511 bronze badge

2

\$\begingroup\$ 60: from string import ascii_lowercase as s;print(s[:11]+s[12:]); 58: from string import*;s=ascii_lowercase;print(s[:11]+s[12:]) \$\endgroup\$

tsh
– tsh

2023-11-24 06:55:22 +00:00
Commented Nov 24, 2023 at 6:55
2

\$\begingroup\$ The boring loop is 54 bytes, the most boring solution only 34 bytes \$\endgroup\$

Philippos
– Philippos

2023-11-24 10:39:07 +00:00
Commented Nov 24, 2023 at 10:39
1

\$\begingroup\$ 56: from string import*;a=printable;print(a[10:21]+a[22:36]) \$\endgroup\$

Stef
– Stef

2023-11-24 13:17:17 +00:00
Commented Nov 24, 2023 at 13:17
\$\begingroup\$ Trying to be smart, but sadly 75 bytes: from math import*;print(''.join(chr(n+isqrt(3*n//2))for n in range(56,81))) \$\endgroup\$

Stef
– Stef

2023-11-24 14:06:10 +00:00
Commented Nov 24, 2023 at 14:06
\$\begingroup\$ @Stef followed your way, and in fact got to 65;see my answer \$\endgroup\$

Rhaixer
– Rhaixer

2023-11-28 14:20:28 +00:00
Commented Nov 28, 2023 at 14:20

| Show 2 more comments

Nahuel Fouilleul · Accepted Answer · 2023-11-24 09:17:10Z

5

Perl 5, 13 bytes

say A..K,M..Z

Try it online!

edited Nov 24, 2023 at 9:17

answered Nov 24, 2023 at 9:08

Nahuel Fouilleul

8,6571 gold badge11 silver badges19 bronze badges

Add a comment |

enzo · Accepted Answer · 2023-11-28 14:19:14Z

Python 3, ⁵¹ 50 bytes

print(''.join(chr(i+65)for i in range(26)if i-11))

Try it online!

Simple iteration combining range and chr.

-1 byte thank to @UndoneStudios's amazing hint of using str.join

Python 3, 54 bytes

a=*range(65,91), print(*map(chr,a[:11]+a[12:]),sep='')

Try it online!

Using tuple destructuring.

-1 byte? print(''.join(chr(i+65)for i in range(26)if i-11)) — Rhaixer
– Rhaixer, Commented Nov 28, 2023 at 14:14
@UndoneStudios How could I have not thought of that? Thank you so much! — enzo
– enzo, Commented Nov 28, 2023 at 14:20

Philippos · Accepted Answer · 2023-12-22 21:56:37Z

morsecco: 112 bytes

Yes, that's 4.5 times the size of the pure input, but don't forget that we have only three symbols, resulting in a factor ~5, compared to the full character set.

The whole christmas alphabet in morse code already takes 102 characters; with the overhead of conversion and printing it would be 124 bytes, so this loop solution is shorter (not counting the christmas tree formatting, which starts beautifully with Entering 65, but doesn't really work out well, because whitespaces are sometimes meaningful in Morsecco):

 . -.....- -- - - - -.- - . - .-- . .-..-.-- .- --.. --.- . .---- .- --.. --. . -.--.-- .- --. --.- . -..--.- --.

The first line initializes the stack with 65 (A)
Line 2 sets a jump Mark to start a loop, Konvert the number to Text and Write it to stdout.
Now comes the golfing trick: line 3 Adds –75 (K) and skips after --.- is zero (so the last line handles the L skipping by Entering 77)
The 4th line subtracts another 15 to test for the Z and skips after the --. that closes the loop for the other characters
The 5th line Adds 91 (–75 + –15 + 91 = 1, so the value is incremented) and Goes to the mark that was set. This saves three bytes compared to saving a copy of the value, dropping the modified version and adding 1 to the copy.

Cheating version: 47 bytes

Yes, morsecco ignores all characters except for dot, dash and space, but to cheat, you can Read the source code from the empty address, Cut it after the Z and Output. Yes, such tricks are probably legal when golfing, but boring:

ABCDEFGHIJKMNOPQRSTUVWXYZ. .-. -.-. --..- ---

Kirill L. · Accepted Answer · 2023-11-23 22:26:09Z

4

Ruby, 19 bytes

([*?a..?z]-[?l])*''

Attempt This Online!

Since the task allows simply returning the string instead of printing, I believe it should be acceptable as this snippet. If not, it's +4 for $><< in front.

answered Nov 23, 2023 at 22:26

Kirill L.

14.3k2 gold badges17 silver badges54 bronze badges

2

\$\begingroup\$ I think it would be acceptable to make this a function that returns a list of characters, so this works for 18 bytes: ->{[*?a..?z]-[?l]} \$\endgroup\$

noodle person
– noodle person

2023-11-24 02:39:13 +00:00
Commented Nov 24, 2023 at 2:39

Add a comment |

topskip · Accepted Answer · 2023-11-24 20:01:09Z

XPath 2: 42 41 27 bytes

First attempt: 42 bytes

codepoints-to-string(remove(97 to 122,12))

Explanation:

97 to 122 returns the sequence 97, 98, 99, ... 122
remove( ..., 12) removes the 12th item
codepoints-to-string() converts the numbers to a string

The result of the evaluation is the christmas string. Try it online.

Second attempt 41 bytes, thanks to @Philippos

codepoints-to-string(remove(65 to 90,12))

(upper case letters)

Third attempt (27 bytes), the "trivial" (but so far the shortest) solution (@jonathan-allan)

"abcdefghijkmnopqrstuvwxyz"

is a equally valid XPath expression.

Very nice, thank you for your contribution! You could even save one byte printing the uppercase christmas alphabet: codepoints-to-string(remove(65 to 90,12)) — Philippos
– Philippos, Commented Nov 24, 2023 at 18:19
"abcdefghijkmnopqrstuvwxyz" saves bytes if that is truly a full-program or function (I do not know XPath, but it works in the linked interpreter(?)). — Jonathan Allan
– Jonathan Allan, Commented Nov 24, 2023 at 19:54
This is a perfectly valid XPath expression, so this is the shortest. — topskip
– topskip, Commented Nov 24, 2023 at 20:02

Emily · Accepted Answer · 2023-11-25 17:29:21Z

Haskell, 23 bytes

filter(/='L')['A'..'Z']

Explanation

['A'..'Z'] represents the entire uppercase alphabet, (/='L') is a shorthand for the lambda \x -> x /= 'L'. When both are passed to filter, this keeps all letters from the alphabet that are not L.

Alternatively, this can also be done with an extra byte using list comprehensions:

[x|x<-['A'..'Z'],x/='L']

Nice answer! I'm a bit sad that ['A'..'K']++['M'..'Z'] is shorter by a byte :) — lynn
– lynn, Commented Nov 27, 2023 at 16:20

Mark Ransom · Accepted Answer · 2023-11-26 14:14:36Z

4

Python 3, 50 49 bytes

print(''.join(chr(x+x//76)for x in range(65,90)))

You could save two bytes by using Python 2, but nobody uses that anymore:

Python 2, 47 bytes

print ''.join(chr(x+x/76)for x in range(65,90))

edited Nov 26, 2023 at 14:14

answered Nov 25, 2023 at 18:33

Mark Ransom

1816 bronze badges

1

\$\begingroup\$ You don't need the space before for. \$\endgroup\$

Neil
– Neil

2023-11-25 19:34:57 +00:00
Commented Nov 25, 2023 at 19:34
\$\begingroup\$ @Neil thanks for the hint! \$\endgroup\$

Mark Ransom
– Mark Ransom

2023-11-25 21:20:43 +00:00
Commented Nov 25, 2023 at 21:20
1

\$\begingroup\$ You can save another byte from the Python 2 version: the space after print isn't needed. \$\endgroup\$

DLosc
– DLosc

2023-11-27 16:24:42 +00:00
Commented Nov 27, 2023 at 16:24

Add a comment |

chunes · Accepted Answer · 2023-11-23 21:51:29Z

3

Uiua, 11 bytes

▽≠@l.+@a⇡26

Try it!

▽≠@l.+@a⇡26 ⇡26 # range from 0 to 25 +@a # add letter a . # duplicate ≠@l # where is it not equal to l? ▽ # keep

answered Nov 23, 2023 at 21:51

chunes

27.8k3 gold badges32 silver badges55 bronze badges

2

\$\begingroup\$ Same length alternative: +@a+>10.⇡25 \$\endgroup\$

Bubbler
– Bubbler

2023-11-24 01:10:36 +00:00
Commented Nov 24, 2023 at 1:10

Add a comment |

Yousername · Accepted Answer · 2023-11-23 22:01:36Z

3

APL (dzaima/APL), 6 bytes

⎕A~'L'

Try it online!

answered Nov 23, 2023 at 22:01

Yousername

4,28011 silver badges24 bronze badges

Add a comment |

Mama Fun Roll · Accepted Answer · 2023-11-24 03:31:09Z

3

sclin, 9 bytes

$abc"l"--

Try it on scline!

Very straightforward.

answered Nov 24, 2023 at 3:31

Mama Fun Roll

9,9781 gold badge38 silver badges47 bronze badges

Add a comment |

DLosc · Accepted Answer · 2023-11-24 23:18:00Z

Acc!!, 41 bytes

Count i while 25-i { Write (65+i)*77/76 }

Try it online!

Explanation

Loop i from 0 to 24. Add 65 to convert to uppercase codepoints A through Y; then scale by a linear factor to skip over code point 76 (L). (Division in Acc!! is integer division, but the floating-point version would be \$ 65.86, 66.87, \cdots, 74.97, 75.99, 77.00, 78.01, \cdots, 90.17 \$)

manatwork · Accepted Answer · 2023-11-26 06:50:51Z

jq, 27 characters

[range(65;91)]-[76]|implode

Sample run:

bash-5.2$ jq -nr '[range(65;91)]-[76]|implode' ABCDEFGHIJKMNOPQRSTUVWXYZ

Try it online!

138 Aspen · Accepted Answer · 2023-11-27 12:14:33Z

3

Scala, 48 30 bytes

Saved 18 bytes thanks to @corvus_192

Golfed version. Try it online!

'A'to'Z'patch(11,"",1)mkString

edited Nov 27, 2023 at 12:14

answered Nov 24, 2023 at 10:58

138 Aspen

7,2771 gold badge5 silver badges18 bronze badges

\$\begingroup\$ println("abcdefghijkmnopqrstuvwxyz") saves 12 bytes though. \$\endgroup\$

Jonathan Allan
– Jonathan Allan

2023-11-24 19:50:34 +00:00
Commented Nov 24, 2023 at 19:50
\$\begingroup\$ 30 bytes: 'A'to'Z'patch(11,"",1)mkString (requires -language:postfixOps) \$\endgroup\$

corvus_192
– corvus_192

2023-11-27 11:23:29 +00:00
Commented Nov 27, 2023 at 11:23

Add a comment |

Aiden Chow · Accepted Answer · 2024-02-27 06:57:34Z

3

Pip, 6 5 bytes

-1 byte thanks to @DLosc

zRM'l

~~Yea I think that's about as short as it can get, unless someone has some genius strategy.~~

Turns out I'm not genius enough :P

Try It Online!

edited Feb 27, 2024 at 6:57

answered Nov 28, 2023 at 5:51

Aiden Chow

14.5k1 gold badge22 silver badges61 bronze badges

\$\begingroup\$ Not a genius strategy, but... 5 bytes ;P \$\endgroup\$

DLosc
– DLosc

2024-02-25 06:27:32 +00:00
Commented Feb 25, 2024 at 6:27
\$\begingroup\$ @DLosc I didn't realize that was a thing. Genius :P \$\endgroup\$

Aiden Chow
– Aiden Chow

2024-02-27 06:55:47 +00:00
Commented Feb 27, 2024 at 6:55

Add a comment |

doubleunary · Accepted Answer · 2024-05-23 07:35:24Z

3

Google Sheets, 45 bytes

=sort(replace(join(,char(row(65:90))),12,1,))

...or:

=sort(join(,char(row(65:89)+(11<row(1:25)))))

...or 46 bytes:

=join(,filter(char(row(65:90)),12<>row(1:26)))

These formulas are longer than their output.

edited May 23, 2024 at 7:35

answered Nov 23, 2023 at 21:28

doubleunary

4,6521 gold badge6 silver badges16 bronze badges

4

\$\begingroup\$ Wouldn't it be shorter just to write it literally as abcdefghijkmnopqrstuvwxyz..? \$\endgroup\$

ATaco
– ATaco

2023-11-23 21:46:35 +00:00
Commented Nov 23, 2023 at 21:46
2

\$\begingroup\$ Yes. Kinda defeats the purpose though. Spreadsheet formula languages are not optimal in many code-golf questions. The patterns therein may however be of use in other contexts. \$\endgroup\$

doubleunary
– doubleunary

2023-11-23 21:49:01 +00:00
Commented Nov 23, 2023 at 21:49

Add a comment |

Print the Christmas alphabet

49 Answers 49

brainfuck, 49 bytes

Charcoal, 3 bytes

Octave / MATLAB, 21 18 bytes

How it works

Bash, 23 bytes, original answer

Bash, 21 bytes, thanks to Nahuel Fouilleul

R, 22 bytes

R, 23 bytes

R, 24 bytes

Retina, 14 bytes

Python, 39 bytes

How?

Various Languages, 25 bytes

Vyxal 3,, 4 bytes

PowerShell Core, 25 bytes

PowerShell, all flavors, 27 bytes

PowerShell, all flavors, 31 bytes

Windows Batch, 31 bytes

x86-64 machine code, 17 15 bytes

CP-1610 machine code, 14 DECLEs1 = 17.5 bytes

Output

RProgN 2, 4 bytes

V (vim), 14 bytes

Python 3, 71 bytes

Perl 5, 13 bytes

Python 3, 51 50 bytes

Python 3, 54 bytes

morsecco: 112 bytes

Ruby, 19 bytes

XPath 2: 42 41 27 bytes

Haskell, 23 bytes

Explanation

Python 3, 50 49 bytes

Python 2, 47 bytes

Uiua, 11 bytes

APL (dzaima/APL), 6 bytes

sclin, 9 bytes

Acc!!, 41 bytes

Explanation

jq, 27 characters

Scala, 48 30 bytes

Pip, 6 5 bytes

Google Sheets, 45 bytes

Linked

Related

Hot Network Questions

CP-1610 machine code, 14 DECLEs¹ = 17.5 bytes

Python 3, ⁵¹ 50 bytes