একটি ফাংশন লিখুন যা প্রদত্ত স্ট্রিংয়ে দীর্ঘতম প্যালিনড্রোম দেয়

Question

উদাহরণস্বরূপ "abccddccefe" স্ট্রিংয়ের "ccddcc"

আমি একটি সমাধানের কথা ভেবেছিলাম তবে এটি ও (এন ^ 2) সময়ে চলে

আলগো 1:

পদক্ষেপ: এটি একটি নিষ্ঠুর শক্তি পদ্ধতি

1. 
   অ্যারের চেয়ে i = 1 থেকে i কমের জন্য লুপের জন্য 2 রাখুন le
   j = i + 1 থেকে j এর চেয়ে কম অ্যারে. দৈর্ঘ্যের চেয়ে কম
2. এইভাবে আপনি অ্যারে থেকে প্রতিটি সম্ভাব্য সংমিশ্রণের সাবস্ট্রিং পেতে পারেন
3. একটি প্যালিনড্রোম ফাংশন রয়েছে যা পরীক্ষা করে কোনও স্ট্রিং প্যালিনড্রোম কিনা
4. সুতরাং প্রতিটি স্ট্রিংয়ের জন্য (i, j) এই ফাংশনটি কল করুন, যদি এটি কোনও প্যালিনড্রোম হয় তবে স্ট্রিং ভেরিয়েবল এ সঞ্চয় করুন
5. আপনি যদি পরবর্তী প্যালিনড্রোম সাবস্ট্রিং খুঁজে পান এবং এটি বর্তমানের চেয়ে বড় হয় তবে এটি বর্তমানের সাথে প্রতিস্থাপন করুন।
6. শেষ পর্যন্ত আপনার স্ট্রিং ভেরিয়েবলের উত্তর থাকবে

সমস্যাগুলি: 1. এই আলগোটি ও (এন ^ 2) সময়ে চলে।

আলগো 2:

1. স্ট্রিংটি বিপরীত করুন এবং এটিকে ডিফেরেন্ট অ্যারেতে সঞ্চয় করুন
2. এখন উভয় অ্যারের মধ্যে বৃহত্তম মিলের সাবস্ট্রিং সন্ধান করুন
3. তবে এটি ও (এন ^ 2) সময়েও চলে

আপনি কি ছেলেরা এমন একটি আলগো সম্পর্কে ভাবতে পারেন যা আরও ভাল সময়ে চলে? সম্ভব হলে ও (এন) সময়

Comments

আমি মনে করি প্রথমটি O(n^2)সাবস্ট্রিংগুলি * O(n)মোট প্যালিনড্রোম কিনা তা পরীক্ষা করে নেওয়া O(n^3)?

— Skylar Saveland

যদি আমি জানতাম যে আমি প্যালিনড্রোমে কাজ করছি এবং আমার স্ট্রিংগুলিকে দুটি অংশ হিসাবে সংরক্ষণ করি এবং তারপর আমি জাভা ব্যবহার করি তবে আমি ফাংশনটির জন্য ও (1) পরীক্ষা করতাম?

— viki.omega9

সেকং আলগো ঠিক আছে? স্ট্রিং সম্পর্কে কী: "অ্যাবডেকবা"। বৃহত্তম মিলের সাবস্ট্রিং হ'ল ("অ্যাবডেকবা" বনাম "অ্যাবসেডকাবা"): "অ্যাবসি" বা "সিবিএ"। তবে দুটিই প্যালিনড্রোম নয়।

— ইয়ার্নিও

@ শিখুন, কেবল কৌতূহলী, আপনি কীসের জন্য উপরে পদক্ষেপে লুপগুলির জন্য রেফারির করছেন? অ্যারে দ্বারা আপনি স্ট্রিং উল্লেখ করছেন? string.length?

— জোল্ট

ও (এন ^ 2) এর সাথে উত্তরগুলির সন্ধানের জন্য

— Shirish Herwade

Answer 1

সবচেয়ে লম্বা যে শব্দ কবিতা প্রভৃতি উলটা করিয়া পড়িলেও একই থাকে ব্যবহার জানতে পারেন Manacher এর অ্যালগরিদম মধ্যে O(n)সময়! এর বাস্তবায়ন এখানে এবং এখানে পাওয়া যাবে ।

