Des lignes directrices

Tâche

Écrivez une méthode qui prend en entrée un tableau de lettres consécutives (croissantes) et qui renvoie la lettre manquante dans le tableau (liste dans certaines langues).

Règles

• C'est le golf de code, donc la réponse la plus courte en octets gagne!
• Vous obtiendrez toujours un tableau valide
• Il manquera toujours exactement une lettre
• La longueur du tableau sera toujours d'au moins 2.
• Le tableau contiendra toujours des lettres dans un seul cas (majuscule ou minuscule)
• Vous devez sortir dans le même cas (majuscule ou minuscule) que l'entrée est
• Le tableau n'ira toujours qu'une lettre à la fois (en sautant la lettre manquante)
• La longueur du tableau sera comprise entre 2 et 25
• Le premier ou le dernier élément du tableau ne sera jamais manquant

Exemples

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

Pyth , 5 octets

-rhQe

Essayez-le en ligne!

C # (.NET Core) , 48 47 46 octets, entrée en tant que tableau de caractères

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

Essayez-le en ligne!

Explication: le premier élément du tableau est incrémenté ainsi qu'un pointeur itérant les éléments suivants. Lorsque le premier élément et l'élément actuel sont différents, il renvoie le premier élément.

C # (.NET Core) , 58 56 50 octets, entrée sous forme de chaîne

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

Essayez-le en ligne!

Solution précédente de 58 octets (référencée dans le premier commentaire):

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

Algorithmes utilisant System.Linq

Les algorithmes suivants doivent ajouter using System.Linq;(18 octets) au nombre d'octets et sont donc plus longs.

J'ai bien aimé celui-ci (52 + 18 octets):

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

Et vous avez également une solution à une ligne (45 + 18) octets:

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

Et une solution très intelligente (37 + 18) octets, gracieuseté d'Ed'ka:

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

Alice , 10 octets

/X.
\ior@/

Essayez-le en ligne!

Explication

Ceci est juste un cadre pour les programmes linéaires qui fonctionnent entièrement en mode Ordinal (traitement de chaîne):

/...
\.../

Le code linéaire réel est alors:

i.rXo@

Qui fait:

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 octets

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

Essayez-le en ligne!

Ruby, 21 caractères

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

Renvoie un tableau d'éléments unique, selon le commentaire du propriétaire de la question .

Exemple d'exécution:

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

Essayez-le en ligne!

Java 8, 70 57 56 48 46 octets

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

-14 (70 → 56) et -2 (48 → 46) octets grâce à @CarlosAlejo .
-8 (56 → 48) octets grâce à @Nevay .

Explication:

Essayez-le ici.

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 octets

Toutes les optimisations doivent être désactivées et uniquement sur GCC 32 bits.

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

Prenez l'entrée comme une chaîne.

Essayez-le en ligne!

Python 3 , 74 62 58 44 40 octets

-12 octets grâce à Erik l'Outgolfer. -18 octets grâce à Leaky Nun. -4 octets grâce à musicman523.

Prend l'entrée comme un bytestring.

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

Essayez-le en ligne!

Une autre solution intéressante:

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

Mathematica, 46 octets

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

JavaScript (ES6), 70 octets

Saisie sous forme de tableau de caractères

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

Moins golfé

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

Tester

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 octets

Prendre l'entrée comme chaîne

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

PHP Sandbox Online

Rétine , 33 25 octets

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

Essayez-le en ligne! Fonctionne avec n'importe quelle plage de caractères ASCII. Edit: 8 octets enregistrés grâce à @MartinEnder. Explication: La première étape duplique l'entrée. La seconde diminue tous les caractères de la copie de 1 point de code. La troisième étape supprime tous les caractères de la copie qui apparaissent toujours dans l'original. Cela laisse juste l'entrée d'origine, le caractère qui précède le premier caractère de l'entrée d'origine et le caractère manquant. La dernière étape correspond alors juste au personnage manquant.

SWI Prolog, 124 octets

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).

Exemples:

?- 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.

Petite explication:

C'est mla procédure "principale", le nproduit le prochain caractère attendu dans la liste. La ccomparaison ne - si l'attente correspond à l'élément suivant, continuez, sinon imprimez le caractère attendu et sautez par la fenêtre.

