Problem

Angenommen, ein Wort ist fast ein Palindrom, wenn es möglich ist, einen seiner Buchstaben zu entfernen, sodass das Wort zu einem Palindrom wird. Ihre Aufgabe ist es, ein Programm zu schreiben, das für ein bestimmtes Wort bestimmt, welchen Buchstaben Sie entfernen müssen, um ein Palindrom zu erhalten.

Der kürzeste Code, um dies in einer Programmiersprache zu tun, gewinnt.

Eingang

Die Eingabe besteht aus einem Wort mit Großbuchstaben von 2 bis 1000 Zeichen.

Ausgabe

Geben Sie die 1-indizierte Position (der Buchstabe ganz links hat Position 1, der nächste hat Position 2 usw.) des Buchstabens aus, der entfernt werden soll. Wenn es Auswahlmöglichkeiten gibt, die zum Palindrom führen, geben Sie eine dieser Positionen aus. Beachten Sie, dass Sie einen Buchstaben entfernen müssen, auch wenn das angegebene Wort bereits ein Palindrom ist. Wenn das angegebene Wort nicht fast ein Palindrom ist, wird -1 ausgegeben.

Beispiel

Die Eingabe:

racercar

könnte die Ausgabe erzeugen:

5

weil das Entfernen des 5th Buchstabens erzeugt racecar, was ein Palindrom ist.

Auch die Eingabe

racecar

kann noch die Ausgabe produzieren

4

denn das Entfernen des 4zu produzierenden Buchstabens raccarist immer noch ein Palindrom.

J - 31 25 char

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

Im Großen und Ganzen Standardtarif für J, daher werde ich nur auf die coolen Details hinweisen.

• Das Adverb \.heißt Outfix . x u\. yEntfernt jedes Längen-Infix xvon yund gilt ufür das Ergebnis jeder Entfernung. Hier xist 1 ydie Eingabezeichenfolge und uist (-:|.)ein Test, ob die Zeichenfolge mit ihrer Umkehrung übereinstimmt. Das Ergebnis dieser Anwendung von \.ist daher eine Liste von Booleschen Werten, 1 anstelle jedes Zeichens, dessen Entfernung die Eingabe zu einem Palindrom macht.

• I.Erstellt eine Liste aller Indizes (0-Ursprung) von oben, bei denen es eine 1 gab. Durch Hinzufügen von 1 mit werden 1+diese Indizes mit 1 Ursprung erstellt. Wenn keine Indizes 1 waren, ist die Liste leer. Nun versuchen wir, das letzte Element mit aufzunehmen _1{. (Wir dürfen jeden der entfernbaren Buchstaben ausgeben!) Wenn dies funktioniert, kehren wir zurück. Wenn die Liste jedoch leer war, gab es überhaupt keine Elemente. {Daher wird ein Domänenfehler ausgegeben, mit dem wir abfangen ::und den Wert -1 zurückgeben [.

Verwendung (Rückruf NB.für Kommentare):

   (_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

Nicht-PHP- Python (73):

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

Wo a ist die Zeichenfolge, die Sie überprüfen möchten. Dies löst jedoch einen Fehler aus, wenn Sie ihn nicht in ein Palindrom verwandeln können. Stattdessen könnten Sie verwenden

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: Nein, warte, es funktioniert!

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)

Danke, das erhöht tatsächlich den PHP-Inhalt dieses Skripts um etwa 25% (das ist es, was Sie wollen, oder?)

Mathematica, 106 98 87 91 Zeichen

Ich denke, ich bin durch die langen Funktionsnamen etwas behindert, aber solche Probleme machen in Mathematica ziemlich viel Spaß:

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

Es werden einige Warnungen ausgegeben, da das l_Muster auch mit allen darin enthaltenen Zeichen übereinstimmt, die Reversenicht bearbeitet werden können. Aber hey, es funktioniert!

Etwas ungolfed:

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

GolfScript, 28 26 Zeichen

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

Vielen Dank an Peter für die Kürzung um 2 Zeichen. Probieren Sie die Testfälle online aus :

> "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

Beispiel für die Verwendung in der Rebol-Konsole:

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

Oben wird der Index des zuletzt gefundenen Palindroms zurückgegeben. Eine alternative Lösung (85 Zeichen), die jedes gefundene Palindrom zurückgibt, wäre:

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

Also "racercar"dafür würde die Liste zurückkehren [4 5].

C #, 134 Zeichen

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);}

Ich weiß, ich verliere :( aber es hat trotzdem Spaß gemacht : D

Lesbare Version:

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 Bytes

ú·àA÷¡%5Ñ╙

Führen Sie es aus und debuggen Sie es

Dieses Programm zeigt alle 1-basierten Indizes an, die aus der Zeichenfolge entfernt werden können, um ein Palindrom zu bilden. Und wenn es keine gibt, wird -1 angezeigt.

Rubin (61):

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

Hier haben Sie eine Rubinlösung. Es gibt die Position des zu entfernenden Zeichens oder -1 zurück, wenn dies nicht möglich ist.

Ich kann nicht anders, als zu glauben, dass es Verbesserungen im Abschnitt dup und slice gibt, aber Ruby scheint keine String-Methode zu haben, die ein Zeichen an einem bestimmten Index entfernt und den neuen String -__- zurückgibt.

Bearbeitet nach Kommentar, ty!

05AB1E , 10 Bytes

gL.Δõs<ǝÂQ

Probieren Sie es online aus oder überprüfen Sie einige weitere Testfälle .

Erläuterung:

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)

Nicht Python PHP ,85 83 81 Bytes

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

• -2 Bytes dank @ Night2!

Probieren Sie es online!

Unnötig rekursiv:

PHP , 96 Bytes

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

Probieren Sie es online!

Haskell, 107 Zeichen:

(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]

Als Funktion ( 85 Zeichen ):

(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]

original ungolfed version:

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

Ich gebe zu, das ist nicht die beste Sprache, um Code-Golf zu spielen ...

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);}}

