প্যালিনড্রোমের জন্য স্ট্রিং পরীক্ষা করুন

Question 1

একজন যে শব্দ কবিতা প্রভৃতি উলটা করিয়া পড়িলেও একই থাকে একটি শব্দ, শব্দগুচ্ছ, নাম্বার বা যে উভয় দিক একই ভাবে পড়া যায় ইউনিট অন্যান্য ক্রম।

কোনও শব্দটি প্যালিনড্রোম কিনা তা যাচাই করতে আমি শব্দের চর অ্যারে পাই এবং বর্ণগুলি তুলনা করি। আমি এটি পরীক্ষা করেছি এবং এটি কাজ করে বলে মনে হচ্ছে। তবে আমি জানতে চাই যে এটি সঠিক কিনা বা উন্নতির জন্য কিছু আছে কিনা।

আমার কোডটি এখানে:

public class Aufg1 {
    public static void main(String[] args) {
        String wort = "reliefpfpfeiller";
        char[] warray = wort.toCharArray(); 
        System.out.println(istPalindrom(warray));       
    }

    public static boolean istPalindrom(char[] wort){
        boolean palindrom = false;
        if(wort.length%2 == 0){
            for(int i = 0; i < wort.length/2-1; i++){
                if(wort[i] != wort[wort.length-i-1]){
                    return false;
                }else{
                    palindrom = true;
                }
            }
        }else{
            for(int i = 0; i < (wort.length-1)/2-1; i++){
                if(wort[i] != wort[wort.length-i-1]){
                    return false;
                }else{
                    palindrom = true;
                }
            }
        }
        return palindrom;
    }
}

Question 2

কেন শুধু:

public static boolean istPalindrom(char[] word){
    int i1 = 0;
    int i2 = word.length - 1;
    while (i2 > i1) {
        if (word[i1] != word[i2]) {
            return false;
        }
        ++i1;
        --i2;
    }
    return true;
}

উদাহরণ:

ইনপুট হ'ল "andna"।
i1 0 হবে এবং i2 হবে 4।

প্রথম লুপ পুনরাবৃত্তি আমরা তুলনা করব word[0]এবং word[4]। তারা সমান, তাই আমরা i1 বৃদ্ধি করি (এটি এখন 1) এবং হ্রাস i2 (এটি এখন 3)।
সুতরাং আমরা তারপর এন এর তুলনা। তারা সমান, তাই আমরা i1 বৃদ্ধি করি (এটি এখন 2) এবং হ্রাস i2 (এটি 2)।
এখন আই 1 এবং আই 2 সমান (তারা উভয়ই 2), সুতরাং লুপের শর্তটি আর সত্য নয় সুতরাং লুপটি সমাপ্ত হয় এবং আমরা সত্য ফিরে আসি।

Question 3

স্ট্রিংটিকে নিজের বিপরীতে তুলনা করে কোনও স্ট্রিং প্যালিনড্রোম কিনা তা আপনি পরীক্ষা করতে পারেন:

public static boolean isPalindrome(String str) {
    return str.equals(new StringBuilder(str).reverse().toString());
}

বা জাভা সংস্করণের জন্য 1.5 এর আগে,

public static boolean isPalindrome(String str) {
    return str.equals(new StringBuffer().append(str).reverse().toString());
}

সম্পাদনা: @ ফার্নান্দোপেলিকসিওনি সময় এবং স্থান উভয় ক্ষেত্রেই এই সমাধানটির দক্ষতা (বা এর অভাব) সম্পর্কে খুব বিশদ বিশ্লেষণ করেছেন। আপনি যদি এই এবং এই প্রশ্নের অন্যান্য সম্ভাব্য সমাধানগুলির গণ্য জটিলতায় আগ্রহী হন, দয়া করে এটি পড়ুন!

Question 4

একটি সংক্ষিপ্ত সংস্করণ, এতে জড়িত নয় (অকার্যকরভাবে) একগুচ্ছ অবজেক্টের গোড়া:

boolean isPalindrome(String str) {    
    int n = str.length();
    for( int i = 0; i < n/2; i++ )
        if (str.charAt(i) != str.charAt(n-i-1)) return false;
    return true;    
}