C ++ 14, bibliothèque standard, type de conteneur générique ( 87 86 octets)

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

Le type de conteneur de l'espace de noms ::stdest supposé (par exemple std::string, std::listou std::vector. Sinon using namespace std;ou similaire serait supposé.

Grâce à @Ven, avec un peu de piratage du préprocesseur, vous obtenez le réduire à 82 octets (1 nouvelle ligne)

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

Le voir Live On Coliru

C ++ 14 pas de bibliothèque standard (toujours générique, 64 63 octets)

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

Encore une fois, vous ne devez aider à la recherche de noms que si le type de conteneur ne provient pas de l'espace de noms ::std(ou ne lui est pas associé)

Live On Colirupar std::stringexemple

Live On Colirupar char const[]exemple

Fusain , 18 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend l'entrée sous forme de chaîne. Fonctionne avec n'importe quelle séquence presque contiguë de caractères ASCII.

C #, 104 octets

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

Version complète / formatée:

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 octets

1 octet enregistré grâce à @Luis

tdqf)Qc

Essayez-le sur MATL Online

Explication

      % 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 octets

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

Doit être entré sous la forme d'une formule matricielle ( Ctrl+ Shift+ Enter) qui ajoute des accolades { }à chaque extrémité, en ajoutant deux octets. L'entrée est sous forme de chaîne A1, ce qui est OK par OP .

Ce n'est pas de loin la réponse la plus courte (Excel l'est rarement) mais j'aime voir si cela peut être fait.

Rexx (Regina) , 56 octets

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

Essayez-le en ligne!

Enfin un qui permet à REXX d'utiliser sa forte manipulation de chaînes.

CJam , 6 octets (programme complet) / 7 octets (bloc de code)

q),^W=

Essayez-le en ligne!

Il s'agit d'un programme CJam complet qui lit la chaîne d'entrée de l'entrée standard et imprime la lettre manquante sur la sortie standard. CJam n'a pas réellement de "méthodes", ce que demande le défi, mais le plus proche serait probablement un bloc de code exécutable, comme ceci:

{),^W=}

Essayez-le en ligne!

Ce bloc de code, une fois évalué, prend l'entrée sous forme de chaîne (c'est-à-dire un tableau de caractères) sur la pile, et renvoie également le caractère manquant sur la pile.

Explication: Dans le programme complet, qlit la chaîne d'entrée et la place sur la pile. )saute ensuite le dernier caractère de la chaîne d'entrée, et l'opérateur de plage le ,transforme en un tableau contenant tous les caractères avec des points de code en dessous (y compris toutes les lettres avant dans l'alphabet). Ainsi, par exemple, si l'entrée était cdfgh, alors après ),la pile contiendrait les chaînes cdfg(c'est-à-dire l'entrée avec la dernière lettre supprimée) et ...abcdefg, où ...représente un tas de caractères avec les codes ASCII ci-dessous a(c'est-à-dire tous les caractères sous la dernière entrée supprimée lettre).

L'opérateur de différence d'ensemble symétrique ^combine ensuite ces chaînes en une seule chaîne qui contient exactement les caractères qui apparaissent dans l'une des chaînes, mais pas dans les deux. Il préserve l'ordre dans lequel les caractères apparaissent dans les chaînes, donc pour l'exemple d'entrée cdfg, le résultat après ),^sera ...abe, où correspond à ...nouveau un groupe de caractères avec les codes ASCII ci-dessous a. Enfin, W=extrait juste le dernier caractère de cette chaîne, qui est exactement le caractère manquant eque nous voulions trouver (et élimine le reste). À la fin du programme, l'interpréteur CJam imprime implicitement le contenu de la pile.

Bonus: GolfScript , 6 octets (programme complet)

),^-1>

Essayez-le en ligne!

Il s'avère que presque le même code fonctionne également dans GolfScript. Nous économisons un octet dans la version complète du programme en raison de l'entrée implicite de GolfScript, mais perdons un octet car, contrairement à CJam W, GolfScript n'a pas de variable à une seule lettre pratique initialisée à -1.