Formatiert und kommentiert:

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

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

Die LINQpad-Anweisung erwartet, dass die Variable idie Eingabezeichenfolge enthält. Die Ausgabe wird in der oVariablen gespeichert .

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

So genannt:

λ> f "racercar"
5

Japt , 8 Bytes

a@jYÉ êS

Versuch es

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

Ungolfed:

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

Jelly , 17-14 Bytes

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

Probieren Sie es online!

           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.

Da ich meinen Ansatz so schnell geändert habe, dass die alte Version nicht mehr im Bearbeitungsverlauf angezeigt wird, war dies: ŒPṚḊŒḂ€TṂ©’<La®o-

Brachylog , 24 Bytes

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

Probieren Sie es online!

Fühlt sich viel zu lang an.

Könnten zwei Bytes kürzer sein, wenn die Ausgabe 2-indiziert sein könnte :

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

Zwei frühere und noch schlimmere Iterationen:

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

Die Verwendung einer globalen Variablen durch letztere erfordert einen anderen Testheader .

Python 3 , 71 Bytes

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

Probieren Sie es online!

Gibt das 1-indizierte Zeichen zurück, wenn die Operation ausgeführt werden kann -1.

Wolfram Language (Mathematica) , 56 Byte

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

Probieren Sie es online!

Übernimmt die Eingabe als Liste von Zeichen. Fügen Sie für die Zeichenfolge-Eingabe an @*Characters.

PalindromeQwurde im Jahr 2015 eingeführt. Die Alternative kostet +4 Bytes .

Perl 5 -p , 56 52 Bytes

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

Probieren Sie es online!

C (GCC) , 180 168 159 157 140 139 Bytes

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

Probieren Sie es online!

2 16 17 Bytes dank Ceilingcat abgeschnitten! Und 3 weitere Bytes, da die Regeln angeben, dass die Mindestlänge der Eingabe 2 Zeichen beträgt, müssen Sie nicht nach leeren Zeichenfolgen suchen.

Ungolfed:

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

Hiermit wird nicht überprüft, ob die Eingabe (Zeichenfolge s) fast palindrom ist, sondern ob sie zeiteffizient und lesbar ist.

Mein erstes Code-Golf.

Java. ~ 1200 Zeichen in den Haupt- (und Unter-) Funktionen. Ja baby

Klasse top und gebrauch:

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

Die Hauptfunktion:

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

Unterfunktionen:

   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();
   }
}

Volle Klasse:

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();
   }
}