Question 5

বিকল্পভাবে, পুনরাবৃত্তি ।

যে কোনও সংক্ষিপ্ত পুনরাবৃত্ত সমাধান সমাধানের সন্ধান করছে তার জন্য, প্রদত্ত স্ট্রিংটি প্যালিনড্রোম হিসাবে সন্তুষ্ট কিনা তা পরীক্ষা করে দেখার জন্য:

private boolean isPalindrome(String s) {
    int length = s.length();

    if (length < 2) // If the string only has 1 char or is empty
        return true;
    else {
        // Check opposite ends of the string for equality
        if (s.charAt(0) != s.charAt(length - 1))
            return false;
        // Function call for string with the two ends snipped off
        else
            return isPalindrome(s.substring(1, length - 1));
    }
}

বা আরও ছোট , যদি আপনি চান:

private boolean isPalindrome(String s) {
    int length = s.length();
    if (length < 2) return true;
    return s.charAt(0) != s.charAt(length - 1) ? false :
            isPalindrome(s.substring(1, length - 1));
}

Question 6

যাও, জাভা:

public boolean isPalindrome (String word) {
    String myWord = word.replaceAll("\\s+","");
    String reverse = new StringBuffer(myWord).reverse().toString();
    return reverse.equalsIgnoreCase(myWord);
}

isPalindrome("Never Odd or Even"); // True
isPalindrome("Never Odd or Even1"); // False

Question 7

এছাড়াও একটি ভিন্ন চেহারা সমাধান:

public static boolean isPalindrome(String s) {

        for (int i=0 , j=s.length()-1 ; i<j ; i++ , j-- ) {

            if ( s.charAt(i) != s.charAt(j) ) {
                return false;
            }
        }

        return true;
    }

Question 8

এবং এখানে একটি সম্পূর্ণ জাভা 8 স্ট্রিমিং সমাধান। স্ট্রিমিটি অর্ধ দৈর্ঘ্যের মতো একটি ইনটস্ট্রিম সমস্ত সূচক সরবরাহ করে এবং তারপরে শুরু থেকে শেষের সাথে একটি তুলনা করা হয়।

public static void main(String[] args) {
    for (String testStr : Arrays.asList("testset", "none", "andna", "haah", "habh", "haaah")) {
        System.out.println("testing " + testStr + " is palindrome=" + isPalindrome(testStr));
    }
}

public static boolean isPalindrome(String str) {
    return IntStream.range(0, str.length() / 2)
            .noneMatch(i -> str.charAt(i) != str.charAt(str.length() - i - 1));
}

আউটপুট হল:

testing testset is palindrome=true
testing none is palindrome=false
testing andna is palindrome=true
testing haah is palindrome=true
testing habh is palindrome=false
testing haaah is palindrome=true

Question 9

public class Palindromes {
    public static void main(String[] args) {
         String word = "reliefpfpfeiller";
         char[] warray = word.toCharArray(); 
         System.out.println(isPalindrome(warray));       
    }

    public static boolean isPalindrome(char[] word){
        if(word.length%2 == 0){
            for(int i = 0; i < word.length/2-1; i++){
                if(word[i] != word[word.length-i-1]){
                    return false;
                }
            }
        }else{
            for(int i = 0; i < (word.length-1)/2-1; i++){
                if(word[i] != word[word.length-i-1]){
                    return false;
                }
            }
        }
        return true;
    }
}

Question 10

public class palindrome {
public static void main(String[] args) {
    StringBuffer strBuf1 = new StringBuffer("malayalam");
    StringBuffer strBuf2 = new StringBuffer("malayalam");
    strBuf2.reverse();


    System.out.println(strBuf2);
    System.out.println((strBuf1.toString()).equals(strBuf2.toString()));
    if ((strBuf1.toString()).equals(strBuf2.toString()))
        System.out.println("palindrome");
    else
        System.out.println("not a palindrome");
}

}

Question 11

এই প্রশ্নের সদৃশ হিসাবে চিহ্নিত একটি প্রশ্নের সমাধানের জন্য আমি কাজ করেছি। এটিকে এখানে ফেলে দিতে পারে ...

