Diretrizes

Tarefa

Escreva um método que use uma matriz de letras consecutivas (crescentes) como entrada e retorne a letra que falta na matriz (listas em alguns idiomas).

Regras

• Isso é código de golfe, então a resposta mais curta em bytes vence!
• Você sempre terá uma matriz válida
• Sempre haverá exatamente uma letra faltando
• O comprimento da matriz sempre será pelo menos 2.
• A matriz sempre conterá letras em apenas um caso (maiúsculas ou minúsculas)
• Você deve produzir na mesma caixa (maiúscula ou minúscula) que a entrada é
• A matriz sempre sempre vai uma letra por vez (pulando a letra que falta)
• O comprimento da matriz estará entre 2 e 25
• O primeiro ou o último elemento da matriz nunca estará ausente

Exemplos

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

Pitão , 5 bytes

-rhQe

Experimente online!

C # (.NET Core) , 48 47 46 bytes, entrada como matriz de caracteres

s=>{for(int i=0;s[++i]==++s[0];);return s[0];}

Experimente online!

Explicação: o primeiro elemento da matriz é incrementado, bem como um ponteiro iterando os seguintes elementos. Quando o primeiro elemento e o elemento atual são diferentes, ele retorna o primeiro elemento.

C # (.NET Core) , 58 56 50 bytes, entrada como sequência

s=>{var c=s[0];while(s.IndexOf(++c)>=0);return c;}

Experimente online!

Solução anterior de 58 bytes (mencionada no primeiro comentário):

s=>{for(int i=1;;i++)if(s[i]-s[0]>i)return(char)(s[i]-1);}

Algoritmos usando System.Linq

Os seguintes algoritmos devem adicionar using System.Linq;(18 bytes) à contagem de bytes e, portanto, são mais longos.

Gostei bastante deste (52 + 18 bytes):

s=>{int i=0;return(char)(s.First(c=>c-s[0]>i++)-1);}

E você também tem uma solução de uma linha (45 + 18) bytes:

s=>(char)(s.Where((c,i)=>c-s[0]>i).First()-1)

E uma solução muito inteligente (37 + 18) de bytes, cortesia de Ed'ka:

s=>s.Select(e=>++e).Except(s).First()

Alice , 10 bytes

/X.
\ior@/

Experimente online!

Explicação

Esta é apenas uma estrutura para programas lineares que operam inteiramente no modo Ordinal (processamento de string):

/...
\.../

O código linear real é então:

i.rXo@

O que faz:

i   Read all input.
.   Duplicate.
r   Range expansion. If adjacent letters don't have adjacent code points, the
    intermediate code points are filled in between them. E.g. "ae" would turn
    into "abcde". For the inputs in this challenge, this will simply insert
    the missing letter.
X   Symmetric set difference. Drops all the letters that appear in both strings,
    i.e. everything except the one that was inserted by the range expansion.
o   Output the result.
@   Terminate the program.

Haskell , 33 30 bytes

f a=until(`notElem`a)succ$a!!0

Experimente online!

Ruby, 21 caracteres

->a{[*a[0]..a[-1]]-a}

Retorna uma matriz de elemento único, de acordo com o comentário do proprietário da pergunta .

Exemplo de execução:

irb(main):001:0> ->a{[*a[0]..a[-1]]-a}[['a','b','c','d','f']]
=> ["e"]

Experimente online!

Java 8, 70 57 56 48 46 bytes

a->{for(int i=0;++a[0]==a[++i];);return a[0];}

-14 (70 → 56) e -2 (48 → 46) bytes graças a @CarlosAlejo .
-8 (56 → 48) bytes graças ao @Nevay .

Explicação:

Experimente aqui.

a->{            // Method with char-array parameter and char return-type
  for(int i=0;  //  Start index-integer at 0 and loop as long as
    ++a[0]      //   the previous character + 1 (by modifying the character at index 0)
    ==a[++i];   //   equals the next character (by raising the index by 1 before checking)
  );            //  End of loop
  return a[0];  //  Return the now modified character at index 0 in the array
}               // End of method

C (gcc) , 3335 36. 48. 60 bytes

Todas as otimizações devem estar desativadas e somente no GCC de 32 bits.

f(char*v){v=*v+++1-*v?*v-1:f(v);}

Tome entrada como uma string.

Experimente online!

Python 3 , 74 62 58 44 40 bytes

-12 bytes graças a Erik, o Outgolfer. -18 bytes graças a Leaky Nun. -4 bytes graças ao musicman523.