En outre, CJam a des types d'entier et de caractères distincts (et les chaînes ne sont que des tableaux contenant des caractères), tandis que GolfScript n'a qu'un seul type d'entier (et a un type de chaîne spécial qui se comporte quelque peu différemment des tableaux normaux). Le résultat de tout cela est que, si nous voulons que l'interpréteur GolfScript imprime la lettre manquante réelle au lieu de son numéro de code ASCII, nous devons renvoyer une chaîne de caractères unique au lieu du seul caractère lui-même. Heureusement, effectuer ce changement ici nécessite simplement de remplacer l'opérateur d'indexation =par l'opérateur de troncature gauche tableau / chaîne >.

Bien sûr, grâce aux E / S implicites de GolfScript, le code ci-dessus peut également être utilisé comme un extrait de code qui lit une chaîne de la pile et renvoie une chaîne à un caractère contenant la lettre manquante. Ou plutôt, tout extrait qui prend une seule chaîne sur la pile comme argument et renvoie sa sortie sous forme de chaîne imprimable sur la pile, est également un programme GolfScript complet.

Husk , 6 octets

→S-(ḣ→

Essayez-le en ligne!

Cette fonction prend une chaîne (liste de caractères) en entrée et renvoie un caractère en sortie.

Explication

→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 octets

Perd à la solution python 2 existante mais c'est une approche légèrement différente, donc j'ai pensé que je la publierais quand même:

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

8ème , 99 octets

Raisonnement

Si la distance entre les lettres est supérieure à deux, il manque une lettre. La distance entre les lettres est obtenue en calculant la différence entre le code ASCII de chaque lettre.

Code

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

Version non golfée

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

Utilisation et exemples

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 octets

Prend l'entrée sous forme de chaîne.

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

Comment?

• Initialisation: Nous commençons par n = 0 et p = 0 et appelons la fonction récursive 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

• Étape # 1: Nous incrémentons n jusqu'à ce qu'il c = String.fromCharCode(n)soit égal au premier caractère de la chaîne d'entrée s [0] .

• Étape # 2: Maintenant que nous sommes synchronisés, nous incrémentons simultanément n et p jusqu'à ce que c = String.fromCharCode(n)ne soit plus égal à s [p] .

• Étape # 3: Nous retournons c : le caractère attendu qui n'a pas été trouvé.

Cas de test

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 octets

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

• a.e. masque booléen pour les lettres d'entrée à travers le jeu de caractères ascii
• 1 0 1&E.nouveau masque booléen indiquant si la séquence 101commence à cet index, c'est-à-dire trouver n'importe quel endroit où une séquence "sauter" commence
• I. l'index de cette correspondance, c'est-à-dire le caractère avant celui ignoré
• >: incrémenter de 1, c.-à-d. l'indice du caractère ignoré dans le jeu de caractères ascii
• {&a. choisir cet index dans le jeu de caractères ascii, c'est-à-dire renvoyer le caractère ignoré

Essayez-le en ligne!

ES6, 125 octets:

(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

La fonction retournée doit être appelée avec un tableau

(["a","c"])

on pourrait économiser encore 9 octets en supprimant .join ("") et en passant une chaîne:

("ac")

ES6, 108 octets:

(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 commun, 88 octets

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

Essayez-le en ligne!

Python 2 , 69 octets

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

Essayez-le en ligne!

Quelques explications Comme nous connaissons le premier et le dernier élément de la liste, nous pouvons facilement calculer la somme des codes de tous les caractères du list + the missed char(en utilisant des formules récapitulatives de progression arithmétique ). La différence entre cette somme et la somme des codes de tous les caractères du listdonne le code de la lettre manquée.

05AB1E , 9 7 octets

ǤÝsKçθ

Essayez-le en ligne!

APL (Dyalog) , 17 octets

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

Essayez-le en ligne!

⎕AV∘∊ Booléenne: chaque caractère dans le A tomic V membre ector (jeu de caractères) de l'argument?

(…)  Appliquez la fonction tacite suivante:

 ⊃ le premier élément de

 ⎕AV l' A tomic V (le jeu de caractères)

 /⍨ lequel

 ∨\ suit l'initiale (membre de l'argument)

 ∧ mais

 ~ n'est pas (un membre de l'argument)