एक पलिंड्रोम बनाने के लिए एक पत्र निकालें


15

मुसीबत

मान लीजिए कि एक शब्द लगभग एक पैलिंड्रोम है यदि इसके किसी एक अक्षर को निकालना संभव है, ताकि यह शब्द एक पैलिंड्रोम बन जाए। आपका कार्य एक प्रोग्राम लिखना है जो किसी दिए गए शब्द के लिए निर्धारित करता है कि किस पत्र को हटाने के लिए एक पैलिंड्रोम प्राप्त करना है।

किसी भी प्रोग्रामिंग भाषा में ऐसा करने वाला सबसे छोटा कोड जीत जाता है।

इनपुट

इनपुट में 2 से 1000 अक्षरों तक के अपरकेस अक्षरों का एक शब्द है।

उत्पादन

आउटपुट 1-अनुक्रमित स्थिति (बाएं अक्षर में स्थिति 1 है, अगले वाले में स्थिति 2 है और इसी तरह) पत्र को हटा दिया जाना चाहिए। अगर वहाँ संभव विकल्प हैं जो पैलिंड्रोम की ओर ले जाते हैं, तो उनमें से किसी भी स्थिति को आउटपुट करते हैं। ध्यान दें कि आपको एक पत्र को हटाने की आवश्यकता है भले ही दिए गए शब्द पहले से ही एक palindrome हो। यदि दिया गया शब्द लगभग एक पैलिंड्रोम नहीं है, तो आउटपुट -1।


उदाहरण

इनपुट:

racercar

उत्पादन हो सकता है:

5

क्योंकि 5वें अक्षर को हटाने से उत्पादन होता है racecar, जो कि एक ताल है।

साथ ही, इनपुट

racecar

अभी भी उत्पादन का उत्पादन कर सकते हैं

4

क्योंकि 4उत्पादन करने के लिए वें पत्र को हटाना raccarअभी भी एक ताल है।


5
कोई उदाहरण पोस्ट नहीं किया गया? और अगर एक इनपुट को पैलिंड्रोम में बनाना संभव नहीं है तो आउटपुट क्या होगा?
प्रोग्रामरडान

3
@ Arm103 आप अभी भी उन उदाहरणों को याद कर रहे हैं जिनका आप उल्लेख कर रहे हैं
मार्टिन

27
चेतावनी: "(उदाहरण 3 देखें)"। इससे पता चलता है कि यह होमवर्क है क्योंकि कोई उदाहरण कभी पोस्ट नहीं किया गया था।
जस्टिन

3
@Quincunx भी Mathematica सबमिशन पर थ्रेड पढ़ना सुनिश्चित करें। :-)
क्रिस जस्टर-यंग

3
यह प्रश्न ऑफ़-टॉपिक प्रतीत होता है क्योंकि उदाहरण 3 प्रश्न से अनुपलब्ध है।
devnull

जवाबों:


10

जे - ३१ २५ चार

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