এটিকে সমাধান করার জন্য প্রশ্নটি একটি একক লাইনকে অনুরোধ করেছিল এবং আমি এটিকে সাহিত্যের প্যালিনড্রোম হিসাবে আরও গ্রহণ করেছি - যাতে ফাঁক, বিরামচিহ্ন এবং উচ্চ / নিম্নতর কেস ফলাফলটি ফেলে দিতে পারে।

একটি ছোট পরীক্ষার শ্রেণীর সাথে কুশ্রী সমাধানটি এখানে:

public class Palindrome {
   public static boolean isPalendrome(String arg) {
         return arg.replaceAll("[^A-Za-z]", "").equalsIgnoreCase(new StringBuilder(arg).reverse().toString().replaceAll("[^A-Za-z]", ""));
   }
   public static void main(String[] args) {
      System.out.println(isPalendrome("hiya"));
      System.out.println(isPalendrome("star buttons not tub rats"));
      System.out.println(isPalendrome("stab nail at ill Italian bats!"));
      return;
   }
}

দুঃখিত যে এটি একদম কদর্য - তবে অন্য প্রশ্নটি একটি ওয়ান-লাইন নির্দিষ্ট করেছে।

Question 12

বাকী অংশগুলির সাথে স্ট্রিংয়ের প্রথমার্ধের জন্য প্যালিনড্রোম চেক করা, এই ক্ষেত্রে কোনও সাদা স্পেস সরিয়ে ফেলা অনুমান করে।

public int isPalindrome(String a) {
        //Remove all spaces and non alpha characters
        String ab = a.replaceAll("[^A-Za-z0-9]", "").toLowerCase();
        //System.out.println(ab);

        for (int i=0; i<ab.length()/2; i++) {
            if(ab.charAt(i) != ab.charAt((ab.length()-1)-i)) {
                return 0;
            }
        }   
        return 1;
    }

Question 13

আমি জাভাতে নতুন এবং আমি আমার জ্ঞানের উন্নতি করার চ্যালেঞ্জ হিসাবে আপনার প্রশ্নটি গ্রহণ করছি।

import java.util.ArrayList;
import java.util.List;

public class PalindromeRecursiveBoolean {

    public static boolean isPalindrome(String str) {

        str = str.toUpperCase();
        char[] strChars = str.toCharArray();

        List<Character> word = new ArrayList<>();
        for (char c : strChars) {
            word.add(c);
        }

        while (true) {
            if ((word.size() == 1) || (word.size() == 0)) {
                return true;
            }
            if (word.get(0) == word.get(word.size() - 1)) {
                word.remove(0);
                word.remove(word.size() - 1);
            } else {
                return false;

            }

        }
    }
}

যদি স্ট্রিংটি কোনও অক্ষর বা কেবল একটি বর্ণের তৈরি হয় তবে এটি প্যালিনড্রোম।
অন্যথায়, স্ট্রিংয়ের প্রথম এবং শেষ বর্ণগুলি তুলনা করুন।
- যদি প্রথম এবং শেষ বর্ণগুলি পৃথক হয়, তবে স্ট্রিংটি প্যালিনড্রোম নয়
- অন্যথায়, প্রথম এবং শেষ বর্ণগুলি একই। তাদের স্ট্রিং থেকে স্ট্রিপ করুন, এবং নির্ধারণ করুন যে স্ট্রিংটি একটি প্যালিনড্রোম রয়েছে। এই ছোট স্ট্রিংয়ের জন্য উত্তর নিন এবং এটি মূল স্ট্রিংয়ের উত্তর হিসাবে ব্যবহার করুন তারপরে 1 থেকে পুনরাবৃত্তি করুন ।

Question 14

এটি ব্যবহার করে দেখুন:

import java.util.*;
    public class str {

        public static void main(String args[])
        {
          Scanner in=new Scanner(System.in);
          System.out.println("ENTER YOUR STRING: ");
          String a=in.nextLine();
          System.out.println("GIVEN STRING IS: "+a);
          StringBuffer str=new StringBuffer(a);
          StringBuffer str2=new StringBuffer(str.reverse());
          String s2=new String(str2);
          System.out.println("THE REVERSED STRING IS: "+str2);
            if(a.equals(s2))    
                System.out.println("ITS A PALINDROME");
            else
                System.out.println("ITS NOT A PALINDROME");
            }
    }

