एक फ़ंक्शन लिखें जो किसी दिए गए स्ट्रिंग में सबसे लंबे तालमेल को लौटाता है

102

उदाहरण के लिए "ccddcc" स्ट्रिंग में "abaccddccefe"

मैंने एक समाधान के बारे में सोचा लेकिन यह O (n ^ 2) समय में चलता है

एल्गो 1:

चरण: इसकी एक क्रूर बल विधि है

  1. 2 के लिए छोरों के
    लिए i = 1 से i
    सरणी से कम है।
  2. इस तरह आप ऐरे से हर संभव संयोजन का विकल्प प्राप्त कर सकते हैं
  3. एक palindrome फ़ंक्शन होता है जो जाँचता है कि क्या एक स्ट्रिंग palindrome है
  4. इसलिए प्रत्येक प्रतिस्थापन के लिए (i, j) इस फ़ंक्शन को कॉल करें, यदि यह एक पैलिंड्रोम स्टोर है जो इसे स्ट्रिंग चर में संग्रहीत करता है
  5. यदि आपको अगला पेलिंड्रोम प्रतिस्थापन लगता है और यदि यह वर्तमान से अधिक है, तो इसे वर्तमान के साथ बदलें।
  6. अंत में आपके स्ट्रिंग चर का जवाब होगा

मुद्दे: 1. यह algo O (n ^ 2) समय में चलता है।

एल्गो 2:

  1. स्ट्रिंग को उल्टा करें और इसे अलग-अलग सरणी में संग्रहीत करें
  2. अब दोनों सरणी के बीच सबसे बड़ा मिलान विकल्प खोजें
  3. लेकिन यह भी O (n ^ 2) समय में चलता है

क्या आप लोग एक ऐसे अहंकार के बारे में सोच सकते हैं जो बेहतर समय में चलता है। यदि संभव हो तो O (n) समय

algorithm  palindrome 
— सिखाने वाला
स्रोत
42
मुझे लगता है कि पहली बार O(n^2)सबस्टैंडिंग प्राप्त करने के लिए * O(n)यह जाँचने के लिए कि क्या वे कुल मिलाकर हैं O(n^3)?
— स्काइलर सेवलैंड
क्या होगा अगर मुझे पता था कि मैं पैलिंड्रोम के साथ काम कर रहा हूं और अपने स्ट्रिंग्स को दो हिस्सों के रूप में बचा रहा हूं और फिर अगर मैंने जावा का इस्तेमाल किया तो मुझे फंक्शन के लिए ओ (1) चेक मिलेगा?
— viki.omega9
10
एकांत अहंकार सही है? स्ट्रिंग के बारे में क्या: "abcdecba"। सबसे बड़ा मिलान विकल्प है ("abcdecba" बनाम "abcedcba"): "abc" या "cba"। हालांकि, दोनों पलिंडोम नहीं हैं।
— यर्नो
@ Learner, बस जिज्ञासु, आप चरणों में ऊपर क्या आप सरणी में रेफरी के लिए कर रहे हैं अपने छोरों के लिए? सरणी से क्या आप स्ट्रिंग का जिक्र कर रहे हैं? स्ट्रिंग लंबाई?
— जोल्ट 15'13
1
O (n ^ 2) के साथ उत्तर खोजने वालों के लिए - geeksforgeeks.org/longest-palindrome-substring-set-1
— शिरीष हेरवाडे

जवाबों:

76

आप समय में Manacher के एल्गोरिथ्म का उपयोग करते हुए सबसे लंबे समय तक का पता लगा सकते हैं O(n)! इसका कार्यान्वयन यहां और यहां पाया जा सकता है ।

इनपुट के लिए String s = "HYTBCABADEFGHABCDEDCBAGHTFYW1234567887654321ZWETYGDE"यह सही आउटपुट पाता है जो है 1234567887654321।

— AnujKu
स्रोत
3
मुझे समझ नहीं आता कि यह कैसे रैखिक है। मैं बाहरी लूप के समान प्रतीत होने वाली बाउंडिंग whileके forसाथ एक एम्बेडेड देखता हूं ।
— v.oddou
2
— एरिक फिलिप्स
9

Algo 2 सभी स्ट्रिंग के लिए काम नहीं कर सकता है। इस तरह के एक स्ट्रिंग "एबीसीडीईएफसीबीए" का एक उदाहरण है।

ऐसा नहीं है कि स्ट्रिंग के रूप में "एबीसी" और "सीबीए" है। यदि आप मूल स्ट्रिंग को उल्टा करते हैं, तो यह "ABCFEDCBA" होगा। और सबसे लंबा मेल खाने वाला विकल्प "एबीसी" है जो एक पैलिंड्रोम नहीं है।

आपको इसके अतिरिक्त जांचने की आवश्यकता हो सकती है कि क्या यह सबसे लंबा मिलान विकल्प वास्तव में एक पैलिंड्रोम है जिसमें ओ (एन ^ 3) का चलने का समय है।

— VCB
स्रोत
2
यह नोट करना महत्वपूर्ण है कि एल्गो 2 को "सबसे लंबे समय तक मिलान करने वाले पैलेंड्रोम" के लिए काम करना चाहिए, जो एक सामान्य एल्गोरिदम समस्या है जहां स्ट्रिंग वर्णों को स्ट्रिंग के भीतर भी अलग किया जा सकता है। उदाहरण के लिए, ऊपर दिए गए दो तारों के बीच सबसे लंबे समय तक मिलान (चरित्र पृथक्करण सहित) "ABCFCBA" है जो कि एक palindrome भी है :) यहाँ LCS समस्या का वर्णन करने वाला एक लिंक है: ics.uci.edu/~eppstein/161/960229.html
— जेक ड्रू
5