Recebe a entrada como uma bytestring.

lambda s:chr(*{*range(s[0],s[-1])}-{*s})

Experimente online!

Outra solução legal:

lambda s:chr(*{*range(*s[::~-len(s)])}-{*s})

Mathematica, 46 bytes

Min@Complement[CharacterRange@@#[[{1,-1}]],#]&

JavaScript (ES6), 70 bytes

Entrada como uma matriz de caracteres

(a,p)=>a.some(c=>(q=p+1,p=c.charCodeAt(),p>q))&&String.fromCharCode(q)

Menos golfe

a=>{
  p = undefined;
  for(i = 0; c = a[i]; i++)
  {
    q = p+1
    p = c.charCodeAt()
    if (p>q)
      return String.fromCharCode(q)
  }
}

Teste

F=(a,p)=>a.some(c=>(q=p+1,p=c.charCodeAt(),p>q))&&String.fromCharCode(q)

function update() {
  var a0=A0.value.charCodeAt()
  var a1=A1.value.charCodeAt()
  if (a1>a0) {
    var r = [...Array(a1-a0+1)]
      .map((x,i)=>String.fromCharCode(a0+i))
      .filter(x => x != AX.value)
    I.textContent = r.join('') + " => " + F(r)
  }
  else {
    I.textContent=''
  }
}

update()

input { width: 1em }

Range from <input id=A0 value='O' pattern='[a-zA-Z]' length=1 oninput='update()'>
to <input id=A1 value='T' pattern='[a-zA-Z]' length=1 oninput='update()'>
excluding <input id=AX value='Q' pattern='[a-zA-Z]' length=1 oninput='update()'>
<pre id=I></pre>

PHP> = 7.1, 46 bytes

Aceitar entrada como string

<?=trim(join(range(($a=$argn)[0],$a[-1])),$a);

Sandbox do PHP Online

Retina , 33 25 bytes

$
¶$_
T`p`_p`.*$
D`.
!`.$

Experimente online! Funciona com qualquer intervalo de caracteres ASCII. Editar: salvou 8 bytes graças a @MartinEnder. Explicação: O primeiro estágio duplica a entrada. O segundo diminui todos os caracteres da cópia em 1 ponto de código. O terceiro estágio exclui todos os caracteres da cópia que ainda aparecem no original. Isso deixa apenas a entrada original, o caractere que precede o primeiro caractere da entrada original e o caractere ausente. O último estágio corresponde apenas ao caractere ausente.

Prolog SWI, 124 bytes

m([H|T]):-n(H,N),c(T,N),!,m(T).
n(I,N):-o(I,C),D is C+1,o(N,D).
c([N|_],N).
c(_,N):-print(N),!,fail.
o(C,O):-char_code(C,O).

Exemplos:

?- m(['a','b','c','d','f']).
e
false.

?- m(['O','Q','R','S']).
'P'
false.

?- m(['x','z']).
y
false.

?- m(['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
false.

Pouca explicação:

O mé o procedimento "principal", nproduz o próximo caractere esperado na lista. A ccomparação faz - se a expectativa corresponder ao próximo item, continue; caso contrário, imprima o caractere esperado e pule para fora da janela.

C ++ 14, biblioteca padrão, tipo de contêiner genérico ( 87 86 bytes)

[](auto a){return++*adjacent_find(begin(a),end(a),[](auto a,auto b){return a+1!=b;});}

O tipo de contêiner do espaço para nome ::stdé assumido (por exemplo std::string, std::listou std::vector. Caso contrário, using namespace std;seria similar.

Graças ao @Ven, com um pouco de hackers no pré-processador, você o reduz para 82 bytes (1 nova linha)

#define x [](auto a,int b=0){return++
x *adjacent_find(begin(a),end(a),x a!=b;});}

Veja Live On Coliru

C ++ 14 sem biblioteca padrão (ainda genérica, 64 63 bytes)

[](auto& a){auto p=*begin(a);for(auto c:a)if(c!=p++)return--p;}

Novamente, é necessário ajudar a pesquisa de nome apenas se o tipo de contêiner não for do espaço para nome ::std(ou associado a ele)

Live On Colirupor std::stringexemplo

Live On Colirupor char const[]exemplo

Carvão , 18 bytes

Ｆγ¿¬∨∨‹ι⌊θ›ι⌈θ№θιι

Experimente online! Link é a versão detalhada do código. Recebe a entrada como uma sequência. Funciona com qualquer sequência quase contígua de caracteres ASCII.

C #, 104 bytes

using System.Linq;a=>(char)Enumerable.Range(a.Min(),a.Max()-a.Min()).Except(a.Select(c=>(int)c)).First()

Versão completa / formatada:

using System.Linq;

namespace System
{
    class P
    {
        static void Main()
        {
            Func<char[], char> f = a =>
                (char)Enumerable.Range(a.Min(), a.Max() - a.Min())
                                .Except(a.Select(c=>(int)c))
                                .First();

            Console.WriteLine(f(new[] { 'a', 'b', 'c', 'd', 'f' }));

            Console.ReadLine();
        }
    }
}

MATL, 8 7 bytes

1 byte salvo graças a @Luis

tdqf)Qc

Experimente no MATL Online

Explicação

      % Implicitly grab the input as a string
t     % Duplicate the string
d     % Compute the differences between successive characters
q     % Subtract 1 from each element
f     % Get the locations of all non-zero characters (1-based index)
)     % Extract that character from the string
Q     % Add one to get the next character (the missing one)
c     % Convert to character and display

Excel, 110 + 2 = 112 bytes

=CHAR(CODE(LEFT(A1))-1+MATCH(0,IFERROR(FIND(CHAR(ROW(INDIRECT(CODE(LEFT(A1))&":"&CODE(RIGHT(A1))))),A1),0),0))

Deve ser inserido como uma fórmula de matriz ( Ctrl+ Shift+ Enter) que adicione colchetes { }em cada extremidade, adicionando dois bytes. A entrada é como uma sequência A1, o que é OK por OP .

Esta não é a resposta mais curta de longe (o Excel raramente é), mas eu gosto de ver se isso pode ser feito.

Rexx (Regina) , 56 bytes

a=arg(1)
say translate(xrange(left(a,1),right(a,1)),'',a)

Experimente online!

Finalmente, um que permite ao REXX usar sua forte manipulação de strings.

CJam , 6 bytes (programa completo) / 7 bytes (bloco de código)

q),^W=

Experimente online!

Este é um programa CJam completo que lê a sequência de entrada da entrada padrão e imprime a letra ausente na saída padrão. CJam realmente não tem "métodos", que é o que o desafio pede, mas o mais próximo provavelmente seria um bloco de código executável, assim:

{),^W=}

Experimente online!

Este bloco de código, quando avaliado, recebe a entrada como uma sequência (ou seja, uma matriz de caracteres) na pilha e retorna o caractere ausente também na pilha.

Explicação: No programa completo, qlê a sequência de entrada e a coloca na pilha. )em seguida, aparece o último caractere da sequência de entrada e o operador range o ,transforma em uma matriz que contém todos os caracteres com pontos de código abaixo (incluindo todas as letras anteriores no alfabeto). Assim, por exemplo, se a entrada foi cdfgh, depois ),da pilha conteria as strings cdfg(ou seja, a entrada com a última letra removida) e ...abcdefg, onde ...representa um monte de caracteres com códigos ASCII abaixo a(ou seja, todos os caracteres abaixo da última entrada removida) carta).

O operador de diferença de conjunto simétrico ^combina essas cadeias em uma única cadeia que contém exatamente os caracteres que aparecem em uma das cadeias, mas não em ambas. Ele preserva a ordem em que os caracteres aparecem nas seqüências, portanto, para a entrada de exemplo cdfg, o resultado ),^será o seguinte ...abe, onde ...novamente significa um monte de caracteres com códigos ASCII abaixo a. Finalmente, W=apenas extrai o último caractere dessa string, que é exatamente o caractere eque faltava que queríamos encontrar (e descarta o resto). Quando o programa termina, o intérprete CJam imprime implicitamente o conteúdo da pilha.

Bônus: GolfScript , 6 bytes (programa completo)

),^-1>

Experimente online!

Acontece que quase o mesmo código também funciona no GolfScript. Economizamos um byte na versão completa do programa devido à entrada implícita do GolfScript, mas perdemos um byte porque, diferentemente do CJam W, o GolfScript não possui uma variável de letra única útil inicializada como -1.

Além disso, o CJam possui tipos inteiros e de caracteres separados (e as strings são apenas matrizes que contêm caracteres), enquanto o GolfScript possui apenas um único tipo inteiro (e um tipo de string especial que se comporta de maneira um pouco diferente das matrizes normais). O resultado de tudo isso é que, se queremos que o intérprete GolfScript imprima a letra que está faltando, em vez de seu número de código ASCII, precisamos retornar uma cadeia de caracteres únicos em vez de apenas o próprio caractere. Felizmente, fazer essa alteração aqui requer apenas a substituição do operador de indexação pelo operador de =truncamento esquerdo da matriz / string >.

Obviamente, graças à E / S implícita do GolfScript, o código acima também pode ser usado como um trecho que lê uma string da pilha e retorna uma string de um caractere contendo a letra que falta. Ou melhor, qualquer trecho que pegue uma única string na pilha como argumento e retorne sua saída como uma string imprimível na pilha também é um programa completo do GolfScript.

Casca , 6 bytes

→S-(ḣ→

Experimente online!

Esta função pega uma string (lista de caracteres) como entrada e retorna um caractere como saída.

Explicação

→S-(ḣ→
    ḣ→    Get the list of all characters from the null byte to the last character of the input
 S-       Subtract the input from this list
→         Get the last element of the result

Python 2 - 76 bytes

Perde para a solução python 2 existente, mas é uma abordagem um pouco diferente, então pensei em publicá-la de qualquer maneira:

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

8o , 99 bytes

Fundamentação

Se a distância entre as letras for maior que dois, falta uma letra. A distância das letras é obtida calculando a diferença entre o código ASCII de cada letra.

Código

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

Versão ungolfed

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

Uso e exemplos

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

ok> "def" f

ok>

JavaScript (ES6), 64 bytes

Recebe a entrada como uma sequência.

s=>(g=p=>(c=String.fromCharCode(n++))<s[p]?p?c:g(p):g(p+1))(n=0)

Quão?

• Inicialização: Começamos com n = 0 e p = 0 e chamar a função recursiva g () .

  g = p =>                                   // given p
    (c = String.fromCharCode(n++)) < s[p] ?  // if the next char. c is not equal to s[p]:
      p ?                                    //   if p is not equal to zero:
        c                                    //     step #3
      :                                      //   else:
        g(p)                                 //     step #1
    :                                        // else:
      g(p + 1)                               //   step #2

• Etapa 1: incrementamos n até que c = String.fromCharCode(n)seja igual ao primeiro caractere da sequência de entrada s [0] .

• Etapa # 2: Agora que estamos sincronizados, incrementamos ambos n e p , ao mesmo tempo até que c = String.fromCharCode(n)não é igual a s [p] mais.

• Etapa 3: retornamos c : o caractere esperado que não foi encontrado.

Casos de teste

let f =

s=>(g=p=>(c=String.fromCharCode(n++))<s[p]?p?c:g(p):g(p+1))(n=0)

console.log(f('abcdf'))                     // -> 'e'
console.log(f('OQRS'))                      // -> 'P'
console.log(f('xz'))                        // -> 'y'
console.log(f('abcdefghijklmnopqrstuwxyz')) // -> 'v'

J, 20 bytes

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

• a.e. máscara booleana para as letras de entrada no conjunto de caracteres ascii
• 1 0 1&E.nova máscara booleana indicando se a sequência 101começa nesse índice, ou seja, encontre qualquer lugar em que a sequência "pular" comece
• I. o índice dessa correspondência, ou seja, o personagem antes do ignorado
• >: incrementa em 1, ou seja, o índice do caractere ignorado no conjunto de caracteres ascii
• {&a. escolha esse índice no conjunto de caracteres ascii, ou seja, retorne o caractere ignorado

Experimente online!

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

A função retornada precisa ser chamada com uma matriz

(["a","c"])

pode-se salvar outros 9 bytes removendo .join ("") e passando uma 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

Lisp comum, 88 bytes

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

Experimente online!

Python 2 , 69 bytes

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

Experimente online!

Algumas explicações Como sabemos o primeiro e o último elementos da lista, podemos calcular facilmente a soma dos códigos de todos os caracteres no list + the missed char(usando fórmulas de resumo da progressão aritmética ). A diferença entre essa soma e a soma dos códigos de todos os caracteres no listfornece o código da letra perdida.

05AB1E , 9 7 bytes

ǤÝsKçθ

Experimente online!

APL (Dyalog) , 17 bytes

(⊃⎕AV/⍨∨\∧~)⎕AV∘∊

Experimente online!

⎕AV∘∊ Booleana: cada caracter na Uma Tomic V ector (conjunto de caracteres) membro do argumento?

(...)  Aplique a seguinte função tácita:

 ⊃ o primeiro elemento de

 ⎕AV o Um Tomic V ector (o conjunto de caracteres)

 /⍨ qual

 ∨\ segue o inicial (membro do argumento)

 ∧ mas

 ~ não é (um membro do argumento)