Question 15

public boolean isPalindrome(String abc){
    if(abc != null && abc.length() > 0){
        char[] arr = abc.toCharArray();
        for (int i = 0; i < arr.length/2; i++) {
            if(arr[i] != arr[arr.length - 1 - i]){
                return false;
            }
        }
        return true;
    }
    return false;
}

Question 16

আর একটি উপায় চর অ্যারে ব্যবহার করা হয়

public class Palindrome {

public static void main(String[] args) {
    String str = "madam";
    if(isPalindrome(str)) {
        System.out.println("Palindrome");
    } else {
        System.out.println("Not a Palindrome");
    }
}

private static boolean isPalindrome(String str) {
    // Convert String to char array
    char[] charArray = str.toCharArray();  
    for(int i=0; i < str.length(); i++) {
        if(charArray[i] != charArray[(str.length()-1) - i]) {
            return false;
        }
    }
    return true;
}

}

Question 17

এখানে @ গ্রেগ উত্তর সম্পর্কে আমার বিশ্লেষণ: উপাদানগুলি প্রোগ্রামিং / প্যালিনড্রোমস

সিডিনোট: তবে, আমার পক্ষে এটি জেনেরিক পদ্ধতিতে করা গুরুত্বপূর্ণ । প্রয়োজনীয়তা হ'ল সিকোয়েন্সটি দ্বিদ্বিধায় পুনরুক্তিযোগ্য এবং ক্রমের উপাদানগুলি সাম্য ব্যবহার করে তুলনীয়। আমি জাভাতে এটি কীভাবে করব তা জানি না, তবে, এখানে একটি সি ++ সংস্করণ রয়েছে, আমি এটি দ্বিপাক্ষিক ক্রমগুলির জন্য আরও ভালতর উপায় জানি না।

template <BidirectionalIterator I> 
    requires( EqualityComparable< ValueType<I> > ) 
bool palindrome( I first, I last ) 
{ 
    I m = middle(first, last); 
    auto rfirst = boost::make_reverse_iterator(last); 
    return std::equal(first, m, rfirst); 
}

জটিলতা: রৈখিক সময়,

যদি আমি র্যান্ডমএকসেসিট্রেটার: মেঝে (n / 2) তুলনা এবং মেঝে (n / 2) * 2 পুনরাবৃত্তি
যদি আমি দ্বিদ্বিধায়ক
স্টোরেজ: ও (1)
কোনও ডায়ামমিক বরাদ্দ মেমরি নেই

Question 18

সম্প্রতি আমি একটি প্যালিনড্রোম প্রোগ্রাম লিখেছিলাম যা স্ট্রিংবুডার ব্যবহার করে না। দেরিতে উত্তর তবে এটি কিছু লোকের পক্ষে কার্যকর হতে পারে।

public boolean isPalindrome(String value) {
    boolean isPalindrome = true;
    for (int i = 0 , j = value.length() - 1 ; i < j ; i ++ , j --) {
        if (value.charAt(i) != value.charAt(j)) {
            isPalindrome = false;
        }
    }
    return isPalindrome;
}

Question 19

স্ট্যাক ব্যবহার করে এটি এটি করা যেতে পারে

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str=in.nextLine();
        str.replaceAll("\\s+","");
        //System.out.println(str);
        Stack<String> stack=new Stack<String>();
        stack.push(str);
        String str_rev=stack.pop();
        if(str.equals(str_rev)){
            System.out.println("Palindrome"); 
        }else{
             System.out.println("Not Palindrome");
        }
    }
}

Question 20

 public static boolean isPalindrome(String word) {
    String str = "";
    for (int i=word.length()-1; i>=0;  i--){
        str = str + word.charAt(i);
    }
   if(str.equalsIgnoreCase(word)){
       return true;
   }else{
       return false;
   }

}

Question 21