जहां तक ​​मैंने समस्या को समझा है, हम केंद्र के चारों ओर palindromes पा सकते हैं और अपनी खोज को केंद्र के दाईं और बाईं ओर दोनों तरह से फैला सकते हैं। यह देखते हुए कि इनपुट के कोनों पर कोई तालमेल नहीं है, हम सीमाओं को 1 और लंबाई -1 पर सेट कर सकते हैं। स्ट्रिंग की न्यूनतम और अधिकतम सीमाओं पर ध्यान देते हुए, हम यह सत्यापित करते हैं कि जब तक हम अपने अधिकतम ऊपरी सीमा केंद्र तक नहीं पहुंचते, तब तक प्रत्येक केंद्रीय स्थिति के लिए सममित अनुक्रमित (दाएं और बाएं) के पदों पर वर्ण समान हैं।

बाहरी लूप O (n) (अधिकतम n-2 पुनरावृत्तियों) है, और आंतरिक लूप O (n) (अधिकतम चारों ओर (n / 2) - 1 पुनरावृत्तियों)

यहां अन्य उपयोगकर्ताओं द्वारा दिए गए उदाहरण का उपयोग करके मेरा जावा कार्यान्वयन है।

class LongestPalindrome {

    /**
     * @param input is a String input
     * @return The longest palindrome found in the given input.
     */
    public static String getLongestPalindrome(final String input) {
        int rightIndex = 0, leftIndex = 0;
        String currentPalindrome = "", longestPalindrome = "";
        for (int centerIndex = 1; centerIndex < input.length() - 1; centerIndex++) {
            leftIndex = centerIndex - 1;  rightIndex = centerIndex + 1;
            while (leftIndex >= 0 && rightIndex < input.length()) {
                if (input.charAt(leftIndex) != input.charAt(rightIndex)) {
                    break;
                }
                currentPalindrome = input.substring(leftIndex, rightIndex + 1);
                longestPalindrome = currentPalindrome.length() > longestPalindrome.length() ? currentPalindrome : longestPalindrome;
                leftIndex--;  rightIndex++;
            }
        }
        return longestPalindrome;
    }

    public static void main(String ... args) {
        String str = "HYTBCABADEFGHABCDEDCBAGHTFYW12345678987654321ZWETYGDE";
        String longestPali = getLongestPalindrome(str);
        System.out.println("String: " + str);
        System.out.println("Longest Palindrome: " + longestPali);
    }
}

इसका आउटपुट निम्न है:

marcello:datastructures marcello$ javac LongestPalindrome
marcello:datastructures marcello$ java LongestPalindrome
String: HYTBCABADEFGHABCDEDCBAGHTFYW12345678987654321ZWETYGDE
Longest Palindrome: 12345678987654321
— Marcello de Sales
स्रोत
6
अगर मैं "HYTBCABADEFGHABCDEDCBAGHTFYW1234567887654321ZWETYGDE" देता हूं, तो यह काम नहीं करता है, लेकिन एवरेज 1234567887654321
— Elvan
1
@j_random_hacker नहीं, यह द्विघात समाधानों में से एक है। इसे यहाँ कवर किया गया है expandAroundCenter।
— v.oddou
@ v.oddou: आप बिल्कुल सही कह रहे हैं, और मुझे नहीं पता कि मैंने ओ (एन ^ 3) का निष्कर्ष कैसे दिया कि केवल 2 नेस्टेड लूप हैं! मैं उस गलत टिप्पणी को हटा दूंगा ... लेकिन मैंने यह भी देखा है कि इस समाधान में एक समस्या है, जिसे मैं एक अलग टिप्पणी में रखूंगा ताकि लेखक को उम्मीद हो।
— j_random_hacker
O (n ^ 3) समय जटिलता का मेरा पहले का दावा गलत था (इसे इंगित करने के लिए धन्यवाद @ v.oddou!), लेकिन एक और समस्या है: यह कोड समान-लंबाई वाले palindromes पर विचार नहीं करता है। यह एक दूसरे, बहुत समान बाहरी लूप (भी O (n ^ 2) को जोड़कर तय किया जा सकता है, इसलिए यह O (n ^ 2) समय की जटिलता को प्रभावित नहीं करता है जो प्रत्येक के बीच n-1 पदों में से प्रत्येक के चारों ओर palindromes का विस्तार करता है। पात्रों की जोड़ी। +2 अगर आप ठीक करते हैं :)
— j_random_hacker
2

रेगेक्स और रूबी के साथ आप इस तरह के छोटे पैलिंड्रोम के लिए स्कैन कर सकते हैं:

PROMPT> irb
>> s = "longtextwithranynarpalindrome"
=> "longtextwithranynarpalindrome"
>> s =~ /((\w)(\w)(\w)(\w)(\w)\6\5\4\3\2)/; p $1
nil
=> nil
>> s =~ /((\w)(\w)(\w)(\w)\w\5\4\3\2)/; p $1
nil
=> nil
>> s =~ /((\w)(\w)(\w)(\w)\5\4\3\2)/; p $1
nil
=> nil
>> s =~ /((\w)(\w)(\w)\w\4\3\2)/; p $1
"ranynar"
=> nil
— neoneye
स्रोत
2

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

/**
 *
 * @author sanhn
 */
public class CheckPalindrome {

    private static String max_string = "";

    public static void checkSubString(String s){
        System.out.println("Got string is "+s);
        for(int i=1;i<=s.length();i++){
            StringBuilder s1 = new StringBuilder(s.substring(0,i));
            StringBuilder s2 = new StringBuilder(s.substring(0,i));
            s2.reverse();
            if(s1.toString().equals(s2.toString())){
                if(max_string.length()<=s1.length()){
                    max_string = s1.toString();
                    System.out.println("tmp max is "+max_string);
                }

            }
        }
    }

