| Bytes | Lang | Time | Link |
|---|---|---|---|
| 062 | Google Sheets | 250919T093338Z | doubleun |
| 054 | Python 3 | 250919T205423Z | Unmitiga |
| 063 | Python 3.8 prerelease | 250919T032624Z | Ted |
| 007 | 05AB1E | 250920T012628Z | darthbee |
| 043 | R | 250919T133826Z | Glory2Uk |
| 027 | x86_64 machine code | 250919T152201Z | Ifier |
| 069 | JavaScript Node.js | 250919T091146Z | Arnauld |
| 3875 | Vyxal g | 250919T050553Z | lyxal |
| 004 | Vyxal 3 G | 250919T080834Z | Themooni |
| 011 | Charcoal | 250919T063442Z | Neil |
| 013 | TinyAPL | 250919T063325Z | RubenVer |
| 042 | Arturo | 250919T054046Z | chunes |
| 019 | Dyalog APL | 250919T053533Z | Aaron |
Google Sheets, 62 bytes
Assuming that "any letter which is not present (ignoring case)" means to get one of the uniques when lowercase is considered equal to uppercase:
=char(filter(row(65:90),iserror(search(char(row(65:90)),A1))))
This gets #N/A when there are no letters to show.
To get all letters that aren't present, upper and lower case (80 bytes):
=let(a,sort(char({row(65:90);row(97:122)})),ifna(filter(a,iserror(find(a,A1)))))
Python 3, 65 57 54 bytes
lambda s:max({"",*map(chr,range(65,91))}-{*s.upper()})
Saved 8 bytes thanks to Albert.Lang.
Saved 3 bytes thanks to xnor.
Python 3.8 (pre-release), 63 bytes
f=lambda w,n=65:n<91and[c:=chr(n),f(w,n+1)][c in w.upper()]or''
Previous case-sensitive version of question: 61 bytes
f=lambda w,n=32:n<83and[c:=chr(65+n%58),f(w,n+1)][c in w]or''
05AB1E, 7 bytes
lAsмõªн
Explanation:
lAsмõªн
l ; lowercase
A ; all lowercase letters
s ; swap positions in stack
м ; remove anything from the top position in stack (lowercasified input) that occurs in the second position (all lowercase letters)
ª ; append empty string to array
н ; get first item in array
R, 43 bytes
\(s)max(sub(paste("[",s,"]"),"",letters,T))
Converts the argument string into a regular expression by adding [] around it. Then sub removes from the alphabet list all letters that are present in the argument string (replaces them with an empty string). And finally the letter with the highest value is taken - to ensure the output of the empty string only when no letters are present. The argument T added to ignore the case.
If we are allowed to input a list of characters instead of a string (thanks to pajonk for the suggestion):
R, 34 bytes
\(s)setdiff(letters,tolower(s))[1]
x86_64 machine code, 27 bytes
0: 6a ff push 0xffffffffffffffff
2: e3 15 jrcxz 19 <empty>
4: 5a pop rdx
0000000000000005 <checklist>:
5: ac lods al,BYTE PTR ds:[rsi]
6: 24 df and al,0xdf
8: 2c 41 sub al,0x41
a: 3c 1a cmp al,0x1a
c: 73 03 jae 11 <nonalpha>
e: 0f b3 c2 btr edx,eax
0000000000000011 <nonalpha>:
11: e2 f2 loop 5 <checklist>
13: 0f bc c2 bsf eax,edx
16: 04 61 add al,0x61
18: c3 ret
0000000000000019 <empty>:
19: 58 pop rax
1a: c3 ret
Sysv calling convention, C-style signature of:
unsigned char find_missing(int, const char* string, int, unsigned long long string_length)
Where the ints are to pad arguments into the right registers and can be any value. Returns a lowercase ascii letter ('a'-'z') indicating the missing letter on failure, or any other bit pattern on success (either 255 or 123).
Fairly simple: set up a bitset tracking which letters haven't been encountered, go through each letter, collapse down to lowercase, then if it's a valid letter clear the corresponding bit. Once the entire string has been processed the index of the first set bit in the bitset is added to 'a' to produce the first missing letter (or '{' if all characters were found, which indicates success)
JavaScript (Node.js), 69 bytes
f=(s,n=65)=>n>90?"":eval(`/${c=Buffer([n])+""}/i`).test(s)?f(s,n+1):c
f = ( // f is a recursive function taking:
s, // s = input string
n = 65 // n = ASCII code counter
) => // starting at 65 ('A')
n > 90 ? // if n is greater than 90 ('Z'):
"" // abort and return ""
: // else:
eval( // build a regex:
`/${ // with the character c
c = Buffer([n]) // whose ASCII code is n
+ "" //
}/i` // case insensitive
) // end of eval()
.test(s) ? // if it's matching s:
f(s, n + 1) // do a recursive call with n + 1
: // else:
c // return c
JavaScript (ES6), 65 bytes
Or 69 bytes if we're not allowed to return undefined instead of an empty string when there's no solution.
x=b=>[...x+Date].find(y=>/^([a-zghjklmpqrw])(?!.*\1)/i.test(y+b))
x = // u is a function taking:
b => // b = input string
[...x + Date] // split the source code concatenated with
// "function Date() { [native code] }"
.find(y => // for each character y in this list:
/^([a-zghjklmpqrw])(?!.*\1)/i // look for a letter in any case that only
// appears at the leading position
.test(y + b) // in the concatenation of c and b
) // end of find()
Vyxal g, 31 bitsv2, 3.875 bytes
Ǎ⇩n⊍
Bitstring:
1101010110010110111001000011100
Pretty much an exact port of the v3 answer.
Vyxal 3 -G, 4 bytes
ʀ⦷n⊍
ʀ⦷n⊍
ʀ # to lowercase
⦷ # keep letters
n # lowercase alphabet
⊍ # set difference
# -G flag prints maximum of top at the end of the program
💎
Created with the help of Luminespire.
Charcoal, 11 bytes
Ｆ⁺αβ¿¬№θιＰι
Try it online! Link is to verbose version of code. Outputs the last missing letter by ASCII code. Explanation:
Ｆ⁺αβ
Loop over the uppercase and lowercase alphabet.
¿¬№θι
If this letter is not present in the input...
Ｐι
... overwrite any previous output.
(10 bytes would be possible if either the output could be None if all letters are present or if the code could throw an exception without output if all letters are present.)
TinyAPL, 13 bytes
⊃⬚⍬∘~⍛(⎕u⍪⎕l)
Explanation: remove from all the letters the input, take the first element or the empty list if it's empty
Dyalog APL, 19 bytes
(⊢↑⍨1⌊≢)(⎕A,⎕C⎕A)∘~
~ # Without
( )∘ # with the left argument bound as
⎕A,⎕C⎕A # the uppercase alphabet concated with the lowercase alphabet
( ) # Run atop this train
≢ # Tally of the arg
1⌊ # Minimum with 1
↑⍨ # Take that many from
⊢ # the right
( ) # This all to prevent taking the first element of the result of `without` giving me a prototypal value of ` ` when I really do want an empty list of there is nothing to be found
💎
Created with the help of Luminespire.