ইনপুট জন্য String s = "HYTBCABADEFGHABCDEDCBAGHTFYW1234567887654321ZWETYGDE"এটি সঠিক ফলাফল খুঁজে বের করে যা 1234567887654321।

Comments

আমি বুঝতে পারি না কিভাবে এটি রৈখিক হয়। আমি একটি দেখতে whileএমবেড forএকটি সীমান্ত বাইরের লুপ অনুরূপ বলে মনে হয় না।

— v.oddou

যখন কেউ স্ট্যাক ওভারফ্লোতে যায়, "উত্তর" প্রশ্নের আসলে একটি উত্তর থাকা উচিত। উত্তরের দিকে কেবল একগুচ্ছ দিক নয়। ।

— এরিক ফিলিপস

Answer 2

অ্যালগো 2 সমস্ত স্ট্রিংয়ের জন্য কাজ না করে। এই জাতীয় স্ট্রিংয়ের একটি উদাহরণ "এবিসিডিডিএফসিএবিএ"।

স্ট্রিংটির স্ট্রিং হিসাবে "এবিসি" এবং "সিবিএ" রয়েছে তা নয়। আপনি যদি মূল স্ট্রিংটি বিপরীত করেন তবে এটি হবে "ABCFEDCBA"। এবং দীর্ঘতম মিলের সাবস্ট্রিং হ'ল "এবিসি" যা কোনও প্যালিনড্রোম নয়।

আপনার দীর্ঘস্থায়ী মিলের সাবস্ট্রিংটি আসলে প্যালিনড্রোম যা হে (এন ^ 3) চলমান সময় রয়েছে কিনা তা আপনাকে অতিরিক্তভাবে পরীক্ষা করতে হবে।

Comments

এটি লক্ষণীয় গুরুত্বপূর্ণ যে অ্যালগো 2 "দীর্ঘতম মিলনকারী প্যাকালিন্ডোম" এর জন্য কাজ করা উচিত যা একটি সাধারণ অ্যালগরিদম সমস্যা যেখানে পরের অক্ষরগুলিও স্ট্রিংয়ের মধ্যে পৃথক করা যায়। উদাহরণস্বরূপ, উপরের দুটি স্ট্রিংয়ের মধ্যে দীর্ঘতম ম্যাচিং সাবকোয়েন্স (অক্ষর পৃথকীকরণ সহ) হ'ল "এবিসিএফসিএবিএ" এটিও একটি প্যালিনড্রোম :) এখানে এলসিএস সমস্যা বর্ণনা করার জন্য একটি লিঙ্ক: ics.uci.edu/~eppstein/161/960229.html

— জেক ড্র

Answer 3

যতদূর আমি সমস্যাটি বুঝতে পেরেছি, আমরা কেন্দ্র সূচকের চারপাশে প্যালিনড্রোমগুলি খুঁজে পেতে পারি এবং কেন্দ্রের ডান এবং বামে উভয় উপায়ে আমাদের সন্ধান করতে পারি। এটি দেওয়া এবং ইনপুটটির কোনায় কোনও প্যালিনড্রোম নেই তা জেনে আমরা সীমানা 1 এবং দৈর্ঘ্য -1 এ সেট করতে পারি। স্ট্রিংয়ের ন্যূনতম এবং সর্বাধিক সীমানার দিকে মনোযোগ দেওয়ার সময় আমরা আমাদের সর্বোচ্চ উচ্চতর আবদ্ধ কেন্দ্রে পৌঁছানো পর্যন্ত প্রতিটি কেন্দ্রীয় অবস্থানের জন্য প্রতিসম সূচকগুলির (ডান এবং বাম) অবস্থানগুলি একই কিনা তা যাচাই করি।

বাইরের লুপটি হ'ল (এন) (সর্বাধিক এন -2 পুনরাবৃত্তি), এবং অভ্যন্তরীণ লুপটি ও (এন) (সর্বাধিক (এন / 2) - 1 পুনরাবৃত্তি)

এখানে অন্যান্য ব্যবহারকারীর দ্বারা প্রদত্ত উদাহরণ ব্যবহার করে আমার জাভা বাস্তবায়ন's

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

Comments