    public static void main(String[] args){
        String s="HYTBCABADEFGHABCDEDCBAGHTFYW1234567887654321ZWETYGDE";

        for(int i=0; i<s.length(); i++)
            checkSubString(s.substring(i, s.length()));

        System.out.println("Max string is "+max_string);
    }
}
— Cleonjoys
स्रोत
1

मुझसे हाल ही में यह सवाल पूछा गया था। यहाँ समाधान मैं [अंततः] के साथ आया हूँ। मैंने इसे जावास्क्रिप्ट में किया क्योंकि यह उस भाषा में बहुत सीधा है।

मूल अवधारणा यह है कि आप सबसे छोटे बहु-चरित्र वाले पैलिंड्रोम की तलाश में स्ट्रिंग पर चलते हैं (या तो एक दो या तीन चरित्र एक)। एक बार जब आप ऐसा कर लेते हैं, तो दोनों तरफ की सीमाओं का विस्तार करें जब तक कि यह एक palindrome होना बंद न हो जाए। यदि वह लंबाई वर्तमान सबसे लंबी अवधि से अधिक है, तो इसे स्टोर करें और साथ चलें।

// This does the expanding bit.
function getsize(s, start, end) {
    var count = 0, i, j;
    for (i = start, j = end; i >= 0 && j < s.length; i--, j++) {
        if (s[i] !== s[j]) {
            return count;
        }
        count = j - i + 1; // keeps track of how big the palindrome is
    }
    return count;
}

function getBiggestPalindrome(s) {
    // test for simple cases
    if (s === null || s === '') { return 0; }
    if (s.length === 1) { return 1; }
    var longest = 1;
    for (var i = 0; i < s.length - 1; i++) {
        var c = s[i]; // the current letter
        var l; // length of the palindrome
        if (s[i] === s[i+1]) { // this is a 2 letter palindrome
            l = getsize(s, i, i+1);
        }
        if (i+2 < s.length && s[i] === s[i+2]) { // 3 letter palindrome
            l = getsize(s, i+1, i+1);
        }
        if (l > longest) { longest = l; }
    }
    return longest;
}

यह निश्चित रूप से साफ किया जा सकता है और थोड़ा और अनुकूलित किया जा सकता है, लेकिन इसमें सभी में सबसे अच्छा मामला है लेकिन सबसे खराब स्थिति (एक ही अक्षर का एक स्ट्रिंग) होना चाहिए।

— swilliams
स्रोत
1
मैंने मूल रूप से सोचा था कि ओपी का एल्गो # 1 ओ (एन ^ 2) का समय था, लेकिन यह वास्तव में बोनहेडली ओ (एन ^ 3) है, इसलिए भले ही आपका एल्गोरिथ्म इसे प्राप्त करने योग्य ओ (एन) से बाध्य न हो। यह अभी भी एक सुधार है।
— j_random_hacker
1
आप इसे "सीधा" कहते हैं, लेकिन यह पूर्ण i j l s ifऔर राज्य रखरखाव से भरा है । मल्टी रिटर्न पॉइंट, एज केस ...
— v.oddou
1

नमस्ते यहाँ स्ट्रिंग में सबसे लंबे ताल का पता लगाने के लिए मेरा कोड है। एल्गोरिथ्म को समझने के लिए कृपया निम्न लिंक को देखें http://stevekrenzel.com/articles/longest-palnidrome

उपयोग किया गया परीक्षण डेटा HYTBCABADEFGHABCDEDCBAGHTFYW12345678987654321ZWETYGDE है

 //Function GetPalindromeString

public static string GetPalindromeString(string theInputString)
 { 

        int j = 0;
        int k = 0;
        string aPalindrome = string.Empty;
        string aLongestPalindrome = string.Empty ;          
        for (int i = 1; i < theInputString.Length; i++)
        {
            k = i + 1;
            j = i - 1;
            while (j >= 0 && k < theInputString.Length)
            {
                if (theInputString[j] != theInputString[k])
                {
                    break;
                }
                else
                {
                    j--;
                    k++;
                }
                aPalindrome = theInputString.Substring(j + 1, k - j - 1);
                if (aPalindrome.Length > aLongestPalindrome.Length)
                {
                    aLongestPalindrome = aPalindrome;
                }
            }
        }
        return aLongestPalindrome;     
  }
— मोहित भंडारी
स्रोत
मुझे यकीन नहीं है कि अगर यह लंबाई के साथ भी काम करता है ... तो क्या आप पुष्टि कर सकते हैं?
— st0le
यह भी आप के लिए काम कर सकते हैं palindromes के लिए काम करता है और मुझे पता है कि अगर आप के लिए काम नहीं कर रहा है। एल्गोरिथ्म की समझ के लिए कृपया निम्न लिंक के लिए देखें stevekrenzel.com/articles/longest-palnidrome
— मोहित भंडारी
@ st0le: यह तर्क भी palindromes के लिए काम नहीं करेगा, लेकिन यह भी palindromes के लिए समायोजित किया जा सकता है। मुझे पहले वाले के लिए खेद है। मुझे तर्क मिल गया और मैं इसे कुछ दिनों में अपडेट करूँगा जैसे कि और जब मुझे एक समय मिलता है।
— मोहित भंडारी
अपनी पिछली टिप्पणी आज तक कभी नहीं पढ़ी ... आपने मुझे आखिरी बार संबोधित नहीं किया .... अपना समय ले लो, यह सिर्फ एक अवलोकन था।
— स्टाल
2
मैंने मूल रूप से सोचा था कि ओपी का एल्गो # 1 ओ (एन ^ 2) का समय था, लेकिन यह वास्तव में बोनहेडली ओ (एन ^ 3) है, इसलिए भले ही आपका एल्गोरिथ्म इसे प्राप्त करने योग्य ओ (एन) से बाध्य न हो। यह अभी भी एक सुधार है।
— j_random_hacker
1

