Problème

Disons qu'un mot est presque un palindrome s'il est possible d'enlever une de ses lettres pour que le mot devienne un palindrome. Votre tâche consiste à écrire un programme qui, pour un mot donné, détermine la lettre à supprimer pour obtenir un palindrome.

Le code le plus court pour le faire dans n'importe quel langage de programmation gagne.

Contribution

L'entrée se compose d'un mot de lettres majuscules de 2 à 1 000 caractères.

Production

Sortez la position indexée 1 (la lettre la plus à gauche a la position 1, la suivante a la position 2 et ainsi de suite) de la lettre qui doit être supprimée. S'il existe des choix possibles menant au palindrome, sortez l'une de ces positions. Notez que vous devez supprimer une lettre même si le mot donné est déjà un palindrome. Si le mot donné n'est pas presque un palindrome, affichez -1.

Exemple

L'entrée:

racercar

pourrait produire la sortie:

5

parce que la suppression de la 5e lettre produit racecar, qui est un palindrome.

De plus, l'entrée

racecar

peut toujours produire la sortie

4

parce que retirer la 4e lettre à produire raccarest toujours un palindrome.

J - 31 25 caractères

(_1{ ::[1+[:I.1(-:|.)\.])

Tarif largement standard pour J, donc je vais juste souligner les morceaux sympas.

• L'adverbe \.s'appelle Outfix . x u\. ysupprime tous les infix de la longueur xde yet applique uau résultat de chaque retrait. Ici, xest 1, yest la chaîne d'entrée, et uest (-:|.), un test pour savoir si la chaîne correspond à son inverse. D'où le résultat de cette application de \.est une liste de booléens, 1 à la place de chaque personnage dont la suppression fait de l'entrée un palindrome.

• I.crée une liste de tous les indices (origine 0) d'en haut où il y avait un 1. L'ajout de 1 avec 1+rend ces indices d'origine 1. Si aucun indice n'était égal à 1, la liste est vide. Maintenant, nous essayons de prendre le dernier élément avec _1{. (Nous sommes autorisés à sortir n'importe laquelle des lettres amovibles!) Si cela fonctionne, nous revenons. Cependant, si la liste était vide, il n'y avait aucun élément du tout, {lance donc une erreur de domaine avec laquelle nous interceptons ::et renvoyons le -1 avec [.

Utilisation (rappelez-vous que NB.c'est pour les commentaires):

   (_1{ ::[1+[:I.1(-:|.)\.]) 'RACECAR'    NB. remove the E
4
   (_1{ ::[1+[:I.1(-:|.)\.]) 'RAACECAR'   NB. remove an A
3
   (_1{ ::[1+[:I.1(-:|.)\.]) 'RAAACECAR'  NB. no valid removal
_1

Python non PHP (73):

[a[:g]+a[g+1:]==(a[:g]+a[g+1:])[::-1] for g in range(len(a))].index(1)

Où a est la chaîne que vous souhaitez vérifier. Cependant, cela génère une erreur si vous ne pouvez pas le tourner dans un palindrome. Au lieu de cela, vous pouvez utiliser

try:print [a[:g]+a[g+1:]==(a[:g]+a[g+1:])[::-1] for g in range(len(a))].index(True)
except ValueError:print -1

EDIT: Non, attendez, cela fonctionne!

try: eval("<?php $line = fgets(STDIN); ?>")
except: print [a[:g]+a[g+1:]==(a[:g]+a[g+1:])[::-1] for g in range(len(a))].index(1)

Merci, cela augmente en effet le contenu php de ce script d'environ 25% (c'est ce que vous voulez, non?)

Mathematica, 106 98 87 91 caractères

Je suppose que je suis légèrement handicapé par les longs noms de fonctions, mais des problèmes comme celui-ci sont assez amusants dans Mathematica:

f=Tr@Append[Position[c~Drop~{#}&/@Range@Length[c=Characters@#],l_/;l==Reverse@l,{1}],{-1}]&

Il lance quelques avertissements, car le l_modèle correspond également à tous les caractères à l'intérieur, qui Reversene peuvent pas fonctionner. Mais bon, ça marche!

Assez peu golfé:

f[s_] := 
  Append[
    Cases[
      Map[{#, Drop[Characters[s], {# }]} &, Range[StringLength[s]]], 
      {_, l_} /; l == Reverse[l]
    ], 
    {-1}
  ][[1, 1]]

GolfScript, 28 26 caractères

:I,,{)I/();\+.-1%=}?-2]0=)

Merci à Peter d'avoir raccourci de 2 caractères. Essayez les cas de test en ligne :

> "RACECAR" 
4
> "RAACECAR" 
2
> "RAAACECAR" 
-1
> "ABCC1BA" 
5
> "AAAAAA" 
1
> "ABCDE" 
-1
> "" 
-1
> "A" 
1

Rebol (81)

r: -1 repeat i length? s[t: head remove at copy s i if t = reverse copy t[r: i]]r

Exemple d'utilisation dans la console Rebol:

>> s: "racercar"
== "racercar"

>> r: -1 repeat i length? s[t: head remove at copy s i if t = reverse copy t[r: i]]r
== 5

>> s: "1234"
== "1234"

>> r: -1 repeat i length? s[t: head remove at copy s i if t = reverse copy t[r: i]]r 
== -1

Ci-dessus retourne l'indice du dernier palindrome trouvé. Une solution alternative (85 caractères) qui renvoie chaque palindrome trouvé serait:

collect[repeat i length? s[t: head remove at copy s i if t = reverse copy t[keep i]]]

Donc, "racercar"cela reviendrait à la liste [4 5].

C #, 134 caractères

static int F(string s,int i=0){if(i==s.Length)return-1;var R=s.Remove(i,1);return R.SequenceEqual(R.Reverse())?i+1:F(s,i+1);}

Je sais que je perds :( mais c'était quand même amusant : D

Version lisible:

using System.Linq;

// namespace and class

static int PalindromeCharIndex(string str, int i = 0)
{
    if (i == str.Length) return -1;
    var removed = str.Remove(i, 1);
    return removed.SequenceEqual(removed.Reverse()) 
        ? i+1
        : PalindromeCharIndex(str, i + 1); 
}

Stax , 8 10 octets

ú·àA÷¡%5Ñ╙

Exécuter et déboguer

Ce programme montre tous les indices basés sur 1 qui peuvent être supprimés de la chaîne pour former un palindrome. Et s'il n'y en a pas, il indique -1.

Rubis (61):

(1..s.size+1).find{|i|b=s.dup;b.slice!(i-1);b.reverse==b}||-1

Ici, ayez une solution rubis. Il retournera la position du personnage à supprimer ou -1 si cela ne peut pas être fait.

Je ne peux pas m'empêcher de penser qu'il y a une amélioration à faire avec la section dup et slice, mais Ruby ne semble pas avoir de méthode String qui supprimera un caractère à un index spécifique et renverra la nouvelle chaîne -__-.

Modifié selon le commentaire, ty!

05AB1E , 10 octets

gL.Δõs<ǝÂQ

Essayez-le en ligne ou vérifiez d'autres cas de test .

Explication:

g           # Get the length of the (implicit) input-string
 L          # Create a list in the range [1,length]
  .Δ        # Find the first value in this list which is truthy for:
            # (which will output -1 if none are truthy)
    õ       #  Push an empty string ""
     s      #  Swap to get the current integer of the find_first-loop
      <     #  Decrease it by 1 because 05AB1E has 0-based indexing
       ǝ    #  In the (implicit) input-String, replace the character at that index with
            #  the empty string ""
        Â   #  Then bifurcate the string (short for Duplicate & Reverse copy)
         Q  #  And check if the reversed copy is equal to the original string,
            #  So `ÂQ` basically checks if a string is a palindrome)
            # (after which the result is output implicitly)

Pas PythonPHP ,85 83 81 octets

while($argn[$x])$s!=strrev($s=substr_replace($argn,'',$x++,1))?:die("$x");echo-1;

• -2 octets grâce à @ Night2!

Essayez-le en ligne!

Inutilement récursif:

PHP , 96 octets

function f($a,$b='',$d=1){return$a?$c==strrev($c=$b.$e=substr($a,1))?$d:f($e,$b.$a[0],$d+1):-1;}

Essayez-le en ligne!

Haskell, 107 caractères:

(x:y)!1=y;(x:y)!n=x:y!(n-1)
main=getLine>>= \s->print$head$filter(\n->s!n==reverse(s!n))[1..length s]++[-1]

En fonction ( 85 caractères ):

(x:y)!1=y;(x:y)!n=x:y!(n-1)
f s=head$filter(\n->s!n==reverse(s!n))[1..length s]++[-1]

version originale non golfée:

f str = case filter cp [1..length str] of
          x:_ -> x
          _   -> -1
    where cp n = palindrome $ cut n str
          cut (x:xs) 1 = xs
          cut (x:xs) n = x : cut xs (n-1)
          palindrome x = x == reverse x

C # (184 caractères)

J'avoue que ce n'est pas la meilleure langue pour faire du golf de code ...

using System.Linq;class C{static void Main(string[]a){int i=0,r=-1;while(i<a[0].Length){var x=a[0].Remove(i++,1);if(x==new string(x.Reverse().ToArray()))r=i;}System.Console.Write(r);}}

Formaté et commenté:

using System.Linq;

class C
{
    static void Main(string[] a)
    {
        int i = 0, r = -1;
        // try all positions
        while (i < a[0].Length)
        {
            // create a string with the i-th character removed
            var x = a[0].Remove(i++, 1);
            // and test if it is a palindrome
            if (x == new string(x.Reverse().ToArray())) r = i;
        }
        Console.Write(r);
    }
}

C # (84 caractères)

int x=0,o=i.Select(c=>i.Remove(x++,1)).Any(s=>s.Reverse().SequenceEqual(s))?x:-1;

Instruction LINQpad s'attendant à ce que la variable icontienne la chaîne d'entrée. La sortie est stockée dans la ovariable.

Haskell, 80

a%b|b<1=0-1|(\x->x==reverse x)$take(b-1)a++b`drop`a=b|1<2=a%(b-1)
f a=a%length a

Appelé comme ceci:

λ> f "racercar"
5

Japt , 8 octets

a@jYÉ êS

Essayez-le

a@jYÉ êS     :Implicit input of string
a            :Last 0-based index that returns true (or -1 if none do)
 @           :When passed through the following function as Y
  j          :  Remove the character in U at index
   YÉ        :    Y-1
      êS     :  Is palindrome?

Haskell, 118C

m s|f s==[]=(-1)|True=f s!!0
f s=[i|i<-[1..length s],r s i==(reverse$r s i)]
r s i=let(a,_:b)=splitAt (i-1) s in a++b

Non golfé:

fix s
    |indices s==[] = (-1)
    |True = indices s!!0
indices s = [i|i<-[1..length s],remove s i==(reverse$remove s i)]
remove s i = let (a,_:b) = (splitAt (i-1) s) in a++b

Gelée , 17 14 octets

ŒPṖLÐṀṚŒḂ€TXo-

Essayez-le en ligne!

           X      A random
          T       truthy index
ŒP                from the powerset of the input
  Ṗ               excluding the input
   LÐṀ            and all proper subsequences with non-maximal length
      Ṛ           reversed
       ŒḂ€        with each element replaced with whether or not it's a palindrome,
            o-    or -1.

Puisque j'ai changé mon approche assez rapidement pour que l'ancienne version ne s'affiche pas dans l'historique des modifications, voici ce qui suit: ŒPṚḊŒḂ€TṂ©’<La®o-

Brachylog , 24 octets

{l+₁≥.ℕ₂≜&↔⊇ᶠ↖.tT↔T∨0}-₁

Essayez-le en ligne!

Sent trop long.

Peut être de deux octets plus court si la sortie peut être indexée sur 2 :

l+₁≥.ℕ₂≜&↔⊇ᶠ↖.tT↔T∨_1

Deux itérations antérieures et encore pires:

ẹ~c₃C⟨hct⟩P↔P∧C;Ȯ⟨kt⟩hl<|∧_1
l>X⁰ℕ≜<.&{iI¬tX⁰∧Ih}ᶠP↔P∨_1

L'utilisation par ce dernier d'une variable globale nécessite un en- tête de test différent .

Python 3 , 71 octets

def f(s,i=1):n=s[:i-1]+s[i:];return(n==n[::-1])*i-(i>len(s))or f(s,i+1)

Essayez-le en ligne!

Renvoie le caractère indexé 1 si l'opération peut être effectuée et -1sinon.

Wolfram Language (Mathematica) , 56 octets

FirstCase[Range@Tr[1^#],a_/;PalindromeQ@Delete[#,a],-1]&

Essayez-le en ligne!

Prend la saisie sous forme de liste de caractères. Pour l'entrée de chaîne, ajoutez @*Characters.

PalindromeQa été introduit en 2015. L'alternative coûte +4 octets .

Perl 5 -p , 56 52 octets

("$`$'"eq reverse"$`$'")&&($\=pos)while/./g}{$\||=-1

Essayez-le en ligne!

C (gcc) , 180 168 159 157 140 139 octets

f(char*s){int j=strlen(s),m=j--/2,p=-1,i=0;for(;p&&i<m;)p=s[i++]^s[j--]&&!++p?s[i]-s[j+1]?s[i-1]-s[j]?p:j--+2:i++:p;return p<0?m+1:p?p:-1;}

Essayez-le en ligne!

2 16 17 octets rasés grâce au plafond! Et 3 octets de plus puisque les règles stipulent que la longueur minimale de l'entrée est de 2 caractères, donc ne devez pas vérifier les chaînes vides.

Non golfé:

f(char *s) {
  int j = strlen(s);             // j = length of input
  int m = j-- / 2;               // m = midpoint of string,
                                 // j = index of right character
  int p = -1;                    // p = position of extra character
                                 //     -1 means no extra character found yet
                                 //     0 means invalid input
  int i = 0;                     // i = index of left character

  for (; p && i < m; i++) {      // loop over the string from both sides,
                                 // as long as the input is valid.
    p = s[i] ^ s[j--]            // if (left character != right character
        && !++p ?                //     and we didn't remove a character yet*)
          s[i + 1] - s[j + 1] ?  //   if (left+1 char != right char)
            s[i] - s[j] ?        //     if (left char != right-1 char)
              p                  //       do nothing,
            :                    //     else
              j-- + 2            //       remove right char.
          :                      //   else
            ++i                  //       remove left char.
        :                        // else
          p;                     //     do nothing, or:
                                 //     *the input is marked invalid 
  } 

  return p < 0 ?                 // if (input valid and we didn't remove a character yet)
           m + 1                 //   return the midpoint character,
         :                       // else
           p ?                   //   if (we did remove a character)
             p                   //     return that character,
           :                     //   else
             -1;                 //     the input was invalid.
}
```

Python, 84

for i in range(len(s)):
    if s[i]!=s[-(i+1)]:
        if s[i]!=s[-(i+2)]:
            return i+1
        else:
            return len(s)-i

Cela ne vérifie pas si l'entrée (chaîne s) est presque palindrome, mais est efficace en temps et lisible.

Mon premier code-golf.

Java. ~ 1200 caractères dans les fonctions principales (et secondaires). Ouais bébé.

Dessus de classe et utilisation:

public class ElimOneCharForPalindrome  {
   public static final void main(String[] ignored)  {
      System.out.println(getEliminateForPalindromeIndex("racercar"));
      System.out.println(getEliminateForPalindromeIndex("racecar"));
   }

La fonction principale:

   public static final int getEliminateForPalindromeIndex(String oneCharAway_fromPalindrome)  {
      for(int i = 0; i < oneCharAway_fromPalindrome.length(); i++)  {
         String strMinus1Char = oneCharAway_fromPalindrome.substring(0, i) + oneCharAway_fromPalindrome.substring(i + 1);

         String half1 = getFirstHalf(strMinus1Char);
         String half2Reversed = getSecondHalfReversed(strMinus1Char);

         if(half1.length() != half2Reversed.length())  {
            //One half is exactly one character longer
            if(half1.length() > half2Reversed.length())  {
               half1 = half1.substring(0, (half1.length() - 1));
            }  else  {
               half2Reversed = half2Reversed.substring(0, (half2Reversed.length() - 1));
            }
         }

         //System.out.println(i + " " + strMinus1Char + " --> " + half1 + " / " + half2Reversed + "  (minus the singular [non-mirrored] character in the middle, if any)");

         if(half1.equals(half2Reversed))  {
            return  i;
         }
      }
      return  -1;
   }

Sous-fonctions:

   public static final String getFirstHalf(String whole_word)  {
      return  whole_word.substring(0, whole_word.length() / 2);
   }
   public static final String getSecondHalfReversed(String whole_word)  {
      return  new StringBuilder(whole_word.substring(whole_word.length() / 2)).reverse().toString();
   }
}

Classe complète:

public class ElimOneCharForPalindrome  {
   public static final void main(String[] ignored)  {
      System.out.println(getEliminateForPalindromeIndex("racercar"));
      System.out.println(getEliminateForPalindromeIndex("racecar"));
   }
   public static final int getEliminateForPalindromeIndex(String oneCharAway_fromPalindrome)  {
      for(int i = 0; i < oneCharAway_fromPalindrome.length(); i++)  {
         String strMinus1Char = oneCharAway_fromPalindrome.substring(0, i) + oneCharAway_fromPalindrome.substring(i + 1);

         String half1 = getFirstHalf(strMinus1Char);
         String half2Reversed = getSecondHalfReversed(strMinus1Char);

         if(half1.length() != half2Reversed.length())  {
            //One half is exactly one character longer
            if(half1.length() > half2Reversed.length())  {
               half1 = half1.substring(0, (half1.length() - 1));
            }  else  {
               half2Reversed = half2Reversed.substring(0, (half2Reversed.length() - 1));
            }
         }

         //System.out.println(i + " " + strMinus1Char + " --> " + half1 + " / " + half2Reversed + "  (minus the singular [non-mirrored] character in the middle, if any)");

         if(half1.equals(half2Reversed))  {
            return  i;
         }
      }
      return  -1;
   }
   public static final String getFirstHalf(String whole_word)  {
      return  whole_word.substring(0, whole_word.length() / 2);
   }
   public static final String getSecondHalfReversed(String whole_word)  {
      return  new StringBuilder(whole_word.substring(whole_word.length() / 2)).reverse().toString();
   }
}