আমি যদি "HYTBCediaEFGHABCDEDCBAGHTFYW1234567887654321ZWETYGDE" দিই তবে এটি কাজ করে না তবে এ্যাওয়ার 1234567887654321 হওয়া উচিত

— এলবেক

@ j_random_hacker না, এটি চতুর্ভুজ সমাধানগুলির একটি। এটি এখানে হিসাবে আচ্ছাদিত expandAroundCenter।

— v.oddou

@ ভি.ডডু: আপনি একেবারে ঠিক বলেছেন এবং আমি জানি না কীভাবে আমি ও (এন! 3) উপসংহারে পৌঁছেছি যে সেখানে মাত্র ২ টি নেস্ট লুপ রয়েছে! আমি সেই ভুল মন্তব্যটি মুছে ফেলব ... তবে আমি এটিও লক্ষ্য করেছি যে এই সমাধানটির একটি সমস্যা রয়েছে, যা আমি একটি পৃথক মন্তব্য করব যাতে লেখক আশা করে লক্ষ্য করবেন।

— j_random_hacker

আমার ও (n ^ 3) সময়ের জটিলতার দাবিটি ভুল ছিল (এটি নির্দেশ করার জন্য ধন্যবাদ @ v.oddou!) তবে আরও একটি সমস্যা আছে: এই কোডটি সম -দৈর্ঘ্যের প্যালিনড্রোমগুলি বিবেচনা করে না। এটি দ্বিতীয়, খুব অনুরূপ বাহ্যিক লুপ যুক্ত করেও স্থির করা যেতে পারে (এছাড়াও ও (এন ^ 2) তাই এটি ও (এন ^ 2) সময়ের জটিলতাকে প্রভাবিত করে না) যা প্রতিটি এন -1 পজিশনের মধ্যে প্রতিটি প্যালিনড্রোমগুলি প্রসারিত করে অক্ষর জোড়া। +2 যদি আপনি ঠিক করেন :)

— j_random_hacker

Answer 4

রেজেক্স এবং রুবীর সাহায্যে আপনি এই জাতীয় শর্ট প্যালিনড্রোমগুলির জন্য স্ক্যান করতে পারেন:

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

Answer 5

আমি নীচের জাভা প্রোগ্রামটি কৌতূহল, সহজ এবং স্ব-ব্যাখ্যামূলক এইচটিএইচের বাইরে লিখেছি। ধন্যবাদ।