इस विषय पर विकिपीडिया लेख देखें । नीचे दिए गए लेख से रैखिक हे (एन) समाधान के लिए नमूना मनेर के एल्गोरिथ्म जावा कार्यान्वयन:

आयात java.util.Arrays; सार्वजनिक वर्ग ManachersAlgorithm {सार्वजनिक स्थैतिक स्ट्रिंग FindLongestPalindrome (स्ट्रिंग s) {यदि (s == null || s.length () == 0) वापसी ""?

char[] s2 = addBoundaries(s.toCharArray());
int[] p = new int[s2.length]; 
int c = 0, r = 0; // Here the first element in s2 has been processed.
int m = 0, n = 0; // The walking indices to compare if two elements are the same
for (int i = 1; i<s2.length; i++) {
  if (i>r) {
    p[i] = 0; m = i-1; n = i+1;
  } else {
    int i2 = c*2-i;
    if (p[i2]<(r-i)) {
      p[i] = p[i2];
      m = -1; // This signals bypassing the while loop below. 
    } else {
      p[i] = r-i;
      n = r+1; m = i*2-n;
    }
  }
  while (m>=0 && n<s2.length && s2[m]==s2[n]) {
    p[i]++; m--; n++;
  }
  if ((i+p[i])>r) {
    c = i; r = i+p[i];
  }
}
int len = 0; c = 0;
for (int i = 1; i<s2.length; i++) {
  if (len<p[i]) {
    len = p[i]; c = i;
  }
}
char[] ss = Arrays.copyOfRange(s2, c-len, c+len+1);
return String.valueOf(removeBoundaries(ss));   }
private static char[] addBoundaries(char[] cs) {
if (cs==null || cs.length==0)
  return "||".toCharArray();

char[] cs2 = new char[cs.length*2+1];
for (int i = 0; i<(cs2.length-1); i = i+2) {
  cs2[i] = '|';
  cs2[i+1] = cs[i/2];
}
cs2[cs2.length-1] = '|';
return cs2;   }
private static char[] removeBoundaries(char[] cs) {
if (cs==null || cs.length<3)
  return "".toCharArray();

char[] cs2 = new char[(cs.length-1)/2];
for (int i = 0; i<cs2.length; i++) {
  cs2[i] = cs[i*2+1];
}
return cs2;   }     }
— Datageek
स्रोत
1

एक कुशल Regexpसमाधान जो क्रूर बल से बचा जाता है

पूरे स्ट्रिंग की लंबाई के साथ शुरू होता है और 2 वर्णों तक नीचे की ओर काम करता है, जैसे ही एक मैच होता है, मौजूद होता है

के लिए "abaccddccefe"regexp लौटने से पहले 7 मैचों का परीक्षण करती है ccddcc।

((।) (।) (।) (।) (।) (\ 6) (\ 5) (\ 4) (\ 4) (\ 3) (\ 2) (\ 1)
(+ 1) (।) (?)। ) (?) (।) (।) (\ 5) (\ 4) (\ 3) (\ 2) (\ 1)
( 1 ) (।) (।) (।) (।) (\) 5 ()। \ 4) (\ 3) (\ 2) (\ 1)
(।) (।) (।) (।) (\ 4) (\ 3) (\ 2) (\ 1)
( \) ()। ।) (।) (?) (\ 4) (\ 3) (\ 2) (\ 1)
(।) (?) (?) () () (3) (\ 2) (\ 1)
(। ) । ) (।) (।) (\ 3) (\ 2) (\ 1)

vbs

Dim strTest
wscript.echo Palindrome("abaccddccefe")

VBA

Sub Test()
Dim strTest
MsgBox Palindrome("abaccddccefe")
End Sub

समारोह 

Function Palindrome(strIn)

Set objRegex = CreateObject("vbscript.regexp")

For lngCnt1 = Len(strIn) To 2 Step -1
    lngCnt = lngCnt1 \ 2
    strPal = vbNullString

    For lngCnt2 = lngCnt To 1 Step -1
        strPal = strPal & "(\" & lngCnt2 & ")"
    Next

    If lngCnt1 Mod 2 = 1 Then strPal = "(.)" & strPal

    With objRegex
        .Pattern = Replace(Space(lngCnt), Chr(32), "(.)") & strPal
        If .Test(strIn) Then
            Palindrome = .Execute(strIn)(0)
            Exit For
        End If
    End With
Next

End Function
— brettdj
स्रोत
@DickKusleika क्या आप ऊपर संशोधित कोड के साथ dailydoseofexcel.com/archives/2016/01/14/… पर मेरी टिप्पणी को अपडेट कर सकते हैं । Thx
— brettdj
1 
public static void main(String[] args) {
         System.out.println(longestPalindromeString("9912333321456")); 
}

    static public String intermediatePalindrome(String s, int left, int right) {
        if (left > right) return null;
        while (left >= 0 && right < s.length()
                && s.charAt(left) == s.charAt(right)) {
            left--;
            right++;
        }
        return s.substring(left + 1, right);
    }


    public static String longestPalindromeString(String s) {
        if (s == null) return null;
        String longest = s.substring(0, 1);
        for (int i = 0; i < s.length() - 1; i++) {
            //odd cases like 121
            String palindrome = intermediatePalindrome(s, i, i);
            if (palindrome.length() > longest.length()) {
                longest = palindrome;
            }
            //even cases like 1221
            palindrome = intermediatePalindrome(s, i, i + 1);
            if (palindrome.length() > longest.length()) {
                longest = palindrome;
            }
        }
        return longest;
    }
