एक पलिंड्रोम के लिए डाउनग्रेड करें

47

एक स्ट्रिंग को देखते हुए s, सबसे छोटी सन्निहित प्रतिस्थापन लौटाएं जिसे आप एक palindrome बनाने के लिए निकाल सकते हैं।

उदाहरण:

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

उपयोगकर्ताओं से परीक्षण मामले के सुझाव (यदि आपको कोई सूचीबद्ध मामला नहीं मिला है, तो कृपया एक टिप्पणी पोस्ट करें):

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

नियम

  • केवल मुद्रण योग्य ASCII वर्ण इनपुट में दिखाई देंगे (कोई नया अंक नहीं, इसे सरल रखें)।
  • वास्तव में एक नियम है, लेकिन नोट <>, /\, (), []और {}खोल देना नहीं हैं।

यह कोड-गोल्फ , सबसे छोटी बाइट-काउंट जीत है।

अदनान द्वारा +100 इनाम का दावा किया गया है

code-golf  string  palindrome 
— जादू ऑक्टोपस Urn
स्रोत
3
टेस्फ़ केस:aabaab
— ज़र्गब
14
मुझे लगता है कि अगर यह "CMC" की तरह शब्दजाल से बचा जाता है, तो इसे और अधिक आगंतुकों के लिए सुलभ रखने में मदद मिलेगी, (इसे देखते हुए, यह "चैट मिनी चैलेंज" के लिए खड़ा प्रतीत होता है, जो मुझे लगता है कि चैट रूम से जुड़ी एक छोटी सी चुनौती से संबंधित है) इस साइट)।
— श्रीवत्सआर
[[]]एक ताल नहीं है?
— कार्ल
4
@ कार्ल यह एक जैसा लग सकता है, लेकिन जब आप पात्रों को उलटते हैं, तो आपको मिलता है ]][[। गौर कीजिए कि aabbएक ही चीज है, बस अलग-अलग किरदार।
— कोनोर ओ'ब्रायन
1
" (7/12 से सम्मानित किया जाएगा) " हुह?
— आउटगोल्फ

जवाबों:

8

जेली , 16 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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.
— डेनिस
स्रोत
10

जे , 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

(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
— मील की दूरी पर
स्रोत
शायद आप (;&quote f)&>परीक्षण हार्नेस क्रिया के रूप में चुनना चाहें ?
— कोनोर ओ'ब्रायन
7

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 53 51 बाइट्स

बाइट गिनती CP-1252 एन्कोडिंग मानती है।

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

इसे ऑनलाइन आज़माएं!

एक एकीकृत ऑपरेटर ±(या एक फ़ंक्शन PlusMinus) को परिभाषित करता है । इनपुट और आउटपुट पात्रों की सूची है। परीक्षण सूट से और सुविधा के लिए वास्तविक तार से रूपांतरण होता है।

— मार्टिन एंडर
स्रोत
है Reverseतो PalindromeQ की तुलना में कम मूल है कि रिवर्स की तुलना? मैं गणितज्ञ को नहीं जानता, इसलिए कोई विचार नहीं है।
— मैजिक ऑक्टोपस Urn
अच्छा जवाब है, लेकिन एक तार के बंटवारे और उन्हें वापस अपने चरित्र की गिनती में शामिल होने के लिए एक खाता नहीं होना चाहिए? Characters@#/.{a___,Shortest@b___,c___}/;PalindromeQ[a<>c]:>b~~""&
— केली लोडर
@MagicOctopusUrn Reverse[x={a,c}]==xदो बाइट्स लंबा है। मुझे नहीं पता कि कोई छोटा विकल्प है या नहीं।
— मार्टिन एंडर
@ केलीलॉडर के पात्रों की सूची पीपीसीजी पर तार के वैध प्रतिनिधित्व हैं। यह गणितज्ञ में थोड़ा अजीब है, जहां आप सामान्य रूप से उस प्रतिनिधित्व का उपयोग नहीं करेंगे, लेकिन यह अभी भी मान्य है। मैं एक मेटा पोस्ट खोदूँगा।
— मार्टिन एंडर
1
@ केलीलॉडर मुझे लगता है कि यह स्वीकृत नीति है । गणितज्ञों में यह अजीब होने का मुख्य कारण यह है कि गणितज्ञ के पास वास्तविक चरित्र प्रकार नहीं है, इसलिए पात्र अंत में सिंगलटन स्ट्रिंग्स होते हैं।
— मार्टिन एंडर
5

05AB1E , 18 बाइट्स

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

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत
फिल्टर के दिलचस्प उपयोग ... हम एक "बिना बी" प्रकार का सौदा करने की कोशिश कर रहे थे, लेकिन अगर प्रतिस्थापन के दो उदाहरण थे, तो हमें गलत नकारात्मक मिलेगा। लगता है जैसे हम इसे अब और अधिक जटिल कर रहे थे कि मैं इस लोल को देखता हूं। Noice, मैं आपको 2 दिनों में 100 इनाम दूंगा।
— मैजिक ऑक्टोपस Urn
ǝहालांकि गंभीर रूप से प्रतिभाशाली था।
— मैजिक ऑक्टोपस Urn
3

पायथन 2 , 116 बाइट्स

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)

इसे ऑनलाइन आज़माएं!

Halvard से मदद के साथ बाइट्स के एक जोड़े को बचाया !

— मिस्टर एक्सकोडर
स्रोत
— हैलवार्ड शेम्स
@HalvardHummel धन्यवाद, मैं इसे बदलने की योजना बना रहा था, लेकिन पिछले 2 घंटों से इंटरनेट कनेक्शन नहीं था।
— श्री एक्सकोडर
2

जाप , 26 22 बाइट्स

¬£¬ËUjEY ꬩUtEY
c æ+0

इसे ऑनलाइन टेस्ट करें! यह पता लगाने की कोशिश की जा रही है कि falseएक झटके में कुछ सत्य और किसी भी स्ट्रिंग को कैसे दिखाया जाए। वर्तमान में मैं उपयोग कर रहा हूँ +0...

— ETHproductions
स्रोत
2

बैश , 108 बाइट्स

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

कमांड-लाइन तर्क के रूप में इनपुट लेता है।

इसे ऑनलाइन आज़माएं! अग्रणी / अनुगामी स्थानों को देखने के लिए आउटपुट के चारों ओर मुद्रित उद्धरणों के साथ।

— जस्टिन मेरिनर
स्रोत
2

प्रोलॉग , 271 बाइट

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

कुछ बिंदु पर मैंने महसूस किया कि यह कोड-गोल्फ मानकों से बहुत बड़ा होने वाला है, इसलिए मैंने कुछ अतिरिक्त रिक्त स्थानों को गैर-अस्पष्ट संस्करण के समान बनाए रखने के लिए रखा। लेकिन मुझे अभी भी लगता है कि यह दिलचस्प हो सकता है क्योंकि यह समस्या के लिए एक अलग दृष्टिकोण है।

गैर-बाधित संस्करण:

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] | _]).
— wvxvw
स्रोत
2