जे के लिए बड़े पैमाने पर मानक किराया, इसलिए मैं सिर्फ शांत बिट्स को इंगित करूंगा।

  • क्रियाविशेषण \.को उपसर्ग कहा जाता है । x u\. yलंबाई के प्रत्येक infix को हटाता xहै yऔर uप्रत्येक हटाने के परिणाम पर लागू होता है। यहाँ, x1 है, yइनपुट स्ट्रिंग है, और uयह है (-:|.)कि स्ट्रिंग इसके विपरीत से मेल खाती है या नहीं, के लिए एक परीक्षण है। इसलिए इस एप्लिकेशन के परिणामस्वरूप \.बुलियन की एक सूची है, प्रत्येक वर्ण के स्थान पर 1 जिसका हटाने इनपुट को एक पैलिंड्रोम बनाता है।

  • I.ऊपर से सभी सूचकांकों (0-उत्पत्ति) की एक सूची बनाता है जहां 1 था। 1+इन 1-मूल सूचकांकों को बनाने के साथ 1 जोड़ना 1 था । यदि कोई सूचकांक 1 नहीं था, तो सूची खाली है। अब, हम अंतिम तत्व को साथ ले जाने की कोशिश करते हैं _1{। (हमें किसी भी हटाने योग्य पत्र को आउटपुट करने की अनुमति है!) यदि यह काम करता है, तो हम वापस लौटते हैं। हालांकि, यदि सूची खाली थी, तो कोई तत्व नहीं थे, इसलिए {एक डोमेन त्रुटि फेंकता है जिसे हम पकड़ते ::हैं और -1 के साथ वापस करते हैं [

उपयोग (याद है कि NB.टिप्पणियों के लिए है):

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

मुझे सीखना चाहिए जे। एक अजगर प्रोग्रामर के लिए कोई ट्यूटोरियल?
atı 20:uʎs

1
@Synthetica अधिकारी एक अच्छा है
जॉन Dvorak

2
@ सिंथेटिका विशेष रूप से पायथनर्स के लिए कुछ भी नहीं है, लेकिन सी प्रोग्रामर्स के लिए जे एम्पायर प्रोग्रामिंग से पलायन करने वाले किसी भी व्यक्ति के लिए एक महान संसाधन है।
एल्गोरिदमार्क

10

नहीं PHP पायथन (73):

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

जहां एक स्ट्रिंग है जिसे आप जांचना चाहते हैं। हालाँकि, यदि आप इसे किसी palindrome में नहीं बदल सकते, तो यह एक त्रुटि है। इसके बजाय, आप उपयोग कर सकते हैं

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

संपादित करें: नहीं, रुको, यह काम करता है!

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)

धन्यवाद, यह वास्तव में इस स्क्रिप्ट की php-content को लगभग 25% बढ़ाता है (यह वही है जो आप चाहते हैं, ठीक है?)


10
+1 "नॉट पीएचपी";)
मार्टिन एंडर

1
<; php $ लाइन = फॉक्स (STDIN); ?>
User011001

2
@ User011001 यह कहां फिट होगा?
atı 19:uʎs

1
आप प्रत्येक लिख कर एक चार को बचा सकता है 1>0के बजाय Trueऔर बीच की जगह को हटाने के द्वारा ]और forमें...[::-1] for g...
काया

1
@ काया आप बस 1के Trueरूप में अच्छी तरह से उपयोग कर सकते हैं । 1 == True, आख़िरकार।
अर्धजी

5

मेथेमेटिका, 106 98 87 91 वर्ण

मुझे लगता है कि मैं लंबे समारोह के नामों से थोड़ा विकलांग हूं, लेकिन इस तरह की समस्याएं गणितज्ञों में काफी मजेदार हैं:

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

यह कुछ चेतावनियों को फेंकता है, क्योंकि l_पैटर्न भी अंदर के सभी पात्रों से मेल खाता है, जो Reverseकि काम नहीं कर सकता है। लेकिन हे, यह काम करता है!

कुछ असम्बद्ध:

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

2
@ Arm103 मैं कर सकता था, लेकिन मैं किसी और को छोड़ दूँगा। ;)
मार्टिन एंडर

2
@ Arm103 प्रतीक्षा करें, क्या यह आपका होमवर्क है?
जॉन ड्वोरक

2
@JanDvorak CS पाठ्यक्रम हैं जो PHP का उपयोग करते हैं? यह डरावना होगा।
क्रिस जस्टर-यंग

2
@ आर्म103 नं। आप ;-)
जॉन ड्वोरक

4
@JDDvorak हम्म, क्या गणितज्ञ में एक कार्यक्रम है?
मार्टिन एंडर

5

गोल्फस्क्रिप्ट, 28 26 वर्ण

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

पीटर द्वारा 2 पात्रों को छोटा करने के लिए धन्यवाद। परीक्षण मामलों की ऑनलाइन कोशिश करें :

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

लगता है कि वहाँ एक छोटा रास्ता होना चाहिए, लेकिन मुझे यह नहीं मिला।
हावर्ड

RACECARई। के साथ एक पैलिंड्रोम अभी भी है। क्या किसी चरित्र को हटाने के लिए यह निर्दिष्ट करना आवश्यक है, जब इनपुट किया गया शब्द पहले से ही एक पल्लिंड्रो है?
चाचा

@ चाचा, हाँ। युक्ति का दंडात्मक वाक्य।
पीटर टेलर