— सुशील मित्तल
स्रोत
0

स्ट्रिंग का प्रयास करें - "HYTBCABADEFGHABCDEDCBAGHTFYW123456789987654321ZWETYGDE"; यह सम और विषम पल्स के लिए काम करना चाहिए। मोहित को बहुत बहुत धन्यवाद!

नेमस्पेस एसटीडी का उपयोग करना;

string largestPal(string input_str)
{
  string isPal = "";
  string largest = "";
  int j, k;
  for(int i = 0; i < input_str.length() - 1; ++i)
    {
      k = i + 1;
      j = i - 1;

      // starting a new interation                                                      
      // check to see if even pal                                                       
      if(j >= 0 && k < input_str.length()) {
        if(input_str[i] == input_str[j])
          j--;
        else if(input_str[i] == input_str[j]) {
          k++;
        }
      }
      while(j >= 0 && k < input_str.length())
        {
          if(input_str[j] != input_str[k])
            break;
          else
            {
              j--;
              k++;
            }
          isPal = input_str.substr(j + 1, k - j - 1);
            if(isPal.length() > largest.length()) {
              largest = isPal;
            }
        }
    }
  return largest;
}
— रॉबर्ट ग्रीस्मेयर
स्रोत
2
यह लगभग O (n ^ 2) समय में काम करता है। क्यों निर्माण isPal- एक ओ (एन) ऑपरेशन - केवल इसकी लंबाई को मापने के लिए !? इसके अलावा यह एक छोटी गाड़ी भी palindromes से निपटने का प्रयास किया है। यहां तक ​​कि-पैलिंड्रोम बगिंग पर: else if(input_str[i] == input_str[j])कभी सफल नहीं हो सकता क्योंकि वही परीक्षण पिछले ifकथन में विफल रहा होगा ; और यह गाड़ी वैसे भी है, क्योंकि आपको बता नहीं सकता सिर्फ 2 पात्रों को देखकर 2 पदों स्थान दिया गया है के अलावा है कि क्या आप एक और भी विलोमपद या एक अजीब एक (पर विचार पर देख रहे हैं AAAऔर AAAA)।
— j_random_hacker
0

निम्नलिखित कोड भी लंबाई और विषम लंबाई के तार के लिए Palidrom की गणना करता है।

सबसे अच्छा समाधान नहीं है लेकिन दोनों मामलों के लिए काम करता है

HYTBCABADEFGHABCDEDCBAGHTFYW12345678987654321ZWETYGDE HYTBCABADEFGHABCDEDCBAGHTFYW12345678876565321WWYYDE

private static String getLongestPalindrome(String string) {
    String odd = getLongestPalindromeOdd(string);
    String even = getLongestPalindromeEven(string);
    return (odd.length() > even.length() ? odd : even);
}

public static String getLongestPalindromeOdd(final String input) {
    int rightIndex = 0, leftIndex = 0;
    String currentPalindrome = "", longestPalindrome = "";
    for (int centerIndex = 1; centerIndex < input.length() - 1; centerIndex++) {
        leftIndex = centerIndex;
        rightIndex = centerIndex + 1;
        while (leftIndex >= 0 && rightIndex < input.length()) {
            if (input.charAt(leftIndex) != input.charAt(rightIndex)) {
                break;
            }
            currentPalindrome = input.substring(leftIndex, rightIndex + 1);
            longestPalindrome = currentPalindrome.length() > longestPalindrome
                    .length() ? currentPalindrome : longestPalindrome;
            leftIndex--;
            rightIndex++;
        }
    }
    return longestPalindrome;
}

public static String getLongestPalindromeEven(final String input) {
    int rightIndex = 0, leftIndex = 0;
    String currentPalindrome = "", longestPalindrome = "";
    for (int centerIndex = 1; centerIndex < input.length() - 1; centerIndex++) {
        leftIndex = centerIndex - 1;
        rightIndex = centerIndex + 1;
        while (leftIndex >= 0 && rightIndex < input.length()) {
            if (input.charAt(leftIndex) != input.charAt(rightIndex)) {
                break;
            }
            currentPalindrome = input.substring(leftIndex, rightIndex + 1);
            longestPalindrome = currentPalindrome.length() > longestPalindrome
                    .length() ? currentPalindrome : longestPalindrome;
            leftIndex--;
            rightIndex++;
        }
    }
    return longestPalindrome;
}
— अभिजीत गायकवाड़
स्रोत
0
  1. एक विभाजक का उपयोग करके प्रत्येक वर्ण को अलग करने के लिए स्ट्रिंग को संशोधित करें [यह अजीब और यहां तक ​​कि palindromes को शामिल करना है]
  2. एक केंद्र के रूप में व्यवहार करने वाले प्रत्येक चरित्र के चारों ओर palindromes का पता लगाएं

हम इसका उपयोग करके सभी लंबाई के सभी पलिंड्रोम्स पा सकते हैं।

नमूना:

शब्द = abcdcbc

संशोधितस्ट्रिंग = एक # बी # सी # डी # सी # बी # सी

palinCount = 1010105010301

सबसे लंबे ताल की लंबाई = 5;

सबसे लंबा ताल = bcdcb

