Bir dize verildiğinde s, bir palindrom oluşturmak için kaldırabileceğiniz en küçük bitişik alt dizeyi döndürün.

Örnekler:

800233008   -> 2
racecarFOOL -> FOOL
abcdedcba   -> (empty string)
ngryL Myrgn -> "L " (or " M")
123456789   -> 12345678 (or 23456789)
aabcdbaa    -> c (or d)
[[]]        -> [[ (or ]])
a           -> (empty string)

Kullanıcılardan test senaryosu önerileri (listede olmayan bir uç vaka bulursanız, lütfen bir yorum gönderin):

aabaab      -> b    | Suggested by Zgarb, some returned "aa".

kurallar

• Girdide yalnızca yazdırılabilir ASCII karakterleri görünecektir (yeni satır yok, basit olsun).
• Gerçekten bir kural, ancak not <>, /\, (), []ve {}palindrom değildir.

Bu kod golf , en küçük bayt sayma kazanç.

+100 ödül Adnan tarafından talep edildi

Jöle , 16 bayt

Ḣ;Ṫµ=Ṛ
0,0jŒṖÇÞṪ

Çevrimiçi deneyin!

Nasıl çalışır

0,0jŒṖÇÞṪ  Main link. Argument: s (string)

0,0j       Join [0, 0], separating by s. This prepends and appends a 0 to s.
    ŒṖ     Build all partitions of the resulting array.
      ÇÞ   Sort the partitions by the helper link.
           As a side effect, this will remove the first and last element of each
           partition. The 0's make sure that not removing any characters from s
           will still remove [0] from both sides.
        Ṫ  Tail; extract the last one.


Ḣ;Ṫµ=Ṛ     Helper link. Argument: A (array/partition)

Ḣ          Head; yield and remove the first chunk of A.
  Ṫ        Tail; yield and remove the last chunk of A.
 ;         Concatenate head and tail.
   µ=Ṛ     Compare the result, character by character, with its reverse.
           A palindrome of length l will yield an array of l 1's, while a
           non-palindrome of length l will yield an array with at least one 0 among
           the first l/2 Booleans. The lexicographically largest result is the one
           with the longest prefix of 1's, which corresponds to the longest
           palindrome among the outfixes.

J , 24 bayt