/**
 *
 * @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);
    }
}

Answer 6

আমাকে সম্প্রতি এই প্রশ্ন জিজ্ঞাসা করা হয়েছিল। সমাধানটি আমি [অবশেষে] সামনে এলাম। আমি এটি জাভাস্ক্রিপ্টে করেছি কারণ এটি ভাষায় বেশ সোজা।

মৌলিক ধারণাটি হ'ল আপনি স্ট্রিংটি ছোট ছোট মাল্টি-ক্যারেক্টার প্যালিনড্রোমে সম্ভাব্য (দুটি বা তিনটি চরিত্রের একটির জন্য) সন্ধান করছেন walk একবার এটি হয়ে গেলে, উভয় দিকে সীমাগুলি প্রসারিত করুন যতক্ষণ না এটি প্যালিনড্রোম হওয়া বন্ধ করে দেয়। যদি সেই দৈর্ঘ্য বর্তমানের দীর্ঘতমের চেয়ে দীর্ঘ হয় তবে এটি সঞ্চয় করুন এবং পাশাপাশি চলে যান।

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

এটি অবশ্যই পরিষ্কার হয়ে যেতে পারে এবং আরও কিছুটা অনুকূলিত করা যেতে পারে তবে এটির মধ্যে সবচেয়ে খারাপ পারফরম্যান্স হওয়া উচিত খারাপ পরিস্থিতি (একই বর্ণের একটি স্ট্রিং) ব্যতীত।

Comments

আমি প্রথমে ভেবেছিলাম যে ওপি'র অ্যালগো # 1 টি হ'ল (এন ^ 2) সময়, তবে এটি আসলে হাড় মাথায় হে (এন ^ 3), সুতরাং যদিও আপনার অ্যালগরিদম এটিকে অর্জনযোগ্য ও (এন)-তে আবদ্ধ না করে, এটি এখনও একটি উন্নতি।

— j_random_hacker

আপনি এটিকে "সোজা" বলেছেন তবে এটি পূর্ণ i j l s ifএবং রাজ্য রক্ষণাবেক্ষণের দ্বারা পূর্ণ । একাধিক রিটার্ন পয়েন্ট, প্রান্তের মামলাগুলি ...

— v.oddou

Answer 7

হাই এই স্ট্রিংয়ের মধ্যে দীর্ঘতম প্যালিনড্রোম খুঁজে পেতে আমার কোড। দয়া করে অ্যালগরিদম বুঝতে নীচের লিঙ্কটি দেখুন http://stevekrenzel.com/articles/longest-palnidrome

ব্যবহৃত পরীক্ষার ডেটা হাইটওয়াইবিবিএবেডিএফজিএইচবিএসইডিসিডিবিএইচটিএফওয়াইডব্লু 1234567898765432121ZWETYGDE

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

Comments

আমি নিশ্চিত না যে এটি পেনড্রোমগুলি এমনকি দৈর্ঘ্যের সাথে কাজ করে ... আপনি নিশ্চিত করতে পারেন?

— st0le

এমনকি palindromes জন্য এই কাজ আপনি এই প্রোগ্রাম চালানো এবং যদি আলগোরিদিম you.For বোঝার জন্য কাজ করছে না কল্যাণকামী নিম্নলিখিত লিঙ্ক পড়ুন আমাকে জানাতে পারেন stevekrenzel.com/articles/longest-palnidrome

— মোহিত ভান্ডারী

@ st0le: এই যুক্তি এমনকি প্যালিনড্রোমগুলির জন্যও কাজ করবে না তবে এটি এমনকি প্যালিনড্রোমগুলির জন্যও সামঞ্জস্য করা যেতে পারে earlier পূর্ববর্তী কমেন্টের জন্য দয়া করে আমার জন্য দুঃখিত I আমি যুক্তিটি পেয়েছি এবং আমি যখন কিছু সময় পাই তখন এটি আপডেট করব।

— মোহিত ভান্ডারী

আজ অবধি আপনার পূর্ববর্তী মন্তব্যটি কখনও পড়বেন না ... আপনি আমাকে শেষবারের মতো সম্বোধন করেননি .... আপনার সময় নিন, এটি কেবল একটি পর্যবেক্ষণ ছিল।

— st0le

আমি প্রথমে ভাবিছিলাম যে ওপি'র অ্যালগো # 1 হ'ল ও (এন ^ 2) সময়, তবে এটি আসলে হাড় মাথায় হে (এন ^ 3), সুতরাং যদিও আপনার অ্যালগরিদম এটিকে অর্জনযোগ্য ও (এন)-তে আবদ্ধ না করে, এটি এখনও একটি উন্নতি।

— j_random_hacker

Answer 8

এই বিষয়ে উইকিপিডিয়া নিবন্ধ দেখুন । নীচের নিবন্ধ থেকে লিনিয়ার হে (এন) সমাধানের জন্য স্যাম্পল মানাচের অ্যালগোরিদম জাভা প্রয়োগ:

আমদানি java.util.Ararays; পাবলিক ক্লাসের ম্যানাচারস অ্যালগোরিদম {পাবলিক স্ট্যাটিক স্ট্রিং ফাইন্ডলজেক্টপ্যালিন্ড্রোম (স্ট্রিং গুলি) {যদি (গুলি = নাল || s.leight () == 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;   }     }

Answer 9

একটি দক্ষ Regexp সমাধান যা নিষ্ঠুর শক্তি এড়ায়

পুরো স্ট্রিং দৈর্ঘ্য দিয়ে শুরু হয় এবং 2 টি অক্ষরে নীচের দিকে কাজ করে, ম্যাচটি হওয়ার সাথে সাথেই উপস্থিত থাকে

"abaccddccefe"রিজএক্সপ্যাক্স পরীক্ষার জন্য ফেরার আগে 7 টি ম্যাচ ccddcc।

(।) (।) (।) (।) (।) (।) (\ 6) (\ 5) (\ 4) (\ 3) (\ 2) (\ 1)
(।) (।) (।) ) (।) (।) (।) (\ 5) (\ 4) (\ 3) (\ 2) (\ 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

Comments

@ ডিকসুলেইকা আপনি উপরোক্ত সংশোধিত কোড সহ আমার ডেইলিডোসোফেক্সেলসেলচারচাইভিস / ives / ০১ / ১৪ / এ আমার মন্তব্য আপডেট করতে পারবেন । Thx

— brettdj

Answer 10

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

Answer 11

স্ট্রিংটি ব্যবহার করে দেখুন - "HYTBCediaEFGHABCDEDCBAGHTFYW12345678998765432121ZWETYGDE"; এটি সম এবং বিজোড় বন্ধুদের জন্য কাজ করা উচিত। মোহিতকে অনেক ধন্যবাদ!

নেমস্পেস স্ট্যান্ড ব্যবহার করে;

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

Comments

এটি প্রায় O (n ^ 2) সময়ে কাজ করে। কেন এটি তৈরি করুন isPal- একটি হে (এন) অপারেশন - কেবল তার দৈর্ঘ্য পরিমাপ করার জন্য !? এমনকি প্যালিনড্রোমগুলি পরিচালনা করার ক্ষেত্রে এটি একটি বগি চেষ্টা করেছে। else if(input_str[i] == input_str[j])সম -প্যালিনড্রোম বগুড়ায়: কখনই সফল হতে পারে না কারণ আগের পরীক্ষায় একই পরীক্ষা অবশ্যই ব্যর্থ হয়েছিল if; এবং এটি যেহেতু বগি কারণ আপনি কেবল প্যালিনড্রোম বা একটি বিজোড় (বিবেচনা করুন AAAএবং AAAA) তাকান কিনা তা ছাড়াই 2 অক্ষরের ব্যবধানে 2 পজিশন দেখে আপনি বলতে পারবেন না ।

— j_random_hacker

Answer 12

নীচের কোডটি পলিড্রোমকে এমনকি দৈর্ঘ্য এবং বিজোড় দৈর্ঘ্যের স্ট্রিংগুলির জন্য গণনা করে।

সেরা সমাধান নয় তবে উভয় ক্ষেত্রেই কাজ করে

এইচটিবিসিএডেএফজিএইচবিডিইডিসিবিএইচটিবিওয়াই 12345678987654321ZWETYGDE এইচটিবিবিএডিএফজিএইচবিসিইডিসিবাগটিএফওয়াইডব্লিউ 1234567887654321ZWETYGDE

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

Answer 13

1. পৃথককারী ব্যবহার করে প্রতিটি অক্ষর পৃথক করতে স্ট্রিং পরিবর্তন করুন [এটি বিজোড় এবং এমনকি প্যালিনড্রোমগুলি অন্তর্ভুক্ত করতে]
2. কেন্দ্র হিসাবে বিবেচিত প্রতিটি চরিত্রের চারপাশে প্যালিনড্রোমগুলি সন্ধান করুন

এটি ব্যবহার করে আমরা সমস্ত দৈর্ঘ্যের সমস্ত প্যালিনড্রোমগুলি খুঁজে পেতে পারি।

নমুনা:

শব্দ = abcdcbc

পরিবর্তিত স্ট্রিং = এ # বি # সি # ডি # সি # বি # সি

প্যালিনকাউন্ট = 1010105010301

দীর্ঘতম প্যালিনড্রোমের দৈর্ঘ্য = 5;

দীর্ঘতম প্যালিনড্রোম = বিসিডিসিবি

পাবলিক ক্লাস MyLongestPalindrome class

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;

    }

}

}

Answer 14

এটি প্রদত্ত স্ট্রিং থেকে দীর্ঘতম প্যালিনড্রোম স্ট্রিংটি ফিরে আসবে

-(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"];
}

== আউটপুট ===

ইনপুট: abcccde আউটপুট: সিসিসি

ইনপুট: abcccbd আউটপুট: বিসিসিসিবি

ইনপুট: abedccde আউটপুট: edccde cc

ইনপুট: abcccdeed আউটপুট: দলিল

ইনপুট: abcccbadeed আউটপুট: abcccba

Answer 15

এখানে জাভাস্ক্রিপ্ট একটি বাস্তবায়ন:

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

Comments

কেন এটিকে নিচে ভোট দেওয়া হয়েছে তা জানেন না - কবজির মতো কাজ করে। সিএ প্রযুক্তিগুলির সাথে একটি সাক্ষাত্কারের মাধ্যমে আমাকে পেয়েছেন ঠিক আছে।

— অ্যালেক্স বনেট

Answer 16

রৈখিক সমাধানের জন্য, আপনি ম্যানাচারের অ্যালগরিদম ব্যবহার করতে পারেন। গুসফিল্ডের অ্যালগরিদম কল করার জন্য আরও একটি অ্যালগরিদম রয়েছে এবং জাভাতে কোডটি নীচে রয়েছে:

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

আপনি আমার নিজের ব্লগ থেকে সেরা ও (এন ^ 2) সমাধান বা মানাচের অ্যালগরিদমের মতো অন্যান্য সমাধানগুলিতে আরও জানতে পারেন ।

Answer 17

এখানে আমি একটি যুক্তি চেষ্টা করে লিখেছেন :)

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

}

Comments

এটি স্ট্রিংয়ের সমস্ত প্যালিনড্রোম দেয় কেবলমাত্র দীর্ঘতম নয়

— বিবেক মিশ্র

Answer 18

এই সমাধানটি ও (এন ^ 2) জটিলতার। ও (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 ;
        }

    }

Answer 19

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

D 'ডিইডি': 3, '123456789987654321': 18, '67899876': 8, 'এবিসিডিইডিসিএ': 9, '456789987654': 12, '34567899876543': 14, 'বিসিডিইডিসিবি': 7, 'এবিএ': 3, ' 5678998765 ': 10,' 2345678998765432 ': 16,' সিডিইডিসি ': 5,' 789987 ': 6,' 8998 ': 4} (' 123456789987654321 ', 18)

Answer 20

এখানে আমার অ্যালগরিদম:

1) বর্তমান কেন্দ্রটি প্রথম অক্ষর হিসাবে সেট করুন

2) আপনি বর্তমান কেন্দ্রের চারপাশে সর্বাধিক প্যালিনড্রোম খুঁজে না পাওয়া পর্যন্ত একযোগে বাম এবং ডানদিকে প্রসারিত করুন

3) আপনি যে প্যালিনড্রোমটি পেয়েছেন তা পূর্ব প্যালিনড্রোমের চেয়ে বড় হলে আপডেট করুন

4) বর্তমান কেন্দ্রটি পরবর্তী অক্ষর হিসাবে সেট করুন

5) স্ট্রিংয়ের সমস্ত অক্ষরের জন্য পদক্ষেপ 2) থেকে 4) পুনরাবৃত্তি করুন

এটি ও (এন) এ চলে।

আশা করি এটা সাহায্য করবে.

Comments

"আআআআআআ" স্ট্রিংটি বিবেচনা করুন। এটি আপনার অ্যালগোরিদম ব্যবহার করে ও (n ^ 2) এ চলে।

— পিসলি

আমি প্রথমে ভাবিছিলাম যে ওপি'র অ্যালগো # 1 হ'ল ও (এন ^ 2) সময়, তবে এটি আসলে হাড় মাথায় হে (এন ^ 3), সুতরাং যদিও আপনার অ্যালগরিদম এটিকে অর্জনযোগ্য ও (এন)-তে আবদ্ধ না করে, এটি এখনও একটি উন্নতি।

— j_random_hacker

এটি ক্লাসিক এন 2 সম্প্রসারণ সমাধান। কিন্তু, আসলে Manacher এর সমাধান পাসে যে যেমন এই ভিডিওটি ব্যাখ্যা ইন: youtube.com/watch?v=V-sEwsca1ak পার্থক্য বিন্দু 4. Manacher পুনঃব্যবহারের তথ্য ইতিমধ্যে স্ক্যান চিঠি rescan করতে এড়াতে সক্ষম হতে হয়।

— v.oddou

Answer 21

তথ্যসূত্র: উইকিপিডিয়া.কম

জটিলতা ও (এন) সহ আমি এর আগে খুঁজে পাওয়া সেরা অ্যালগরিদম

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

Answer 22

আমার সমাধানটি হ'ল:

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

Comments

স্ট্রিং-এর সমতা ( ) ক্রিয়াকলাপগুলির কারণে এটি স্ট্রিং দৈর্ঘ্যে কিউবিক সময় নেয় । এটি মূলত ওপির অ্যালগো # 1 অভিন্ন। Substring()==

— j_random_hacker