सार्वजनिक वर्ग MyLongestPalindrome {

static String word;
static int wordlength;
static int highestcount = 0;
static int newlength;
static char[] modifiedString; // stores modified string
static int[] palinCount; // stores palindrome length at each position
static char pound = '#';

public static void main(String[] args) throws IOException {
    // TODO Auto-generated method stub
    System.out.println("Enter String : ");
    InputStreamReader isr = new InputStreamReader(System.in);
    BufferedReader bfr = new BufferedReader(isr);
    word = bfr.readLine();
    wordlength = word.length();
    newlength = (wordlength * 2) - 1;
    convert();
    findpalindrome();
    display();
}

// Inserting # in string
public static void convert() {

    modifiedString = new char[newlength];
    int j = 0;
    int i;
    for (i = 0; i < wordlength - 1; i++) {
        modifiedString[j++] = word.charAt(i);
        modifiedString[j++] = pound;
    }
    modifiedString[j] = word.charAt(i);
}

// display all palindromes of highest length
public static void display() {
    String palindrome;
    String s = new String(modifiedString);
    System.out.println("Length of longest palindrome = " + highestcount);
    for (int i = 0; i < newlength; i++) {
        if (palinCount[i] == highestcount) {
            palindrome = s.substring(i - (highestcount - 1), i
                    + (highestcount));
            i = i + (highestcount - 1);
            palindrome = palindrome.replace("#", "");
            System.out.println(palindrome);
        }
    }
}

// populate palinCount with length of palindrome string at each position
public static void findpalindrome() {
    int left, right, count;
    palinCount = new int[newlength];
    palinCount[0] = 1;
    palinCount[newlength - 1] = 1;
    for (int i = 1; i < newlength - 1; i++) {
        count = 0;
        left = i - 1;
        right = i + 1;
        ;
        if (modifiedString[i] != pound)
            count++;
        while (left >= 0 && right < newlength) {
            if (modifiedString[left] == modifiedString[right]) {
                if (modifiedString[left] != pound)
                    count = count + 2;
                left--;
                right++;
            } else
                break;
        }

        palinCount[i] = count;
        highestcount = count > highestcount ? count : highestcount;

    }

}

}

— NNC
स्रोत
0

यह दिए गए स्ट्रिंग से सबसे लंबे पैलिंड्रोम स्ट्रिंग लौटाएगा

-(BOOL)isPalindromString:(NSString *)strInput
{
    if(strInput.length<=1){
        return NO;
    }
    int halfLenth = (int)strInput.length/2;

    BOOL isPalindrom = YES;
    for(NSInteger i=0; i<halfLenth; i++){

        char a = [strInput characterAtIndex:i];
        char b = [strInput characterAtIndex:(strInput.length-1)-i];

        if(a != b){
            isPalindrom = NO;
            break;
        }
    }
    NSLog(@"-%@- IS Plaindrom %@",strInput,(isPalindrom ? @"YES" : @"NO"));
    return isPalindrom;
}


-(NSString *)longestPalindrom:(NSString *)strInput
{
    if(strInput.length<=1){
        return @"";
    }

    NSString *strMaxPalindrom = @"";

    for(int i = 0; i<strInput.length ; i++){

        for(int j = i; j<strInput.length ; j++){

            NSString *strSub = [strInput substringWithRange:NSMakeRange(i, strInput.length-j)];

            if([self isPalindromString:strSub]){

                if(strSub.length>strMaxPalindrom.length){

                    strMaxPalindrom = strSub;
                }
            }
        }
    }
    NSLog(@"-Max - %@",strMaxPalindrom);
    return strMaxPalindrom;
}

-(void)test
{
    [self longestPalindrom:@"abcccbadeed"];
}

== OUTPUT ===

इनपुट: abcccde आउटपुट: ccc

इनपुट: abcccbd आउटपुट: bcccb

इनपुट: abedccde आउटपुट: edccde

इनपुट: abcccdeed आउटपुट: डीड

इनपुट: abcccbadeed आउटपुट: abcccba

— किरण पटेल
स्रोत
0

यहाँ जावास्क्रिप्ट में एक कार्यान्वयन है:

var longestPalindromeLength = 0;
var longestPalindrome = ''

function isThisAPalidrome(word){
  var reverse = word.split('').reverse().join('')
  return word == reverse
}

function findTheLongest(word){ // takes a word of your choice
  for(var i = 0; i < word.length; i++){ // iterates over each character
    var wordMinusOneFromBeginning = word.substr(i, word.length) // for each letter, create the word minus the first char
    for(var j = wordMinusOneFromBeginning.length; j > 0; j--){ // for the length of the word minus the first char
      var wordMinusOneFromEnding = wordMinusOneFromBeginning.substr(0, j) // create a word minus the end character
      if(wordMinusOneFromEnding <= 0) // make sure the value is more that 0,
      continue // if more than zero, proced to next if statement
      if(isThisAPalidrome(wordMinusOneFromEnding)){ // check if the word minus the first character, minus the last character = a plaindorme
        if(wordMinusOneFromEnding.length > longestPalindromeLength){ // if it is
          longestPalindromeLength = wordMinusOneFromEnding.length; // save its length
          longestPalindrome = wordMinusOneFromEnding // and save the string itself
        } // exit the statement that updates the longest palidrome
      } // exit the stament that checks for a palidrome
    } // exit the loop that goes backwards and takes a letter off the ending
  } // exit the loop that goes forward and takes off the beginning letter
  return console.log('heres the longest string: ' + longestPalindrome
  + ' its ' + longestPalindromeLength + ' charachters in length'); // return the longest palidrome! :)
}
findTheLongest('bananas');
स्निपेट का विस्तार करें

