Find the Missing Letter

Question

Guidelines

Task

Write a method that takes an array of consecutive (increasing) letters as input and that returns the missing letter in the array (lists in some languages).

---

Rules

• This is code golf so the shortest answer in bytes wins!
• You will always get a valid array
• There will always be exactly one letter missing
• The length of the array will always be at least 2.
• The array will always contain letters in only one case (uppercase or lowercase)
• You must output in the same case (uppercase or lowercase) that the input is
• The array will always only go one letter a time (skipping the missing letter)
• The array length will be between 2 and 25
• The first or last element of the array will never be missing

---

Examples

['a','b','c','d','f'] -> 'e'

['O','Q','R','S'] -> 'P'

['x','z'] -> 'y'

['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','w','x','y','z'] -> 'v'

Answer 1

Uiua ^SBCS, 9 bytes

⊢▽¬⊃∊∘⊸+1

Try it!

⊃∊∘ can be replaced with ⤚∊ for -1 byte once ⤚ comes out of experimental.

Explanation

⊢▽¬⊃∊∘⊸+1­⁡​‎⁠‎⁡⁠⁢⁤‏⁠‎⁡⁠⁣⁡‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁢⁣‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁤‏⁠‎⁡⁠⁢⁡‏⁠‎⁡⁠⁢⁢‏‏​⁡⁠⁡‌⁤​‎‎⁡⁠⁣‏‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁢‏‏​⁡⁠⁡‌⁢⁢​‎‎⁡⁠⁡‏‏​⁡⁠⁡‌­
       +1  # ‎⁡increment input
      ⊸    # ‎⁢keeping original input underneath
   ⊃∊∘     # ‎⁣membership mask, keeping incremented input underneath
  ¬        # ‎⁤invert mask
 ▽         # ‎⁢⁡keep
⊢          # ‎⁢⁢first

Answer 2

Python 2 - 76 bytes

Loses to existing Python 2 solution but it's a slightly different approach so I thought I'd post it anyway:

lambda c:[chr(x)for x in range(ord(c[0]),ord(c[0]+26)if chr(x)not in c][0]

Answer 3

Jelly, 7 bytes

.ịOr/Ọḟ

Try it online!

Answer 4

J, 20 bytes

{&a.>:I.1 0 1&E.a.e.

• a.e. boolean mask for the input letters across ascii charset
• 1 0 1&E. new boolean mask indicating if the sequence 101 begins at that index, ie, find any place a "skip" sequence begins
• I. the index of that match, ie, the character before the skipped one
• >: increment by 1, ie, the index of the skipped char within ascii charset
• {&a. pick that index from the ascii charset, ie, return the skipped char

Try it online!

Answer 5

ES6, 125 bytes:

(a=>((s,f)=>(r=(i,b)=>a[i]?r(i+1,b||(s[f](i)-s[f](i-1)-1&&String.fromCharCode(s[f](i-1)+1))):b)(1,0))(a.join(""),"charCodeAt"))

http://jsbin.com/vasoqidawe/edit?console

The returned function needs to be called with an array

(["a","c"])

one could save another 9 bytes through removing .join("") and passing a string:

("ac")

---

ES6, 108 bytes:

(a=>((s,f,o)=>(a.find((_,i)=>(o?++o:o=s[f](i))!==s[f](i)),String.fromCharCode(o)))(a.join(""),'charCodeAt'),0))

http://jsbin.com/tudiribiye/edit?console

Answer 6

Common Lisp, 88 bytes

(lambda(s)(loop as(x y)on s if(>(#1=char-code y)(1+(#1#x)))return(code-char(1+(#1#x)))))

Try it online!

Answer 7

Python 2, 69 bytes

lambda a:chr((ord(a[0])+ord(a[-1]))*-~len(a)/2-sum(ord(x)for x in a))

Try it online!

Some explanations As we know the first and the last elements of the list, we can easily compute the sum of the codes of all the chars in the list + the missed char (using summary formulas of arithmetic progression). The difference between this sum and the sum of the codes of all the chars in the list gives the code of the missed letter.

Answer 8

05AB1E, 9 7 bytes

ǤÝsKçθ

Try it online!

Answer 9

PHP, 43 bytes

for($x=$argn[0];$argn[++$i]==++$x;);echo$x;

Answer 10

Scala, 63 chars, 63 bytes

for(i<-1 to t.size-1)if(t(i-1)+1!=t(i))return (t(i)-1).toChar
0

See TIO link for tests. t is the input (a String), and I output a char. I tried doing it with a string (like this) but I don't think it is correct to output the code of the missing char. This would make the code 3 bytes shorter.

Try It Online!

Answer 11

05AB1E, 5 bytes

ÇŸçsK

Uses the 05AB1E encoding. Try it online!

Answer 12

Japt, 14 bytes

mc
g oUo¹kU md

Try it online!

Answer 13

PHP, 44 bytes

operating on separate command line arguments:

for($c=$argv[1];++$c==$argv[-~++$i];)echo$c;            # 44 bytes
for($c=$argv[$i=1];++$c==$argv[++$i];)echo$c;           # 45 bytes
<?=end(array_diff(range($argv[1],end($argv)),$argv));   # 53 bytes
<?=trim(join(range($argv[1],end($argv))),join($argv));  # 54 bytes

Answer 14

Brain-Flak, 45 bytes

{([{}()]({})){{}({}<>)((<()>))}{}}{}({}[()])

Try it online!

44 bytes of code, and +1 byte for the -c flag.

Surprisingly short for a language terrible at manipulating strings.

Answer 15

Python 3, 92 bytes

from string import *; f=lambda s:{*[a for a in ascii_letters if a>=s[0] and a<=s[-1] ]}^{*s}

Try it online!

Long solution but I like how sets work, and it seemed shorter in my head.

Answer 16

R, 67 bytes

l=letters;L=LETTERS;a=scan(,'');`if`(a==l&&T,l[a!=l][1],L[a!=L][1])

Try it online!

Answer 17

Octave, 34 32 bytes

@(x)char(setdiff(x(1):max(x),x))

Anonymous function; returns the missing character.

Try it online!

Answer 18

x86 Machine Code, 11 bytes

8A 11
41
8A 01
48
38 C2
74 F6
C3  

The above bytes define a function in 32-bit x86 machine code that finds the missing letter. It takes a single parameter, which is a pointer to the first element of a character array. (The length of the array is not needed, and the character array need not be NUL-terminated.)

The function uses the fastcall calling convention, where its parameter is passed in the ECX register. (It isn't essential that this calling convention or ECX be used for the input; we just need a register-based calling convention. You could trivially modify the code to take input in any register.)

The return value (the missing character) is returned in the AL register (low byte of EAX).

Note that characters are assumed to be 1 byte in length. This is perfectly sufficient for 8-bit ASCII characters, but is obviously not guaranteed to work on Unicode characters. The challenge doesn't specify, and the sample inputs only show basic ASCII. The whole world is ASCII, right?

Ungolfed assembly mnemonics:

; char FindMissingChar(char *letters);
Top:
    mov     dl, BYTE PTR [ecx]    ; load nth character from array
    inc     ecx                   ; increment pointer
    mov     al, BYTE PTR [ecx]    ; load n+1th character from array
    dec     eax                   ; decrement AL (shorter than 'dec al')
    cmp     dl, al                ; compare these two characters
    je      L2                    ; keep looping if n+1 is the char expected to follow n
    ret                           ; otherwise, return with the missing character in AL

Try it online!
_{(The TIO link passes the -m32 switch to GCC to ensure that it is compiling in 32-bit mode, and also applies an attribute to ensure the compiler uses the correct calling convention.)}

Answer 19

><>, 12 bytes

i/o;
?/1+:i-

Try it online!

Explanation

i/o;
?/1+:i-

i/            | Push 1 byte input to the stack then move to second line
 /1+:         | Add 1 to the stack top then duplicate it
     i-       | Push 1 byte input and take from the stack top
?/            | Check stack top is 0, if not 0 move back to line 1
 /o;          | Print the stack top

Answer 20

8th, 99 bytes

Rationale

If the distance between letters is greater than two, then there is a missing letter. Letter distance is obtained by computing the difference between ASCII code of each letter.

Code

: f ' nip s:each repeat over n:- 2 n:= if n:1+ "" swap s:+ . reset 1 then depth n:1- while! reset ;

Ungolfed version

: f \ s -- c 
  ' nip s:each    \ convert each letter into its ASCII code and put them on stack
  repeat
    over
    n:- 2 n:=     \ check if there is a missing letter 
    if            
      n:1+        \ compute the ASCII code of missing letter
      "" swap s:+ \ convert ASCII code into printable character
      .           \ print out the missing letter
      reset 1     \ set condition to exit from while!
    then
    depth n:1-    \ verify if there are letters to check
  while!          
  reset           \ clean stack
;

Usage and examples

ok> "abcdf" f
e
ok> "OQRS" f
P
ok> "xz" f
y
ok> "abcdefghijklmnopqrstuwxyz" f
v
ok> "ab" f

ok> "def" f

ok>

Answer 21

Clojure, 102 89 bytes

#(nth(filter(fn[a](not(some #{a}%)))(map char(range(int(first %))(inc(int(last %)))))) 0)

Anonymous function, takes a string as parameter and returns the first missing character.

Seems like clojure ain't that good for golfin'...

Edit: Stripped whitespace and used nth ... 0 instead of first

Answer 22

Japt -h, 6 bytes

â¡Îc+Y

Try it

â¡Îc+Y     :Implicit input of array U
â          :Setwise union with
 ¡         :Map each 0-based index Y in U
  Î        :  First element of U
   c       :  Codepoint
    +Y     :  Add Y
           :Implicit output of last element

Answer 23

Python 3, 62 bytes

Outgolfed, but has a clean string interface :)

def f(s,i=0):a=chr(ord(s[0])+i);return a==s[i]and f(s,i+1)or a

Try it online!

Answer 24

Factor + math.unicode, 29 bytes

[ dup minmax [a,b] swap ∖ ]

Try it online!

Answer 25

PowerShell Core, 36 bytes

param($a)$a[0]..$a[-1]|?{$_-notin$a}

Try it online!

Takes the chars as an array of strings

$a[0]..$a[-1]  # creates a range from the first to the last character in the argument
|?{$_-notin$a} # keeps only the character that is not in the argument

Answer 26

Brainfuck, 39 bytes

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

Try it here!

, a
>+[- unset bit
    <[->+<] add a into bit space
    ,[->->+<<] take b and sub into bit space and move into 3rd cell 
    the bit is now minus 1 if continue and minus 2 if end
    >>[-<<+>>]< move clone back
    ++ end if inconsistency
]
<-.

Answer 27

Perl 5 + -M5.10.0 -F, 31 bytes

28 bytes code + 3 for -F

say grep"@F"!~$_,$F[0]..chop

Try it online!

Explanation

Creates a list of first character ($F[0] as @F is automatically set to the input, $_, split) to last character (chop, which works on $_ by default) and strips out any items that exist in the source string.

Answer 28

Uiua, 10 bytes

▽¬∊⟜:+⊢⟜°⊏

Try it online

Keep non-members of the input in the first character of the input added to each number from zero to the length of the input.

Answer 29

Mathematica, 83 bytes

T=ToCharacterCode;FromCharacterCode[T@#[[Position[Differences@T@#,{2}][[1,1]]]]+1]&

input

[{"a","b","c","d","f"}]

Answer 30

J,30 bytes - till I can get rid of more parentheses!

a.{~((([:i.#)+/a.i.{.)-.a.i.])       'abcef'

Returns d

 a.{~     take from 
 ((([:i.#) number of input bytes
 +/a.i.{.) starting from 2nd input byte
 -.a.i.]) subtract all but missing character from input

Or, a byte longer (31), completely different method but perhaps more elegantly?

a.{~<:a.i.t#~0,~<:2-/\a.i.t=:|.           'STUVX'

    returns W