क्यों -2]$-1=)? उस ब्लॉक के प्रारंभ में आपके पास स्टैक पर अधिकतम एक आइटम है, जिससे आप आसानी से छोटा कर सकते हैं -2]0=)। (या समान लंबाई के लिए, ]-2or)मैंने orविशेष मामलों के लिए प्यार करना सीख लिया है )।
पीटर टेलर

2
@ हॉवर्ड अगर मुझे हर बार निकल जाता था तो मुझे गोल्फस्क्रिप्ट के बारे में ऐसा लगता था ...
एल्गोरिथममार्क

3

Rebol (81)

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

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


पिछले पैलिंड्रोम का रिटर्न इंडेक्स मिला। एक वैकल्पिक समाधान (85 वर्ण) जो कि पाया गया हर पैलिंड्रोम लौटाता है:

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

तो इसके लिए "racercar"सूची में वापस आएंगे [4 5]


यदि आपने रिबमु बोली का उपयोग किया है, तो पहला समाधान सिर्फ 37 वर्णों का है, मूल रूप से समान कोड होने के बावजूद :-) रीमू / आर्ग्स के रूप में आमंत्रित करें "Rng01rpNl? A [ThdRMatCYaNieTvCYt [Rn]] r" "racecar" ? ध्यान दें कि Rebmu प्रलेखन में सुधार किया गया है, और हाल के परिवर्तनों ने इसे थोड़ा कस दिया है ... अभी भी सभी के समक्ष प्रतिक्रिया की तलाश कर रहे हैं और उनका डी इसका उपयोग करना शुरू कर रहा है। :-)
HostileFork का कहना है कि 22

3

सी #, 134 वर्ण

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

मुझे पता है कि मैं हार गया :( लेकिन यह अभी भी मजेदार था : डी

पठनीय संस्करण:

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

3
हाँ मज़ा !!!!! :)
आलमो

1
गोल्फ संस्करण में, कहाँ Rपरिभाषित और प्रयोग किया जाता है?
टूथब्रश

ओह, हाँ, इसे var R = s.Remove (i, 1) कहना चाहिए । अच्छी पकड़
न्यूटन

3

स्टैक्स , 8 10 बाइट्स

ú·àA÷¡%5Ñ╙

इसे चलाएं और डीबग करें

यह कार्यक्रम सभी 1-आधारित सूचकांकों को दिखाता है जिन्हें स्ट्रिंग से पैलिंड्रोम बनाने के लिए हटाया जा सकता है। और अगर कोई नहीं हैं, तो यह दिखाता है -1।


2
यह -1 के बजाय अंतिम इंडेक्स को आउटपुट करता है, यदि कोई पैलिंड्रोम नहीं मिला है (यानी aaabbआउटपुट के 5बजाय -1)।
केविन क्रूज़सेन

1
@ केविनक्रूजसेन: सही हैं आप। मैंने इसे 2 बाइट्स की कीमत पर तय किया।
पुनरावर्ती

2

रूबी (61):

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

यहाँ, एक रूबी समाधान है। यदि यह नहीं किया जा सकता है तो इसे हटाने या -1 के लिए चरित्र की स्थिति वापस आ जाएगी।

मैं मदद नहीं कर सकता, लेकिन लगता है कि डुप और स्लाइस सेक्शन के साथ सुधार किया जा सकता है, लेकिन रूबी के पास एक स्ट्रिंग विधि नहीं है जो एक विशिष्ट इंडेक्स पर एक चरित्र को हटा देगा और नया स्ट्रिंग -__ लौटाएगा।

टिप्पणी के अनुसार संपादित, ty!


1
आप फंक्शन / मेथड में रैपिंग न करके कुछ जगह बचा सकते हैं। हालाँकि आपका कोड वर्तमान में 0-आधारित इंडेक्स (1-आधारित होना चाहिए) लौटाता है और -1यदि कोई पाइंड्रोम नहीं मिला है तो भी इसे वापस करना होगा।
ड्रेगेटुन

फिक्स्ड -1, धन्यवाद। यह सुनिश्चित नहीं है कि आपके मन में क्या है, हालांकि इसे एक विधि के रूप में लेना, मेरे पास एक सोच होगी।
माइक कैंपबेल

ठीक है, बोर्ड पर आपकी सलाह ली और इसे फिर से लिखा :), ty।
माइक कैंपबेल

आपका स्वागत है! अब यह बहुत बेहतर है :) +1
draegtun

