Gegeben a Zeichenfolge s Die Aufgabe besteht darin, das zu finden Minimum Charaktere zu sein angehängt (Einfügung am Ende) ein String-Palindrom erstellen.
Beispiele:
Eingang : s = ‚fertig‘
Ausgabe : 2
Erläuterung: Wir können ein String-Palindrom als 'abede' erstellen nicht ' durch Hinzufügen nicht am Ende der Zeichenfolge.
Eingang :s = 'aabb'
Ausgabe : 2
Erläuterung: Wir können ein String-Palindrom als'aabb erstellen aa ' durch Hinzufügen aa am Ende der Zeichenfolge.
Inhaltsverzeichnis
- Überprüfen Sie das Palindrom jedes Mal – O(n^2) Zeit und O(n) Raum
- Verwendung des Knuth Morris Pratt-Algorithmus – O(n) Zeit und O(n) Raum
Überprüfen Sie das Palindrom jedes Mal – O(n^2) Zeit und O(n) Raum
C++Die Lösung beinhaltet nach und nach Entfernen von Zeichen aus dem Anfang der Zeichenfolge nacheinander, bis die Zeichenfolge zu a wird Palindrom . Die Antwort ist die Gesamtzahl der entfernten Zeichen.
Betrachten Sie zum Beispiel die Zeichenfolge s = ‚hier‘. Wir prüfen zunächst, ob die gesamte Zeichenfolge ein Palindrom ist, was nicht der Fall ist. Als nächstes entfernen wir das erste Zeichen, was zu dem führt Zeichenfolge 'betteln'. Wir überprüfen es noch einmal, aber es ist immer noch kein Palindrom. Anschließend entfernen wir ein weiteres Zeichen von Anfang an „ede“ verlassen. Diesmal ist die Zeichenfolge ein Palindrom. Daher die Die Ausgabe ist 2 stellt die Anzahl der vom Anfang entfernten Zeichen dar, um ein Palindrom zu erhalten.
// C++ code to find minimum number // of appends to make string Palindrome #include
// Java code to find minimum number // of appends to make string Palindrome import java.util.*; class GfG { // Function to check if a given string is a palindrome static boolean isPalindrome(String s) { int left = 0 right = s.length() - 1; while (left < right) { if (s.charAt(left) != s.charAt(right)) return false; left++; right--; } return true; } // Function to find the minimum number of // characters to remove from the beginning static int noOfAppends(String s) { int n = s.length(); // Remove characters from the start until // the string becomes a palindrome for (int i = 0; i < n; i++) { if (isPalindrome(s.substring(i))) { // Return the number of characters removed return i; } } // If no palindrome is found remove // all but one character return n - 1; } public static void main(String[] args) { String s = 'abede'; int result = noOfAppends(s); System.out.println(result); } }
# Python code to find minimum number # of appends to make string Palindrome # Function to check if a given string is a palindrome def is_palindrome(s): left right = 0 len(s) - 1 while left < right: if s[left] != s[right]: return False left += 1 right -= 1 return True # Function to find the minimum number of # characters to remove from the beginning def no_of_appends(s): n = len(s) # Remove characters from the start until # the string becomes a palindrome for i in range(n): if is_palindrome(s[i:]): # Return the number of characters # removed return i # If no palindrome is found remove # all but one character return n - 1 if __name__ == '__main__': s = 'abede' result = no_of_appends(s) print(result)
// C# code to find minimum number // of appends to make string Palindrome using System; class GfG { // Function to check if a given string // is a palindrome static bool IsPalindrome(string s) { int left = 0 right = s.Length - 1; while (left < right) { if (s[left] != s[right]) return false; left++; right--; } return true; } // Function to find the minimum number of // characters to remove from the beginning static int NoOfAppends(string s) { int n = s.Length; // Remove characters from the start until // the string becomes a palindrome for (int i = 0; i < n; i++) { if (IsPalindrome(s.Substring(i))) { // Return the number of characters // removed return i; } } // If no palindrome is found remove all but // one character return n - 1; } static void Main(string[] args) { string s = 'abede'; int result = NoOfAppends(s); Console.WriteLine(result); } }
// JavaScript code to find minimum number // of appends to make string Palindrome // Function to check if a given string is a palindrome function isPalindrome(s) { let left = 0 right = s.length - 1; while (left < right) { if (s[left] !== s[right]) return false; left++; right--; } return true; } // Function to find the minimum number of // characters to remove from the beginning function noOfAppends(s) { let n = s.length; // Remove characters from the start until // the string becomes a palindrome for (let i = 0; i < n; i++) { if (isPalindrome(s.substring(i))) { // Return the number of // characters removed return i; } } // If no palindrome is found remove // all but one character return n - 1; } const s = 'abede'; const result = noOfAppends(s); console.log(result);
Ausgabe
2
Verwendung des Knuth Morris Pratt-Algorithmus – O(n) Zeit und O(n) Raum
C++Der Grundgedanke hinter dem Ansatz ist, dass wir berechnen Die Größter Teilstring vom Ende und die Länge der Zeichenfolge Minus Dieser Wert ist der Minimum Anzahl der Anhänge. Die Logik ist intuitiv, wir müssen sie nicht anhängen Palindrom und nur diejenigen, die nicht das Palindrom bilden. Um dieses größte Palindrom vom Ende zu finden, haben wir umkehren Die Zeichenfolge berechnet die DFA.
Der DFA (Deterministischer endlicher Automat) im Zusammenhang mit erwähnt Knuth Morris Pratt-Algorithmus ist ein Konzept, das bei der Suche hilft längstes Präfix einer Zeichenfolge, das auch ein Suffix ist und kehren Sie die Zeichenfolge erneut um (wodurch Sie die ursprüngliche Zeichenfolge zurückgewinnen) und ermitteln Sie den Endzustand, der die Anzahl der Übereinstimmungen der Zeichenfolge mit der verehrten Zeichenfolge darstellt. Daher erhalten wir vom Ende an die größte Teilzeichenfolge, die ein Palindrom ist.
// CPP program for the given approach // using 2D vector for DFA #include
// Java program for the given approach // using 2D array for DFA import java.util.*; class GfG { // Function to build the DFA and precompute the state static int[][] buildDFA(String s) { int n = s.length(); // Number of possible characters (ASCII range) int c = 256; // Initialize 2D array with zeros int[][] dfa = new int[n][c]; int x = 0; dfa[0][s.charAt(0)] = 1; // Build the DFA for the given string for (int i = 1; i < n; i++) { for (int j = 0; j < c; j++) { dfa[i][j] = dfa[x][j]; } dfa[i][s.charAt(i)] = i + 1; x = dfa[x][s.charAt(i)]; } return dfa; } // Function to find the longest overlap // between the string and its reverse static int longestOverlap(int[][] dfa String query) { int ql = query.length(); int state = 0; // Traverse through the query to // find the longest overlap for (int i = 0; i < ql; i++) { state = dfa[state][query.charAt(i)]; } return state; } // Function to find the minimum // number of characters to append static int minAppends(String s) { // Reverse the string String reversedS = new StringBuilder(s).reverse().toString(); // Build the DFA for the reversed string int[][] dfa = buildDFA(reversedS); // Get the longest overlap with the original string int longestOverlapLength = longestOverlap(dfa s); // Minimum characters to append // to make the string a palindrome return s.length() - longestOverlapLength; } public static void main(String[] args) { String s = 'abede'; System.out.println(minAppends(s)); } }
# Python program for the given approach # using 2D list for DFA # Function to build the DFA and precompute the state def buildDFA(s): n = len(s) # Number of possible characters (ASCII range) c = 256 # Initialize 2D list with zeros dfa = [[0] * c for _ in range(n)] x = 0 dfa[0][ord(s[0])] = 1 # Build the DFA for the given string for i in range(1 n): for j in range(c): dfa[i][j] = dfa[x][j] dfa[i][ord(s[i])] = i + 1 x = dfa[x][ord(s[i])] return dfa # Function to find the longest overlap # between the string and its reverse def longestOverlap(dfa query): ql = len(query) state = 0 # Traverse through the query to # find the longest overlap for i in range(ql): state = dfa[state][ord(query[i])] return state # Function to find the minimum # number of characters to append def minAppends(s): # Reverse the string reversedS = s[::-1] # Build the DFA for the reversed string dfa = buildDFA(reversedS) # Get the longest overlap with the # original string longestOverlapLength = longestOverlap(dfa s) # Minimum characters to append # to make the string a palindrome return len(s) - longestOverlapLength if __name__ == '__main__': s = 'abede' print(minAppends(s))
// C# program for the given approach // using 2D array for DFA using System; class GfG { // Function to build the DFA and precompute the state static int[] buildDFA(string s) { int n = s.Length; // Number of possible characters // (ASCII range) int c = 256; // Initialize 2D array with zeros int[] dfa = new int[n c]; int x = 0; dfa[0 s[0]] = 1; // Build the DFA for the given string for (int i = 1; i < n; i++) { for (int j = 0; j < c; j++) { dfa[i j] = dfa[x j]; } dfa[i s[i]] = i + 1; x = dfa[x s[i]]; } return dfa; } // Function to find the longest overlap // between the string and its reverse static int longestOverlap(int[] dfa string query) { int ql = query.Length; int state = 0; // Traverse through the query to // find the longest overlap for (int i = 0; i < ql; i++) { state = dfa[state query[i]]; } return state; } // Function to find the minimum // number of characters to append static int minAppends(string s) { // Reverse the string using char array char[] reversedArray = s.ToCharArray(); Array.Reverse(reversedArray); string reversedS = new string(reversedArray); // Build the DFA for the reversed string int[] dfa = buildDFA(reversedS); // Get the longest overlap with the original string int longestOverlapLength = longestOverlap(dfa s); // Minimum characters to append // to make the string a palindrome return s.Length - longestOverlapLength; } static void Main() { string s = 'abede'; Console.WriteLine(minAppends(s)); } }
// JavaScript program for the given approach // using 2D array for DFA // Function to build the DFA and precompute the state function buildDFA(s) { let n = s.length; // Number of possible characters // (ASCII range) let c = 256; // Initialize 2D array with zeros let dfa = Array.from({ length: n } () => Array(c).fill(0)); let x = 0; dfa[0][s.charCodeAt(0)] = 1; // Build the DFA for the given string for (let i = 1; i < n; i++) { for (let j = 0; j < c; j++) { dfa[i][j] = dfa[x][j]; } dfa[i][s.charCodeAt(i)] = i + 1; x = dfa[x][s.charCodeAt(i)]; } return dfa; } // Function to find the longest overlap // between the string and its reverse function longestOverlap(dfa query) { let ql = query.length; let state = 0; // Traverse through the query to // find the longest overlap for (let i = 0; i < ql; i++) { state = dfa[state][query.charCodeAt(i)]; } return state; } // Function to find the minimum // number of characters to append function minAppends(s) { // Reverse the string let reversedS = s.split('').reverse().join(''); // Build the DFA for the reversed string let dfa = buildDFA(reversedS); // Get the longest overlap with the original string let longestOverlapLength = longestOverlap(dfa s); // Minimum characters to append // to make the string a palindrome return s.length - longestOverlapLength; } let s = 'abede'; console.log(minAppends(s));
Ausgabe
2
Verwandter Artikel:
- Dynamische Programmierung | Set 28 (Minimale Einfügungen zur Bildung eines Palindroms)