(0{::(-:|.)\.#&,<\)~i.@#

Çevrimiçi deneyin!

açıklama

(0{::(-:|.)\.#&,<\)~i.@#  Input: array of chars S
                       #  Length of S
                    i.@   Range, [0, 1, ..., len(S)-1]
(                 )~      Dyadic verb on range and S
           \.               For each outfix of S of size x in range
        |.                    Reverse
      -:                      Matches input (is palindrome)
                <\          Box each infix of S of size x in range
             #&,            Flatten each and copy the ones that match
 0{::                       Fetch the result and index 0 and return

Wolfram Dili (Mathematica) , 53 51 bayt

Bayt sayısı, CP-1252 kodlamasını varsayar.

±{a___,Shortest@b___,c___}/;PalindromeQ[a<>c]:={b}

Çevrimiçi deneyin!

Tekli bir işleç ±(veya bir işlev PlusMinus) tanımlar . Giriş ve çıkış karakterlerin listesidir. Test paketi kolaylık sağlamak için gerçek dizgelere ve gerçek dizgelere dönüşür.

Jöle , 20 bayt

ŒḂ⁹Ƥ
çЀJN$Ẏi1ịẆẋ⁻Ṛ$

Çevrimiçi deneyin!

05AB1E , 18 bayt

ā<Œ¯¸«ʒRõsǝÂQ}éнèJ

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

Python 3 , 97 bayt

f=lambda s,p='	':min([s][:p[::-1]in p+p]+(s and[f(s[1:],p+s[0]),f(s[:-1],s[-1]+p)]or[p]),key=len)

Çevrimiçi deneyin!

Python 2 , 116 bayt

def f(i):R=range(len(i)+1);print min([i[y:k+1]for y in R for k in R if(i[:y]+i[k+1:])[::-1]==i[:y]+i[k+1:]],key=len)

Çevrimiçi deneyin!

Halvard Hummel'in yardımıyla birkaç bayt kurtarıldı !

Japt , 26 22 bayt

¬£¬ËUjEY ꬩUtEY
c æ+0

Çevrimiçi test edin! Haritayı nasıl anlamaya çalışıyorum falseşey falsy ve bir byte bir şey truthy herhangi dizeye. Şu anda kullanıyorum +0...

Bash , 108 bayt

for((j=0;;j++)){
for((i=0;i<${#1};i++)){
r=${1:0:i}${1:j+i}
[[ $r = `rev<<<$r` ]]&&echo "${1:i:j}"&&exit
}
}

Komut satırı argümanı olarak girdi alır.

Çevrimiçi deneyin! Baştaki / sondaki boşlukları görüntülemek için çıktının etrafına basılmış tırnaklar bulunur.

Prolog , 271 bayt

p([_]).
p([X,X]).
p([X|Y]):-append([P,[X]],Y),p(P).

s(P,M,S,R,N):-p(P),append([M,S],N).
s(P,M,S,S,N):-p(S),append([P,M],N).
s(P,M,S,P,M):-append([P,S],X),p(X).

d(Y,P,N):-
    findall([A,B,C],(append([R,M,X],Y),s(R,M,X,B,C),length(B,A)),S),
    sort(1,@>,S,[[_,P,N]|_]).

Bir noktada bunun kod-golf standartlarına göre çok büyük olacağını fark ettim, bu yüzden gizlenmeyen versiyonun benzerliğini korumak için birkaç boşluk daha tuttum. Fakat soruna farklı bir yaklaşım olduğu için ilginç olabileceğini düşünüyorum.

Şaşırtmamış versiyon:

palindrome([_]).
palindrome([X, X]).
palindrome([X | Xs]) :-
    append([Prefix, [X]], Xs),
    palindrome(Prefix).

palindrome_split(Prefix, Mid, Suffix, Prefix, N) :-
    palindrome(Prefix),
    append([Mid, Suffix], N).
palindrome_split(Prefix, Mid, Suffix, Suffix, N) :-
    palindrome(Suffix),
    append([Prefix, Mid], N).
palindrome_split(Prefix, Mid, Suffix, P, Mid) :-
    append([Prefix, Suffix], P),
    palindrome(P).

palindrome_downgrade(NP, P, N):-
    findall(
        [La, Pa, Na],
        (append([Prefix, Mid, Suffix], NP),
         palindrome_split(Prefix, Mid, Suffix, Pa, Na),
         length(Pa, La)),
        Palindromes),
    sort(1, @>, Palindromes, [[_, P, N] | _]).

C ++, 254 248 246 bayt

Zacharý -2 bayt sayesinde -6 bayt Toby Speight sayesinde

#include<string>
#define S size()
#define T return
using s=std::string;int p(s t){for(int i=0;i<t.S;++i)if(t[i]!=t[t.S-i-1])T 0;T 1;}s d(s e){if(!p(e))for(int i,w=1;w<e.S;++w)for(i=0;i<=e.S-w;++i){s t=e;t.erase(i,w);if(p(t))T e.substr(i,w);}T"";}

Yani...

• Ben Tbir makro tanımı olarak kullandım çünkü R""string literal üzerinde başka bir etki olarak (ham string literalleri tanımlamak için kullanılan bir önektir, daha fazla bilgi için cppreference'a bakınız) yaptığım zaman orada bulunmuyor.T""
• Önişlemci tanımları aynı satırda olamaz ve tanımdaki ad ile içerik arasında en az bir boşluk olması gerekir
• 2 fonksiyon: p(std::string)dizginin bir palindrom olup olmadığını test etmek için. Eğer öyleyse, 1hangi seçeneğe döner true, başka yere döner 0, hangisine döner?false
• Algoritma, her zaman 1 elemanı silerken bir palindrom ise tüm dizi testi üzerinde döngü yapar, daha sonra ilk dizinden itibaren, 2 elemanın silinmesini test eder (bunun üzerine dizginin maksimum büyüklüğüne kadar olan döngüler) the last index - number of erased char. Bir kısmını silmeyi bulursa bir palindrom, sonra döner. Örneğin, dizeyi "aabcdbaa"parametre olarak geçirirken , her ikisi de cve dgeçerli bir cevaptır, ancak bu kod geri dönecektir, cçünkü onu siler ve bir palindrom olup olmadığını dtest eder, sınamadan önce siler ve palindrom ise test eder

• İşte test edilecek kod:

  std::initializer_list<std::pair<std::string, std::string>> test{
      {"800233008","2"},
      { "racecarFOOL","FOOL" },
      { "abcdedcba","" },
      { "ngryL Myrgn","L " },
      { "123456789","12345678" },
      { "aabcdbaa","c" },
      { "[[]]","[[" },
      { "a","" },
      { "aabaab","b" }
  };
  
  for (const auto& a : test) {
      if (a.second != d(a.first)) {
          std::cout << "Error on : " << a.first << " - Answer : " << a.second  << " - Current : " << d(a.first) << '\n';
      }
  }

Jöle , 33 bayt

r/ḟ@J}ị
“”µJp`ç³$ŒḂ$Ðfạ/ÞḢr/ịµŒḂ?

Çevrimiçi deneyin!

PHP 104 + 1 bayt

while(~($s=$argn)[$e+$i++]?:++$e|$i=0)strrev($t=substr_replace($s,"",$i,$e))==$t&&die(substr($s,$i,$e));

Pipe ile çalıştırın -nRveya çevrimiçi deneyin .

Haskell , 109 105 bayt

snd.minimum.([]#)
p#s@(a:b)=[(i,take i s)|i<-[0..length s],(==)<*>reverse$p++drop i s]++(p++[a])#b
p#_=[]

Çevrimiçi deneyin!

EDIT: H.PWiz 4 bayt ayırdığınız için teşekkürler! Bu monadlarla daha iyi olmam gerek!

JavaScript, 90 bayt

a=>a.map((_,p)=>a.map((_,q)=>k||(t=(b=[...a]).splice(q,p),k=''+b==b.reverse()&&t)),k=0)&&k

Çevrimiçi deneyin!

f=
a=>a.map((_,p)=>a.map((_,q)=>k||(t=(b=[...a]).splice(q,p),k=''+b==b.reverse()&&t)),k=0)&&k

F=a=>console.log(a.padEnd(11)+' ---> '+f([...a]).join``)
F('800233008')
F('racecarFOOL')
F('abcdedcba')
F('ngryL Myrgn')
F('123456789')
F('aabcdbaa')
F('[[]]')
F('a')
F('aabaab')

Perl 5, 72 + 1 (-p) bayt

$\=$_;/.*(?{$,=$`.$';$\=$&if length$&<length$\&&$,eq reverse$,})(?!)/g}{

Çevrimiçi deneyin

JavaScript (ES6), 91 78 bayt

(s,i=0,j=0,S=[...s],b=S.splice(i,j))=>S+''==S.reverse()?b:f(s,s[++i]?i:!++j,j)

Giriş ve çıkış karakterlerin listesidir.

Bir palindrom bulunana kadar tekrarlı olarak daha büyük ve daha büyük bir dilimi girdiden kaldırır.

Parça, parçacık:

f=
(s,i=0,j=0,S=[...s],b=S.splice(i,j))=>S+''==S.reverse()?b:f(s,s[++i]?i:!++j,j)


console.log(f([...'800233008']).join``)   // 2
console.log(f([...'racecarFOOL']).join``) // FOOL
console.log(f([...'abcdedcba']).join``)   // (empty string)
console.log(f([...'ngryL Myrgn']).join``) // "L " (or " M")
console.log(f([...'123456789']).join``)   // 12345678 (or 23456789)
console.log(f([...'aabcdbaa']).join``)    // c (or d)
console.log(f([...'[[]]']).join``)        // [[ (or ]])
console.log(f([...'a']).join``)           // (empty string)

TSQL (2016) 349B

En kompakt değil, basit çözüm:

DECLARE @i VARCHAR(255)='racecarFOOL'
;WITH DAT(v,i,l)AS(SELECT value,(ROW_NUMBER()OVER(ORDER BY value))-1,LEN(@i)FROM STRING_SPLIT(REPLICATE(@i+';',LEN(@i)+1),';')WHERE value<>'')
SELECT TOP 1C,S
FROM(SELECT LEFT(D.v, D.i)+SUBSTRING(D.v,D.i+E.i+1,D.l)C,SUBSTRING(D.v,D.i+1,E.i)S
FROM DAT D CROSS APPLY DAT E)C
WHERE C=REVERSE(C)
ORDER BY LEN(C)DESC

Kabuğu , 18 bayt

◄LfmS=↔†!⁰ṠM-Qŀ⁰Q⁰

Çevrimiçi deneyin!

açıklama

◄LfmS=↔†!⁰ṠM-Qŀ⁰Q⁰  Input is a string, say s="aab"
              ŀ⁰    Indices of s: x=[1,2,3]
             Q      Slices: [[],[1],[1,2],[2],[1,2,3],[2,3],[3]]
          ṠM-       Remove each from x: [[1,2,3],[2,3],[3],[1,3],[],[1],[1,2]]
       †!⁰          Index into s: ["aab","ab","b","ab","","a","aa"]
   mS=↔             Check which are palindromes: [0,0,1,0,1,1,1]
  f             Q⁰  Filter the slices of s by this list: ["aa","aab","ab","b"]
◄L                  Minimum on length: "b"

Haskell , 98 94 81 80 bayt

""#0
(h#n)t|(==)=<<reverse$h++drop n t=take n t|x:r<-t=(h++[x])#n$r|m<-n+1=t#m$h

Çevrimiçi deneyin! Örnek kullanım: ""#0 $ "aabaab"verim "b".

Düzenleme: rjan Johansen sayesinde -1 bayt.

C ++, 189 186 176 167 bayt

HatsuPointerKun'un cevabı ile başladım , sadece eşitliği tersine çevirmek için testi değiştirdim; sonra aday dizgileri nasıl sıraladığımızı değiştirdim. Bunu takiben makrolar yalnızca bir veya iki defa kullanıldı ve satır içi için daha kısa oldu.

#include<string>
using s=std::string;s d(s e){for(int i,w=0;;++w){s t=e.substr(w);for(i=-1;++i<=t.size();t[i]=e[i])if(t==s{t.rbegin(),t.rend()})return e.substr(i,w);}}

açıklama

Eşdeğer okunabilir kod:

std::string downgrade(std::string e)
{
    for (int w=0; ; ++w) {
        std::string t = e.substr(w);
        for (int i=0;  i<=t.size();  ++i) {
            if (t == std::string{t.rbegin(),t.rend()})
                // We made a palindrome by removing w chars beginning at i
                return e.substr(i,w);
            t[i] = e[i];  // next candidate
        }
    }
}

Adayların numaralandırılması, ilk wkarakterlerin çıkarıldığı bir dize başlatılarak başlar ve ardından ardışık karakterleri, orijinali hareket ettirmek için orijinalden kopyalar. Örneğin, foobarve w== 2 dizesiyle :

foobar
  ↓↓↓↓
  obar

foobar
↓
fbar

foobar
 ↓
foar

foobar
  ↓
foor

foobar
   ↓
foob

İlk geçiş ( w== 0 ile) no-op'tur, bu nedenle tam dize tekrar tekrar ele alınacaktır. Bu iyi - golf trump verimlilik! Bu döngünün son yinelemesi, son bir öncekine endekse erişecektir; GCC ile bundan kurtulmuş gibiyim, ama kesinlikle, bu Tanımsız Davranış.

Test programı

HatsuPointerKun'ın yanıtından doğrudan bir asansör :

static const std::initializer_list<std::pair<std::string, std::string>> test{
    { "800233008", "2" },
    { "racecarFOOL", "FOOL" },
    { "abcdedcba", "" },
    { "ngryL Myrgn", "L " },
    { "123456789", "12345678" },
    { "aabcdbaa", "c" },
    { "[[]]", "[[" },
    { "a","" },
    { "aabaab", "b" }
};

#include <iostream>
int main()
{
    for (const auto& a : test) {
        if (a.second != d(a.first)) {
            std::cout << "Error on: " << a.first
                      << " - Expected: " << a.second
                      << " - Actual: " << d(a.first) << '\n';
        }
    }
}

REXX, 132 bayt

a=arg(1)
l=length(a)
do i=1 to l
  do j=0 to l-i+1
    b=delstr(a,i,j)
    if b=reverse(b) & m>j then do
      m=j
      s=substr(a,i,j)
      end
    end
  end
say s

Ruby , 86 84 bayt

->s{l=i=0
(l+=(i+=1)/z=s.size-l+1
i%=z)while(w=s[0,i]+s[i+l..-1])!=w.reverse
s[i,l]}

Çevrimiçi deneyin!

• Cyoce sayesinde 2 bayt kurtarıldı

C (gcc) , 307 bayt

#define T malloc(K)
P(S,i,y,z,k,u,L,K,V)char*S;{char*M,*R,*E;K=strlen(S);M=T;R=T;E=T;for(i=0;i<K;++i){for(y=0;y<=K-i;++y){strcpy(M,S);for(z=y;z<y+i;E[z-y]=M[z],++z);for(k=y;k+i<=K;M[k]=M[k+i],++k);V=strlen(M);strcpy(R,M);for(u=0;u<V/2;L=R[u],R[u]=R[V-u-1],R[V-u-1]=L,++u);if(!strcmp(M,R))puts(E),exit(0);}}}

Çevrimiçi deneyin!