আশ্চর্যজনক যে এত সহজ সমস্যার কতগুলি পৃথক সমাধান বিদ্যমান! এখানে অন্য একটি।

private static boolean palindrome(String s){
    String revS = "";
    String checkS = s.toLowerCase();
    String[] checkSArr = checkS.split("");

    for(String e : checkSArr){
        revS = e + revS;
    }

    return (checkS.equals(revS)) ? true : false;
}

Question 22

এই বাস্তবায়ন সংখ্যা এবং স্ট্রিংয়ের জন্য কাজ করে।

যেহেতু আমরা কিছু লিখছি না, সুতরাং স্ট্রিংটি অক্ষর অ্যারেতে রূপান্তর করার দরকার নেই।

public static boolean isPalindrome(Object obj)
{
    String s = String.valueOf(obj);

    for(int left=0, right=s.length()-1; left < right; left++,right--)
    {
        if(s.charAt(left++) != s.charAt(right--))
            return false;
    }
    return true;
}

Question 23

কেন শুধু:

boolean isPalindrom(String s) {
        char[] myChars = s.toCharArray();
        for (int i = 0; i < myChars.length/2; i++) {
            if (myChars[i] != myChars[myChars.length - 1 - i]) {
                return false;
            }
        }
        return true;
}

Question 24

import java.util.Scanner;


public class Palindrom {

    public static void main(String []args)
    {
        Scanner in = new Scanner(System.in);
        String str= in.nextLine();
        int x= str.length();

        if(x%2!=0)
        {
            for(int i=0;i<x/2;i++)
            {

                if(str.charAt(i)==str.charAt(x-1-i))
                {
                    continue;
                }
                else 
                {
                    System.out.println("String is not a palindrom");
                    break;
                }
            }
        }
        else
        {
            for(int i=0;i<=x/2;i++)
            {
                if(str.charAt(i)==str.charAt(x-1-i))
                {
                    continue;
                }
                else 
                {
                    System.out.println("String is not a palindrom");
                    break;
                }

            }
        }
    }

}

Question 25

private static boolean isPalindrome(String word) {

        int z = word.length();
        boolean isPalindrome = false;

        for (int i = 0; i <= word.length() / 2; i++) {
            if (word.charAt(i) == word.charAt(--z)) {
                isPalindrome = true;
            }
        }

        return isPalindrome;
    }

Question 26

আমি এমন একটি সমাধান খুঁজছিলাম যা কেবল প্যালিনড্রোমের মতোই কাজ করে না ...

"কায়ক"
"ম্যাডাম"

... তবে পাশাপাশি ...

"একজন মানুষ, একটি পরিকল্পনা, একটি খাল, পানামা!"
"এটি গাড়ি বা বিড়াল আমি দেখেছি?"
"নিক্সনের কোনও 'x' নয়

Iterative : এটি একটি ভাল সমাধান হিসাবে প্রমাণিত হয়েছে।

private boolean isPalindromeIterative(final String string)
    {
        final char[] characters =
            string.replaceAll("[\\W]", "").toLowerCase().toCharArray();

        int iteratorLeft = 0;
        int iteratorEnd = characters.length - 1;

        while (iteratorEnd > iteratorLeft)
        {
            if (characters[iteratorLeft++] != characters[iteratorEnd--])
            {
                return false;
            }
        }

        return true;
    }

পুনরাবৃত্তি । আমি মনে করি এই সমাধানটি পুনরাবৃত্তের চেয়ে খুব খারাপ হওয়া উচিত নয়। কিছুটা কৃপণতা কি আমাদের অযৌক্তিক প্রক্রিয়াজাতকরণ এড়াতে পদ্ধতিটি থেকে পরিষ্কারের পদক্ষেপটি বের করতে হবে।

private boolean isPalindromeRecursive(final String string)
        {
            final String cleanString = string.replaceAll("[\\W]", "").toLowerCase();
            return isPalindromeRecursiveRecursion(cleanString);
        }