— एलेक्स बेनेट
स्रोत
पता नहीं क्यों इस पर मतदान किया गया था - एक आकर्षण की तरह काम करता है। मुझे CA प्रौद्योगिकियों के साथ एक साक्षात्कार के माध्यम से मिला।
— एलेक्स बेनेट
0

रैखिक समाधान के लिए, आप मनचेर के एल्गोरिथ्म का उपयोग कर सकते हैं। Gusfield के एल्गोरिथ्म में एक और एल्गोरिथ्म कॉल है, और नीचे जावा में कोड है:

public class Solution {  
    char[] temp;   
    public int match(int a, int b,int len){   
        int i = 0;   
        while (a-i>=0 && b+i<len && temp[a-i] == temp[b+i]) i++;   
        return i;   
    }  

    public String longestPalindrome(String s) {  

        //This makes use of the assumption that the string has not more than 1000 characters.  
        temp=new char[1001*2];  
        int[] z=new int[1001 * 2];  
        int L=0, R=0;  
        int len=s.length();  

        for(int i=0;i<len*2+1;i++){  
            temp[i]='.';  
        }  

        for(int i=0;i<len;++i){  
            temp[i*2+1] = s.charAt(i);  
        }  

        z[0]=1;  
        len=len*2+1;  

        for(int i=0;i<len;i++){  
            int ii = L - (i - L);     
            int n = R + 1 - i;  
            if (i > R)  
            {  
                z[i] = match(i, i,len);  
                L = i;  
                R = i + z[i] - 1;  
            }  
            else if (z[ii] == n)  
            {  
                z[i] = n + match(i-n, i+n,len);  
                L = i;  
                R = i + z[i] - 1;  
            }  
            else  
            {  
                z[i] = (z[ii]<= n)? z[ii]:n;  
            }   
        }  

        int n = 0, p = 0;  
        for (int i=0; i<len; ++i)  
            if (z[i] > n)  
                n = z[p = i];  

        StringBuilder result=new StringBuilder();  
        for (int i=p-z[p]+1; i<=p+z[p]-1; ++i)  
            if(temp[i]!='.')  
                result.append(String.valueOf(temp[i]));  

        return result.toString();  
    }  
}

आप अपने स्वयं के ब्लॉग से सर्वश्रेष्ठ O (n ^ 2) समाधान या Manacher के एल्गोरिथ्म जैसे अन्य समाधानों पर अधिक पा सकते हैं ।

— traceformula
स्रोत
0

यहाँ मैंने लिखा है एक तर्क यह कोशिश :) 

public class palindromeClass{

public  static String longestPalindromeString(String in) {
        char[] input = in.toCharArray();
        int longestPalindromeStart = 0;
        int longestPalindromeEnd = 0;

        for (int mid = 0; mid < input.length; mid++) {
            // for odd palindrome case like 14341, 3 will be the mid
            int left = mid-1;
            int right = mid+1;
            // we need to move in the left and right side by 1 place till they reach the end
            while (left >= 0 && right < input.length) {
                // below check to find out if its a palindrome
                if (input[left] == input[right]) {
                    // update global indexes only if this is the longest one till now
                    if (right - left > longestPalindromeEnd
                            - longestPalindromeStart) {
                        longestPalindromeStart = left;
                        longestPalindromeEnd = right;
                    }
                }
                else
                    break;
                left--;
                right++;
            }
            // for even palindrome, we need to have similar logic with mid size 2
            // for that we will start right from one extra place
            left = mid;
            right = mid + 1;// for example 12333321 when we choose 33 as mid
            while (left >= 0 && right < input.length)
            {
                if (input[left] == input[right]) {
                    if (right - left > longestPalindromeEnd
                            - longestPalindromeStart) {
                        longestPalindromeStart = left;
                        longestPalindromeEnd = right;
                    }
                }
                else
                    break;
                left--;
                right++;
            }


        }
        // we have the start and end indexes for longest palindrome now
        return in.substring(longestPalindromeStart, longestPalindromeEnd + 1);
    }
public static void main(String args[]){
System.out.println(longestPalindromeString("HYTBCABADEFGHABCDEDCBAGHTFYW12345678987654321ZWETYGDE"));
}

}
— Coldy
स्रोत
यह स्ट्रिंग में सभी पैलिंड्रोम को न केवल सबसे लंबे समय तक देता है
— विवेक मिश्रा
0

यह समाधान O (n ^ 2) जटिलता का है। O (1) अंतरिक्ष की जटिलता है।

public class longestPalindromeInAString {

        public static void main(String[] args) {
            String a =  "xyMADAMpRACECARwl"; 
            String res = "";
            //String longest = a.substring(0,1);
            //System.out.println("longest => " +longest);
            for (int i = 0; i < a.length(); i++) {
                String temp = helper(a,i,i);//even palindrome
                if(temp.length() > res.length()) {res = temp ;}
                temp = helper(a,i,i+1);// odd length palindrome
                if(temp.length() > res.length()) { res = temp ;}

            }//for
            System.out.println(res);
            System.out.println("length of " + res + " is " + res.length());

        }

        private static String helper(String a, int left, int right) {
            while(left>= 0 && right <= a.length() -1  &&  a.charAt(left) == a.charAt(right)) {
                left-- ;right++ ;
            }
            String curr = a.substring(left + 1 , right);
            System.out.println("curr =>" +curr);
            return curr ;
        }

    }
— सौदिप्ता दत्ता
स्रोत
0 

#longest palindrome
s='HYTBCABADEFGHABCDEDCBAGHTFYW123456789987654321ZWETYGDE'
out1=[]
def substring(x):
    for i in range(len(x)):
        a=x[i:]
        b=x[:-i]
        out1.append(a)
        out1.append(b)
        
    return out1

for i in range(len(s)):
    substring(s[i:])    