2

05AB1E , 10 बाइट्स

gL.Δõs<ǝÂQ

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें

स्पष्टीकरण:

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)

2

अजगर नहीं पीएचपी ,85 83 81 बाइट्स

while($argn[$x])$s!=strrev($s=substr_replace($argn,'',$x++,1))?:die("$x");echo-1;
  • -2 बाइट्स @ रात 2 को धन्यवाद!

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

अनावश्यक रूप से पुनरावर्ती:

PHP , 96 बाइट्स

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

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


1

हास्केल, 107 वर्ण:

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

एक समारोह के रूप में ( 85 वर्ण ):

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

मूल ungolfed संस्करण:

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

1

C # (184 अक्षर)

मैं मानता हूं कि यह कोड-गोल्फिंग करने के लिए सबसे अच्छी भाषा नहीं है ...

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

प्रारूपित और टिप्पणी की गई:

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

1

C # (84 वर्ण)

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

LINQpad कथन iइनपुट स्ट्रिंग में परिवर्तनशील होने की अपेक्षा करता है । आउटपुट को oचर में संग्रहीत किया जाता है।


1

हास्केल, 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

इस तरह कहा जाता है:

λ> f "racercar"
5

1

जाप , 8 बाइट्स

a@jYÉ êS

कोशिश करो

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?

0

हास्केल, 118 सी

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

0

जेली , 17 14 बाइट्स

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

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

           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.

चूँकि मैंने पुराने संस्करण को संपादित इतिहास में न दिखाने के लिए अपना दृष्टिकोण बहुत तेज़ी से बदला, यह यह था: ŒPṚḊŒḂ€TṂ©’<La®o-


0

ब्रेकीलॉग , 24 बाइट्स

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

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

बहुत लंबा लगता है।

यदि उत्पादन 2-अनुक्रमित हो सकता है तो दो बाइट्स कम हो सकते हैं :

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

दो पहले और भी बदतर पुनरावृत्तियों:

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

एक वैश्विक चर के उत्तरार्द्ध का उपयोग एक अलग परीक्षण हेडर की आवश्यकता है ।



0

वोल्फ्राम भाषा (गणितज्ञ) , 56 बाइट्स

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

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

वर्णों की सूची के रूप में इनपुट लेता है। स्ट्रिंग इनपुट के लिए, संलग्न करें @*Characters

PalindromeQ2015 में शुरू किया गया था। वैकल्पिक लागत +4 बाइट्स



0

C (gcc) , 180 168 159 157 140 139 बाइट्स

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

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

१६ 17 बाइट्स सीटिंग के लिए धन्यवाद मुंडा! और 3 और बाइट्स क्योंकि नियम बताता है कि इनपुट की न्यूनतम लंबाई 2 वर्ण है, इसलिए खाली तारों की जांच करने की आवश्यकता नहीं है।

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

@ceilingcat जो &&!++pकेवल समझाने के लिए कुटिल है :)
जी। स्लीपेन

-1

अजगर, 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

यह जांच नहीं करता है कि इनपुट (स्ट्रिंग एस) लगभग पैलिंड्रोम है, लेकिन क्या समय कुशल और पठनीय है।


2
s[-(i+1)]को छोटा किया जा सकता है s[-i-1]। इसके अलावा, मैं यकीन नहीं है, लेकिन आप को बदलने के लिए सक्षम हो सकता है if...else...के साथreturn i+1 if ... else len(s)-1
user12205

यह ठीक काम किया है .. किसी को भी इसके पीछे तर्क समझा सकते हैं?
अरिंदम रॉयचौधरी

आवश्यकता यह है कि यह आउटपुट -1 है यदि इनपुट एक अतिरिक्त अक्षर के साथ एक तालमेल नहीं है। इसलिए, उदाहरण के लिए, अगर s = "abcde", यह -1 लौटाना चाहिए।
जी। स्लीपेन

-2

मेरा पहला कोड-गोल्फ।

जावा। ~ 1200 वर्ण मुख्य (और उप) कार्यों में। हाँ बेबी।

कक्षा शीर्ष और उपयोग:

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

पूर्ण वर्ग:

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

3
यह कोड को गोल करने की कोई कोशिश नहीं दिखाता है।
mbomb007
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.