सी ++, 254 248 246 बाइट्स

-6 बाइट्स Zacharý -2 बाइट्स के लिए धन्यवाद टोबी स्पाइट के लिए धन्यवाद

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

इसलिए...

  • मैंने Tएक स्थूल परिभाषा के रूप में उपयोग किया क्योंकि R""स्ट्रिंग शाब्दिक पर एक और प्रभाव के रूप में कर रहा है (यह कच्ची स्ट्रिंग शाब्दिक को परिभाषित करने के लिए उपयोग किया जाने वाला उपसर्ग है, अधिक informations के लिए cppreference देखें) जब मैं ऐसा नहीं करता हूंT""
  • प्रीप्रोसेसर परिभाषाएं एक ही पंक्ति में नहीं हो सकती हैं, और परिभाषा में नाम और सामग्री के बीच कम से कम एक स्थान होना चाहिए
  • 2 फ़ंक्शन: p(std::string)यह जांचने के लिए कि क्या स्ट्रिंग एक पैलिंड्रोम है। यदि यह है, तो यह 1जो लौटता है, वह वापस trueलौटता है 0, जो वापस आता हैfalse
  • एल्गोरिथ्म पूरे स्ट्रिंग परीक्षण पर लूप करता है यदि यह एक पैलिंड्रोम है जब प्रत्येक बार 1 तत्व मिटाते हैं, तो पहले तत्वों से 2 तत्वों (उस पर स्ट्रिंग के अधिकतम आकार तक) को मिटाते हुए परीक्षण करें the last index - number of erased char। यदि यह पाता है कि कुछ हिस्सा मिट रहा है, तो यह वापस आ जाता है। उदाहरण के लिए, जब स्ट्रिंग "aabcdbaa"को पैरामीटर के रूप में पास किया जाता है, तो दोनों cऔर dमान्य उत्तर होते हैं, लेकिन यह कोड वापस आ जाएगा cक्योंकि इसे मिटा देना और परीक्षण करना अगर यह एक पैलिंड्रोम है, तो परीक्षण से पहले आता है यदि मिटाने dऔर परीक्षण करने से पहले यदि यह लंबित है

  • यहाँ परीक्षण करने के लिए कोड है:

    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';
    }
}
— HatsuPointerKun
स्रोत
क्या यह अंतिम पंक्ति के लिए काम करेगा? using s=std::string;int p(s t){for(int i=0;i<t.S/2;++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"";}
— Zacharý
कर सकते हैं /2लोप हो? पूरी लंबाई में इटरेटिंग बस हमारे द्वारा किए गए परीक्षणों को दोहराएगा, जो हानिरहित होना चाहिए। आप "अन्य प्रभाव" R""(यानी यह एक कच्चे स्ट्रिंग शाब्दिक के रूप में पार्स किया जाता है) के द्वारा आप क्या मतलब चाहते हैं, इसका विस्तार करना चाहते हैं ।
— टोबे स्पाइट
मैंने इसे संशोधित किया है और परिणाम को अपने स्वयं के उत्तर के रूप में जोड़ा है ।
— टोबी स्पाइट
1

जावास्क्रिप्ट, 90 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कोड स्निपेट दिखाएं

1

जावास्क्रिप्ट (ईएस 6), 91 78 बाइट्स

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

इनपुट और आउटपुट पात्रों की सूची है।

पुनरावर्ती इनपुट से एक बड़ा और बड़ा टुकड़ा निकालता है जब तक कि एक पैलिंड्रोम नहीं मिलता है।

स्निपेट:

कोड स्निपेट दिखाएं

— रिक हिचकॉक
स्रोत
1

TSQL (2016) 349B

सबसे कॉम्पैक्ट नहीं बल्कि सीधा समाधान:

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
— जान ड्रोजेन
स्रोत
आप @कुछ बाइट्स के लिए एक चर के रूप में उपयोग कर सकते हैं । सीटीई में आप where''=value)एक और एक के लिए उपयोग कर सकते हैं और आपको Cपरिणाम में वापस जाने की आवश्यकता नहीं है ।
— मिक्यट
1