final=set([item for item in out1 if len(item)>2])
final
palind={item:len(item) for item in final if item==item[::-1]}
print(palind)
sorted(palind.items(),reverse=True, key=lambda x: x[1])[0]
स्निपेट का विस्तार करें

{[DED ': 3,' 123456789987654321 ': 18,' 67899876 ': 8,' ABCDEDCBA ': 9,' 456789987654 ': 12,' 3676789987654 ': 14,' BCDEDCB ': 7,' ABA ': 3 5678998765 ': 10,' 2345678998765432 ': 16,' सीडीईडीसी ': 5,' 789987 ': 6,' 8998 ': 4} (' 123456789987654321 ', 18)

— आशीष बंसल
स्रोत
-1

यहाँ मेरा एल्गोरिथ्म है:

1) पहला अक्षर होने के लिए वर्तमान केंद्र निर्धारित करें

2) एक साथ बाईं और दाईं ओर का विस्तार करें जब तक कि आप वर्तमान केंद्र के चारों ओर अधिकतम तालमेल नहीं पाते

3) यदि आपको जो तालमेल दिखता है, वह पिछले तालमेल से बड़ा है, तो उसे अपडेट करें

4) वर्तमान केंद्र को अगले अक्षर के रूप में सेट करें

5) स्ट्रिंग में सभी अक्षरों के लिए चरण 2) से 4 तक दोहराएं

यह O (n) में चलता है।

आशा करता हूँ की ये काम करेगा।

— मकड़ी
स्रोत
5
स्ट्रिंग "आसा" पर विचार करें। यह आपके एल्गोरिथ्म का उपयोग करते हुए O (n ^ 2) में चलता है।
— paislee
1
मैंने मूल रूप से सोचा था कि ओपी का एल्गो # 1 ओ (एन ^ 2) का समय था, लेकिन यह वास्तव में बोनहेडली ओ (एन ^ 3) है, इसलिए भले ही आपका एल्गोरिथ्म इसे प्राप्त करने योग्य ओ (एन) से बाध्य न हो। यह अभी भी एक सुधार है।
— j_random_hacker 7
यह क्लासिक एन 2 विस्तार समाधान है। लेकिन, वास्तव में यह इस वीडियो में बताए गए Manacher के समाधान के करीब है: youtube.com/watch?v=V-sEwsca1ak अंतर है बिंदु 4. Manacher पुन: उपयोग किए जाने वाले पत्रों से बचने के लिए सक्षम होने के लिए जानकारी का पुन: उपयोग करें।
— v.oddou
-2

संदर्भ: विकिपीडिया डॉट कॉम

जटिलता ओ (एन) के साथ सबसे अच्छा एल्गोरिथ्म मैंने कभी पाया है

 import java.util.Arrays;

 public class ManachersAlgorithm {

  public static String findLongestPalindrome(String s) {
    if (s==null || s.length()==0)
      return "";

    char[] s2 = addBoundaries(s.toCharArray());
    int[] p = new int[s2.length]; 
    int c = 0, r = 0; // Here the first element in s2 has been processed.
    int m = 0, n = 0; // The walking indices to compare if two elements are the same
    for (int i = 1; i<s2.length; i++) {
      if (i>r) {
        p[i] = 0; m = i-1; n = i+1;
      } else {
        int i2 = c*2-i;
        if (p[i2]<(r-i)) {
          p[i] = p[i2];
          m = -1; // This signals bypassing the while loop below. 
        } else {
          p[i] = r-i;
          n = r+1; m = i*2-n;
        }
      }
      while (m>=0 && n<s2.length && s2[m]==s2[n]) {
        p[i]++; m--; n++;
      }
      if ((i+p[i])>r) {
        c = i; r = i+p[i];
      }
    }
    int len = 0; c = 0;
    for (int i = 1; i<s2.length; i++) {
      if (len<p[i]) {
        len = p[i]; c = i;
      }
    }
    char[] ss = Arrays.copyOfRange(s2, c-len, c+len+1);
    return String.valueOf(removeBoundaries(ss));
  }

  private static char[] addBoundaries(char[] cs) {
    if (cs==null || cs.length==0)
      return "||".toCharArray();

    char[] cs2 = new char[cs.length*2+1];
    for (int i = 0; i<(cs2.length-1); i = i+2) {
      cs2[i] = '|';
      cs2[i+1] = cs[i/2];
    }
    cs2[cs2.length-1] = '|';
    return cs2;
  }

  private static char[] removeBoundaries(char[] cs) {
    if (cs==null || cs.length<3)
      return "".toCharArray();

    char[] cs2 = new char[(cs.length-1)/2];
    for (int i = 0; i<cs2.length; i++) {
      cs2[i] = cs[i*2+1];
    }
    return cs2;
  }    
}
— सज्जाद हिसैन खान
स्रोत
-5

मेरा समाधान है:

static string GetPolyndrom(string str)
{
    string Longest = "";

    for (int i = 0; i < str.Length; i++)
    {
        if ((str.Length - 1 - i) < Longest.Length)
        {
            break;
        }
        for (int j = str.Length - 1; j > i; j--)
        {
            string str2 = str.Substring(i, j - i + 1);
            if (str2.Length > Longest.Length)
            {
                if (str2 == str2.Reverse())
                {
                    Longest = str2;
                }
            }
            else
            {
                break;
            }
        }

    }
    return Longest;
}
— तोमर कीसर
स्रोत
1
यह स्ट्रिंग लंबाई में, और स्ट्रिंग-समानता ( ) संचालन के कारण घन समय लेता है । यह मूल रूप से ओपी के एल्गो # 1 के समान है। Substring()==
— j_random_hacker
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.