private boolean isPalindromeRecursiveRecursion(final String cleanString)
        {
            final int cleanStringLength = cleanString.length();

            return cleanStringLength <= 1 || cleanString.charAt(0) ==
                       cleanString.charAt(cleanStringLength - 1) &&
                       isPalindromeRecursiveRecursion  
                           (cleanString.substring(1, cleanStringLength - 1));
        }

বিপরীত : এটি ব্যয়বহুল সমাধান হিসাবে প্রমাণিত হয়েছে।

private boolean isPalindromeReversing(final String string)
    {
        final String cleanString = string.replaceAll("[\\W]", "").toLowerCase();
        return cleanString.equals(new StringBuilder(cleanString).reverse().toString());
    }

ছেলেদের সমস্ত কৃতিত্ব এই পোস্টে উত্তর দেওয়া এবং বিষয়টিতে আলোকপাত করা।

Question 27

কথায় চিঠি না বিবেচনা করা

public static boolean palindromeWords(String s ){

        int left=0;
        int right=s.length()-1;

        while(left<=right){

            while(left<right && !Character.isLetter(s.charAt(left))){
                left++;
            }
            while(right>0 && !Character.isLetter(s.charAt(right))){
                right--;
            }

            if((s.charAt(left++))!=(s.charAt(right--))){
                return false;
            }
        }
        return true;
    }

---

@Test
public void testPalindromeWords(){
    assertTrue(StringExercise.palindromeWords("ece"));
    assertTrue(StringExercise.palindromeWords("kavak"));
    assertFalse(StringExercise.palindromeWords("kavakdf"));
    assertTrue(StringExercise.palindromeWords("akka"));
    assertTrue(StringExercise.palindromeWords("??e@@c_--e"));
}

Question 28

এখানে আপনি গতিশীলভাবে বেশ কয়েকটি স্ট্রিং প্যালিনড্রোম চেক করতে পারেন

import java.util.Scanner;

public class Checkpalindrome {
 public static void main(String args[]) {
  String original, reverse = "";
  Scanner in = new Scanner(System.in);
  System.out.println("Enter How Many number of Input you want : ");
  int numOfInt = in.nextInt();
  original = in.nextLine();
do {
  if (numOfInt == 0) {
    System.out.println("Your Input Conplete");
   } 
  else {
    System.out.println("Enter a string to check palindrome");
    original = in.nextLine();

    StringBuffer buffer = new StringBuffer(original);
    reverse = buffer.reverse().toString();

  if (original.equalsIgnoreCase(reverse)) {
    System.out.println("The entered string is Palindrome:"+reverse);
   } 
  else {
    System.out.println("The entered string is not Palindrome:"+reverse);
    }
 }
   numOfInt--;
    } while (numOfInt >= 0);
}
}

Question 29

আইএমও, পুনরাবৃত্তির উপায়টি সহজ এবং পরিষ্কার।

public static boolean isPal(String s)
{   
    if(s.length() == 0 || s.length() == 1)
        return true; 
    if(s.charAt(0) == s.charAt(s.length()-1))
       return isPal(s.substring(1, s.length()-1));                
   return false;
}

Question 30

এখানে সর্বদা 1 ম চর থেকে শুরু করে একটি স্ট্রিংয়ের বৃহত্তম প্যালিনড্রোমের জন্য চেক করা হচ্ছে।

public static String largestPalindromeInString(String in) {
    int right = in.length() - 1;
    int left = 0;
    char[] word = in.toCharArray();
    while (right > left && word[right] != word[left]) {
        right--;
    }
    int lenght = right + 1;
    while (right > left && word[right] == word[left]) {

        left++;
        right--;

    }
    if (0 >= right - left) {
        return new String(Arrays.copyOf(word, lenght ));
    } else {
        return largestPalindromeInString(
                new String(Arrays.copyOf(word, in.length() - 1)));
    }
}

Question 31

টুকিটাকি সংকেতলিপি:

import java.util.Scanner;

 class main
 {
    public static void main(String []args)
    {
       Scanner sc = new Scanner(System.in);
       String str = sc.next();
       String reverse = new StringBuffer(str).reverse().toString();

        if(str.equals(reverse))
            System.out.println("Pallindrome");
        else
            System.out.println("Not Pallindrome");
     }
}