हस्क , 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

◄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"
— Zgarb
स्रोत
1

हास्केल , 98 94 81 80 बाइट्स

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

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: ""#0 $ "aabaab"पैदावार "b"।

संपादित करें: ० अर्जन जोहान्सन को धन्यवाद।

— Laikoni
स्रोत
1
आप पिछले ""द्वारा प्रतिस्थापित कर सकते हैं t।
— अर्जन जोहान्सन
1

सी ++, 189 186 176 167 बाइट्स

मैंने HatsuPointerKun के उत्तर के साथ शुरुआत की , परीक्षण को बदलकर बस उलट स्ट्रिंग के साथ समानता की तुलना की; फिर मैंने बदल दिया कि हम किस तरह से प्रत्याशी के तारों की गणना करते हैं। इसके बाद, मैक्रोज़ का उपयोग केवल एक या दो बार किया गया था, और उन्हें इनलाइन करना कम था।

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

व्याख्या

समतुल्य पठनीय कोड:

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

अभ्यर्थियों की गणना शुरू होने वाले पहले wवर्णों के साथ स्ट्रिंग शुरू करके , और फिर अंतर को स्थानांतरित करने के लिए मूल से क्रमिक वर्णों की प्रतिलिपि बनाकर शुरू होती है । उदाहरण के लिए, स्ट्रिंग foobarऔर w== 2 के साथ:

foobar
  ↓↓↓↓
  obar
foobar
↓
fbar
foobar
 ↓
foar
foobar
  ↓
foor
foobar
   ↓
foob

पहला पास (साथ) w == 0 के ) एक नो-ऑप है, इसलिए पूर्ण स्ट्रिंग को बार-बार माना जाएगा। यह ठीक है - दक्षता ट्रम्पिंग! इस लूप की अंतिम पुनरावृत्ति एक-अतीत-एंड-इंडेक्स तक पहुंच जाएगी; मुझे लगता है कि जीसीसी के साथ, लेकिन सख्ती से, यह अपरिभाषित व्यवहार है।

परीक्षण कार्यक्रम

HatsuPointerKun के उत्तर से एक सीधा लिफ्ट :

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';
        }
    }
}
— टोबी स्पाईट
स्रोत
0

REXX, 132 बाइट्स

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
— idrougge
स्रोत
0

रूबी , 86 84 बाइट्स

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

इसे ऑनलाइन आज़माएं!

  • साइयो के लिए धन्यवाद 2 बाइट्स सहेजे गए
— iamnotmaynard
स्रोत
आपको चारों ओर कोष्ठकों की आवश्यकता नहीं है z=s.size-l+1।
— साइओस
@Cyoce धन्यवाद। मेरे पास सभी ऑपरेटर पूर्वता को याद करने का कठिन समय है।
— नोमतमानयार्ड '’१ay
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.