[Question]
  [
Write a program to print or return one of these strings verbatim:
```
abcdefghijkmnopqrstuvwxyz
ABCDEFGHIJKMNOPQRSTUVWXYZ
```
Notice that there is [no L](https://en.wikipedia.org/wiki/The_First_Noel).
  
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 49 bytes
```
+++++++++++++[->+>+++++>+<<<]>--[->.+<]>>+[-<+.>]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGxlE69pp24FZdto2Njaxdrq6QCE9bSDLDihpo61nF/v/PwA "brainfuck – 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.
[Answer]
# [Octave](https://www.gnu.org/software/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!](https://tio.run/##y08uSSxL/Z9mq6en999BQzNa3VHdSt1bXcHc3MrSIPZ/SmZxgUaahqbmfwA)
### 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.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 3 bytes
```
⁻βl
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3M6@0WCNJR0EpR0lT0/r///@6ZTkA "Charcoal – Try It Online") Link is to verbose version of code. Explanation: `β` is a Charcoal variable predefined to the lowercase alphabet.
```
⁻αL
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3M6@0WCNRR0HJR0lT0/r///@6ZTkA "Charcoal – Try It Online") Link is to verbose version of code. Explanation: `α` is a Charcoal variable predefined to the uppercase alphabet.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 23 bytes, original answer
```
printf %s {a..k} {m..z}
```
[Try it online!](https://tio.run/##S0oszvj/v6AoM68kTUG1WKE6UU8vu1ahOldPr6r2/38A "Bash – Try It Online")
# [Bash](https://www.gnu.org/software/bash/), 21 bytes, thanks to Nahuel Fouilleul
```
echo {a..z}|tr -d \ l
```
[Try it online!](https://tio.run/##S0oszvj/PzU5I1@hOlFPr6q2pqRIQTdFIUYh5/9/AA "Bash – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 22 bytes
```
!Map(cat,letters[-12])
```
[Try it online!](https://tio.run/##K/r/X9E3sUAjObFEJye1pCS1qDha19AoVvP/fwA "R – Try It Online")
Exits with an error; credit to [ovs](https://codegolf.stackexchange.com/users/64121/ovs).
# [R](https://www.r-project.org/), 23 bytes
```
x=Map(cat,letters[-12])
```
[Try it online!](https://tio.run/##K/r/v8LWN7FAIzmxRCcntaQktag4WtfQKFbz/38A "R – Try It Online")
Also credit to ovs.
# [R](https://www.r-project.org/), 24 bytes
```
cat(letters[-12],sep="")
```
[Try it online!](https://tio.run/##K/r/PzmxRCMntaQktag4WtfQKFanOLXAVklJ8/9/AA "R – Try It Online")
[Answer]
# Various Languages, 25 bytes
```
abcdefghijkmnopqrstuvwxyz
```
or
```
ABCDEFGHIJKMNOPQRSTUVWXYZ
```
In many languages, the shortest solution is also the least interesting.
Works in: [///](https://esolangs.org/wiki////), [ARBLE](https://github.com/TehFlaminTaco/ARBLE), [PHP](https://php.net/), [ReRegex](https://github.com/TehFlaminTaco/ReRegex), ...
[Answer]
# [Vyxal 3](https://github.com/Vyxal/Vyxal/tree/version-3),, 4 bytes
```
n'l-
```
[Try it Online!](https://vyxal.github.io/latest.html#WyIiLCIiLCJuJ2wtIiwiIiwiIiwiMy4wLjAiXQ==)
First Vyxal answer, so I’m sure there may be a more concise way, but I like that it almost reads ‘no el’!
[Answer]
# [PowerShell Core](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 25 bytes
```
-join$('a'..'k';'m'..'z')
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XzcrPzNPRUM9UV1PTz1b3Vo9F8SoUtf8/x8A "PowerShell – 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](https://github.com/TryItOnline/TioSetup/wiki/Powershell), all flavors, 27 bytes
```
'abcdefghijkmnopqrstuvwxyz'
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/Xz0xKTklNS09IzMrOzcvv6CwqLiktKy8orJK/f9/AA "PowerShell – 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](https://github.com/TryItOnline/TioSetup/wiki/Powershell), all flavors, 31 bytes
```
-join([char[]]$(65..75;77..90))
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XzcrPzNPIzo5I7EoOjZWRcPMVE/P3NTa3FxPz9JAU/P/fwA "PowerShell – 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
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 14 bytes
```
26*#
Y`#`l
l
```
[Try it online!](https://tio.run/##K0otycxLNPz/n8vITEuZKzJBOSGHK4fr/38A "Retina – 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.)
```
l
```
Remove the `l`.
The best I could do in [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d) 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!](https://tio.run/##K0otycxL/P8/JCEnIT6HqzZBhauKK4fr/38A "Retina 0.8.2 – 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.
```
l
```
Remove the `l`.
[Answer]
# [CP-1610](https://en.wikipedia.org/wiki/General_Instrument_CP1600) machine code, 14 DECLEs1 = 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
[![screenshot](https://i.stack.imgur.com/hiclB.gif)](https://i.stack.imgur.com/hiclB.gif)
[Answer]
# [RProgN 2](https://github.com/TehFlaminTaco/RProgN-2), 4 bytes
```
a`l-
```
[Try it online!](https://tio.run/##Kyooyk/P0zX6/z8xIUf3/38A "RProgN 2 – Try It Online")
Or for upper-case
```
A`L-
```
[Try it online!](https://tio.run/##Kyooyk/P0zX6/98xwUf3/38A "RProgN 2 – Try It Online")
Just removes literal `L` from the alphabet builtin.
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), 14 bytes
```
:h<_
jjYZZPtmx
```
[Try it online!](https://tio.run/##K/v/3yrDJp4rKysyKiqgJLfi/38A "V (vim) – Try It Online")
[Yet another](https://codegolf.stackexchange.com/questions/94983/now-i-know-my-abcs-wont-you-come-and-golf-with-me/94989#94989) post uses [the trick](https://codegolf.stackexchange.com/questions/86986/print-a-tabula-recta/87010#87010) found by [Lynn](https://codegolf.stackexchange.com/users/3852/lynn).
[Answer]
# [Perl 5](https://www.perl.org/), 13 bytes
```
say A..K,M..Z
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVLBUU/PW8dXTy/q//9/@QUlmfl5xf91fU31DAwB "Perl 5 – Try It Online")
[Answer]
# 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!](https://tio.run/##TVFNU8IwED0nv2Ktw5AIZQCVA4gXj44XT47AIU3SNk6aME2LrQx/3brgIF52533s251ZGWdSdp0IBTB4jRgdZdYnwkJK0zkp/A6EHUI8ndFyToRSJ9h/7w8mlITKhwRbnfyyz31KZLE9AZSFkmc@xglKPtwXlH9jpa4oj4Av6M4bBSmTuShvICBBr42TtlYaHkKljB/lj5QaV0EhjGOc7nEPmqHUobbV6n4y3SwoSdkvxgCyLdGesqgXoiFc6Iuwdi9C5sZpkF7peXRUjxsaWMJ4CC1C5WF/tkNvPH3DqHbJWO2CyZxWcDqYp3zVDAYbvjjAZ26sBtbCFYY0T7f/LwHWM5C0lQ587TCpQfHQdd8ytSILXVzM7rDgH5bo1/YH "C (gcc) – 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.
```
[Answer]
# [Python](https://www.python.org), 39 bytes
```
print(25*"%c"%(*{*range(65,91)}-{76},))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwYKlpSVpuhY31QuKMvNKNIxMtZRUk5VUNbSqtYoS89JTNcxMdSwNNWt1q83NanU0NSHKobpgugE)
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.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 19 bytes
```
([*?a..?z]-[?l])*''
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsESFTsbm6WlJWm6Fps1orXsE_X07KtidaPtc2I1tdTVITILoBSUBgA)
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.
[Answer]
# [Python 3](https://docs.python.org/3/), 71 bytes
```
import string as s
print(s.ascii_lowercase[:11]+s.ascii_lowercase[12:])
```
[Try it online!](https://tio.run/##K6gsycjPM/7/PzO3IL@oRKG4pCgzL10hsVihmKsAyCzRKNZLLE7OzIzPyS9PLUpOLE6NtjI0jNXGFDY0sorV/P8fAA "Python 3 – Try It Online")
[Answer]
# 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](http://xpather.com/i1C7g8C1).
---
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.
[Answer]
# [Haskell](https://www.haskell.org/), 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](https://wiki.haskell.org/List_comprehension):
```
[x|x<-['A'..'Z'],x/='L']
```
[Answer]
# [Python 3](https://docs.python.org/3/), 51 50 bytes
```
print(''.join(chr(i+65)for i in range(26)if i-11))
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EQ11dLys/M08jOaNII1PbzFQzLb9IIVMhM0@hKDEvPVXDyEwzM00hU9fQUFPz/38A "Python 3 – Try It Online")
Simple iteration combining `range` and `chr`.
-1 byte thank to [@UndoneStudios](https://codegolf.stackexchange.com/users/110681)'s amazing hint of using `str.join`
---
# [Python 3](https://docs.python.org/3/), 54 bytes
```
a=*range(65,91),
print(*map(chr,a[:11]+a[12:]),sep='')
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P9FWqygxLz1Vw8xUx9JQU4eroCgzr0RDKzexQCM5o0gnMdrK0DBWOzHa0MgqVlOnOLXAVl1d8/9/AA "Python 3 – Try It Online")
Using tuple destructuring.
[Answer]
# [morsecco](https://codegolf.meta.stackexchange.com/a/26119/72726): 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 `E`ntering 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 `M`ark to start a loop, `K`onvert the number to `T`ext and `W`rite it to stdout.
* Now comes the golfing trick: line 3 `A`dds –75 (`K`) and skips after `--.-` is zero (so the last line handles the `L` skipping by `E`ntering 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 `A`dds 91 (–75 + –15 + 91 = 1, so the value is incremented) and `G`oes 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 `R`ead the source code from the empty address, `C`ut it after the `Z` and `O`utput. Yes, such tricks are probably legal when golfing, but boring:
```
ABCDEFGHIJKMNOPQRSTUVWXYZ.   .-. -.-. --..- ---
```
[Answer]
# [Uiua](https://uiua.org), 11 [bytes](https://codegolf.stackexchange.com/a/265917/97916)
```
▽≠@l.+@a⇡26
```
[Try it!](https://uiua.org/pad?src=0_3_1__ZiDihpAg4pa94omgQGwuK0Bh4oehMjYKCmYK)
```
▽≠@l.+@a⇡26
        ⇡26  # range from 0 to 25
     +@a     # add letter a
    .        # duplicate
 ≠@l         # where is it not equal to l?
▽            # keep
```
[Answer]
# [APL (dzaima/APL)](https://github.com/dzaima/APL), 6 bytes
```
⎕A~'L'
```
[Try it online!](https://tio.run/##SyzI0U2pSszMTfz/qHfeo7YJGv8f9U11rFP3Uf@v@R8A "APL (dzaima/APL) – Try It Online")
[Answer]
# [sclin](https://github.com/molarmanful/sclin), 9 bytes
```
$abc"l"--
```
[Try it on scline!](https://scline.fly.dev/##H4sIAOYYYGUCA1NJTEpWylHS1QUA1.fRIwkAAAA#)
Very straightforward.
[Answer]
# Google Sheets, 45 bytes
`=sort(replace(join(,char(row(65:90))),12,1,))`
...or **47 bytes**:
`=join(,filter(char(row(65:90)),row(65:90)<>76))`
These formulas are longer than their output.
[Answer]
# [Python 3](https://docs.python.org/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))
```
[Answer]
# [Scala](http://www.scala-lang.org/), ~~48~~ 30 bytes
Saved 18 bytes thanks to @corvus\_192
---
Golfed version. [Try it online!](https://tio.run/##NY2xCsIwFEX3fMWjS1qoQ9eUDv0AcRAXxeEZ2xhN0pA8xSL9dWOgOB0u515ulGgwTZf7IAm2qB18GMB1GMHmUGJQUUAfAs6nPQXt1LkScHCaoMtN9sIAdl6NgJVd4j2niR@5R5K3smnqoqibyj5Wn1rmM8m48j@tWpZfF7akrxwNqpg2Bp16ohqEnyKN@r3z8Qc)
```
'A'to'Z'patch(11,"",1)mkString
```
[Answer]
# [*Acc!!*](https://github.com/dloscutoff/Esolangs/tree/master/Acc!!), 41 bytes
```
Count i while 25-i {
Write (65+i)*77/76
}
```
[Try it online!](https://tio.run/##S0xOTkr6/985vzSvRCFToTwjMydVwchUN1Ohmiu8KLMkVUHDzFQ7U1PL3Fzf3Iyr9v9/AA "Acc!! – 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 \$)
[Answer]
# [jq](https://stedolan.github.io/jq/), 27 characters
```
[range(65;91)]-[76]|implode
```
Sample run:
```
bash-5.2$ jq -nr '[range(65;91)]-[76]|implode'
ABCDEFGHIJKMNOPQRSTUVWXYZ
```
[Try it online!](https://tio.run/##yyr8/z@6KDEvPVXDzNTa0lAzVjfa3Cy2JjO3ICc/JfX//3/5BSWZ@XnF/3V180pzcnQz8wpKS4CcosRy3fzSEiAHAA "jq – Try It Online")
[Answer]
# [Kotlin](https://kotlinlang.org), 40 35 bytes
```
{(('a'..'z')-'l').joinToString("")}
```
[Try it online!](https://tio.run/##JcuxCYAwEEbh3il@bO6uSAYQdAldIE0kGi8i0UJx9hiw/OC9NeUYtPhTsbmgLHgaAJeL8B0qzYAxH0Fn9CgPMzmylm4SQ5HELinolP6C21beUm/slTkqexZp3vIB "Kotlin – Try It Online")
# [Kotlin](https://kotlinlang.org), 40 35 31 bytes
```
{(('a'..'z')-'l').map(::print)}
```
[Try it online!](https://tio.run/##DcuxDYAgEAXQnil@d3cFDECiWzgADQkRTmLQQsLsSPmKd14tJ53xUZSQlAXdAHhDRvRYtDsOTQ0bZmemQM7RR2Ipk7gSKntf76RNxlwPkcWM@QM "Kotlin – Try It Online")
Lambdas `() -> String` and `() -> Unit`, respectively, that uses [`minus`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/minus.html) applied to a CharRange.
-5 bytes thank to [@corvus\_192](https://codegolf.stackexchange.com/users/46901)'s wonderful reminder that `minus` can be replaced by `-`
-4 bytes on `() -> Unit` by replacing the `forEach` with a `map`.
]