Đưa ra một chuỗi s, trả về chuỗi con liền kề nhỏ nhất mà bạn có thể loại bỏ để tạo một bảng màu.

Ví dụ:

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

Kiểm tra đề xuất trường hợp từ người dùng (nếu bạn tìm thấy một trường hợp cạnh không được liệt kê, xin vui lòng gửi bình luận):

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

Quy tắc

• Chỉ các ký tự ASCII có thể in sẽ xuất hiện trong đầu vào (không có dòng mới, giữ cho nó đơn giản).
• Không thực sự là một quy luật, nhưng lưu ý <>, /\, (), []và {}không palindromes.

Đây là môn đánh gôn , đánh số byte nhỏ nhất.

+100 tiền thưởng đã được yêu cầu bởi Adnan

Thạch , 16 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

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

Hãy thử trực tuyến!

Giải trình

(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

Ngôn ngữ Wolfram (Mathicala) , 53 51 byte

Số lượng byte giả định mã hóa CP-1252.

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

Hãy thử trực tuyến!

Xác định một toán tử đơn nguyên ±(hoặc một hàm PlusMinus). Đầu vào và đầu ra là danh sách các ký tự. Bộ kiểm tra thực hiện chuyển đổi từ và sang chuỗi thực tế để thuận tiện.

Thạch , 20 byte

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

Hãy thử trực tuyến!

05AB1E , 18 byte

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

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Python 3 , 97 byte

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)

Hãy thử trực tuyến!

Python 2 , 116 byte

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)

Hãy thử trực tuyến!

Đã lưu một vài byte với sự giúp đỡ từ Halvard Hummel !

Japt , 26 22 byte

¬£¬ËUjEY ꬩUtEY
c æ+0

Kiểm tra nó trực tuyến! Cố gắng tìm ra cách ánh xạ falsetới một cái gì đó sai lệch và bất kỳ chuỗi nào thành một thứ gì đó trung thực trong một byte. Hiện tại tôi đang sử dụng +0...

Bash , 108 byte

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

Lấy đầu vào làm đối số dòng lệnh.

Hãy thử trực tuyến! với các trích dẫn được in xung quanh đầu ra để xem các không gian hàng đầu / dấu.

Prolog , 271 byte

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

Tại một số thời điểm, tôi nhận ra rằng điều này sẽ rất lớn theo tiêu chuẩn golf-code, vì vậy tôi đã giữ thêm một vài khoảng trống để duy trì sự tương đồng với phiên bản không bị che khuất. Nhưng tôi vẫn nghĩ nó có thể thú vị vì đó là một cách tiếp cận vấn đề khác.

Phiên bản không bị xáo trộn:

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 byte

-6 byte nhờ Zacharý -2 byte nhờ Toby Speight

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

Vì thế...

• Tôi đã sử dụng Tnhư một định nghĩa vĩ mô vì thực hiện R""như một hiệu ứng khác trên chuỗi ký tự (đó là tiền tố được sử dụng để xác định các chuỗi ký tự thô, xem cppreference để biết thêm thông tin) không có ở đó khi tôi làmT""
• Các định nghĩa tiền xử lý không thể nằm trên cùng một dòng và phải có ít nhất một khoảng trắng giữa tên và nội dung trong định nghĩa
• 2 hàm: p(std::string)để kiểm tra xem chuỗi có phải là palindrom không. Nếu có, nó trả về 1phôi truenào, nó trả về 0, phôi nàofalse
• Thuật toán lặp trên toàn bộ chuỗi kiểm tra nếu đó là một bảng màu khi xóa mỗi lần 1 phần tử, sau đó kiểm tra xóa 2 phần tử (vòng lặp trên đó đến kích thước tối đa của chuỗi), từ chỉ mục đầu tiên đến the last index - number of erased char. Nếu nó tìm thấy xóa một số phần là một palindrom, sau đó, nó trở lại. Ví dụ: khi truyền chuỗi "aabcdbaa"dưới dạng tham số, cả hai cvà dđều là câu trả lời hợp lệ, nhưng mã này sẽ trả về cvì xóa nó và kiểm tra nếu đó là một palindrom xuất hiện trước khi kiểm tra nếu xóa dvà kiểm tra nếu đó là palindrom

• Đây là mã để kiểm tra:

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

Thạch , 33 byte

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

Hãy thử trực tuyến!

PHP 104 + 1 byte

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

Chạy như ống với -nRhoặc thử trực tuyến .

Haskell , 109 105 byte

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

Hãy thử trực tuyến!

EDIT: Cảm ơn @ H.PWiz đã gỡ 4 byte! Tôi cần phải trở nên tốt hơn với những đơn nguyên đó!

JavaScript, 90 byte

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

Hãy thử trực tuyến!

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

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

Dùng thử trực tuyến

JavaScript (ES6), 91 78 byte

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

Đầu vào và đầu ra là danh sách các ký tự.

Đệ quy loại bỏ một lát lớn hơn và lớn hơn từ đầu vào cho đến khi tìm thấy một palindrom.

Đoạn trích:

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

Không phải là giải pháp nhỏ gọn nhất nhưng đơn giản nhất:

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

Husk , 18 byte

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

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến! Ví dụ sử dụng: ""#0 $ "aabaab"sản lượng "b".

Chỉnh sửa: -1 byte nhờ rjan Johansen.

C ++, 189 186 176 167 byte

Tôi bắt đầu với câu trả lời của HatsuPulumKun , thay đổi bài kiểm tra để đơn giản so sánh sự bình đẳng với chuỗi đảo ngược; sau đó tôi đã thay đổi cách chúng ta liệt kê các chuỗi ứng cử viên. Theo đó, các macro chỉ được sử dụng một hoặc hai lần mỗi macro và nó ngắn hơn để nội tuyến chúng.

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

Giải trình

Mã tương đương có thể đọc được:

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

Việc liệt kê các ứng cử viên bắt đầu bằng cách khởi tạo một chuỗi với các wký tự đầu tiên được bỏ qua, sau đó sao chép các ký tự liên tiếp từ bản gốc để di chuyển khoảng cách. Ví dụ: với chuỗi foobarvà w== 2:

foobar
  ↓↓↓↓
  obar

foobar
↓
fbar

foobar
 ↓
foar

foobar
  ↓
foor

foobar
   ↓
foob

Vượt qua đầu tiên (với w== 0) là không có op, vì vậy chuỗi đầy đủ sẽ được xem xét lại nhiều lần. Đó là tốt - hiệu quả hơn so với golf! Lặp lại cuối cùng của vòng lặp này sẽ truy cập vào chỉ mục một quá khứ; Tôi dường như thoát khỏi điều đó với GCC, nhưng nghiêm túc, đó là Hành vi không xác định.

Chương trình kiểm tra

Thang máy trực tiếp từ câu trả lời của HatsuPulumKun :

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 byte

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 byte

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

Hãy thử trực tuyến!

• Đã lưu 2 byte nhờ Cyoce

C (gcc) , 307 byte

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

Hãy thử trực tuyến!