在给定的两个字符串之间找到一个按字典顺序排列的字符串-yiteyi-C++库

给定两个字符串S和T，找到一个长度相同的字符串，该字符串在字典上大于S，小于T。如果没有形成这样的字符串，请打印“-1”。（S>T）

null

注：如果存在一个i，那么字符串S=s1s2…sn在词典学上比字符串T=t1t2…tn小，这样s1=t1，s2=t2，…si-1=ti-1，si

例如：

Input : S = "aaa", T = "ccc"Output : aabExplanation: Here, 'b' is greater than any letter in S[]('a') and smaller than any letter in T[]('c').Input : S = "abcde", T = "abcdf"Output : -1Explanation: There is no other string betweenS and T.

推荐：请尝试你的方法 {IDE} 首先，在进入解决方案之前。

方法： 查找一个按字典顺序大于字符串S的字符串，并检查它是否小于字符串T，如果是，则打印该字符串，否则打印“-1”。要查找字符串，请按相反顺序迭代字符串S，如果最后一个字母不是“z”，请将字母增加一（以移动到下一个字母）。如果是“z”，则将其更改为“a”，并移动到最后一个字符。将结果字符串与字符串T进行比较，如果两个字符串相等，则打印’-1’，否则打印结果字符串。

以下是上述方法的实施情况：

C++

                             // CPP program to find the string                           
                             // in lexicographic order which is                           
                             // in between given two strings                           
                             #include <bits/stdc++.h>                           
                             using                                           namespace                                           std;                           
             
                             // Function to find the lexicographically                           
                             // next string                           
                             string lexNext(string s,                                           int                                           n)                           
                             {                           
                                                         // Iterate from last character                           
                                                         for                                           (                                           int                                           i = n - 1; i >= 0; i--)                           
                                                         {                           
                                                         // If not 'z', increase by one                           
                                                         if                                           (s[i] !=                                           'z'                                           )                           
                                                         {                           
                                                         s[i]++;                           
                                                         return                                           s;                           
                                                         }                           
                                         
                                                         // if 'z', change it to 'a'                           
                                                         s[i] =                                           'a'                                           ;                           
                                                         }                           
                             }                           
             
                             // Driver Code                           
                             int                                           main()                           
                             {                           
                                                         string S =                                           "abcdeg"                                           , T =                                           "abcfgh"                                           ;                           
                                                         int                                           n = S.length();                           
                                                         string res = lexNext(S, n);                           
             
                                                         // If not equal, print the                           
                                                         // resultant string                           
                                                         if                                           (res != T)                           
                                                         cout << res << endl;                           
                                                         else                           
                                                         cout <<                                           "-1"                                           << endl;                           
                                                         return                                           0;                           
                             }                           

JAVA

                             //Java program to find the string                           
                             // in lexicographic order which is                           
                             // in between given two strings                           
             
                             class                                           GFG {                           
             
                             // Function to find the lexicographically                           
                             // next string                           
                                                         static                                           String lexNext(String str,                                           int                                           n) {                           
                                                         char                                           [] s = str.toCharArray();                           
                                                         // Iterate from last character                           
                                                         for                                           (                                           int                                           i = n -                                           1                                           ; i >=                                           0                                           ; i--) {                           
                                                         // If not 'z', increase by one                           
                                                         if                                           (s[i] !=                                           'z'                                           ) {                           
                                                         s[i]++;                           
                                                         return                                           String.valueOf(s);                           
                                                         }                           
             
                                                         // if 'z', change it to 'a'                           
                                                         s[i] =                                           'a'                                           ;                           
                                                         }                           
                                                         return                                           null                                           ;                           
                                                         }                           
             
                             // Driver Code                           
                                                         static                                           public                                           void                                           main(String[] args) {                           
                                                         String S =                                           "abcdeg"                                           , T =                                           "abcfgh"                                           ;                           
                                                         int                                           n = S.length();                           
                                                         String res = lexNext(S, n);                           
             
                                                         // If not equal, print the                           
                                                         // resultant string                           
                                                         if                                           (res != T) {                           
                                                         System.out.println(res);                           
                                                         }                                           else                                           {                           
                                                         System.out.println(                                           "-1"                                           );                           
                                                         }                           
                                                         }                           
                             }                           
             
                             // This code is contributed by 29AjayKumar                           

Python3

                             # Python3 program to find the string                           
                             # in lexicographic order which is                           
                             # in between given two strings                           
             
                             # Function to find the lexicographically                           
                             # next string                           
                             def                                           lexNext(s, n):                           
             
                                                         # Iterate from last character                           
                                                         for                                           i                                           in                                           range                                           (n                                           -                                           1                                           ,                                           -                                           1                                           ,                                           -                                           1                                           ):                           
             
                                                         # If not 'z', increase by one                           
                                                         if                                           s[i] !                                           =                                           'z'                                           :                           
                                                         k                                           =                                           ord                                           (s[i])                           
                                                         s[i]                                           =                                           chr                                           (k                                           +                                           1                                           )                           
                                                         return                                           ''.join(s)                           
             
                                                         # if 'z', change it to 'a'                           
                                                         s[i]                                           =                                           'a'                           
             
                             # Driver Code                           
                             if                                           __name__                                           =                                           =                                           "__main__"                                           :                           
                                                         S                                           =                                           "abcdeg"                           
                                                         T                                           =                                           "abcfgh"                           
                                                         n                                           =                                           len                                           (S)                           
             
                                                         S                                           =                                           list                                           (S)                           
                                                         res                                           =                                           lexNext(S, n)                           
             
                                                         # If not equal, print the                           
                                                         # resultant string                           
                                                         if                                           res !                                           =                                           T:                           
                                                         print                                           (res)                           
                                                         else                                           :                           
                                                         print                                           (                                           -                                           1                                           )                           
             
                             # This code is contributed by                           
                             # sanjeev2552                           

C#

                             //C# program to find the string                           
                             // in lexicographic order which is                           
                             // in between given two strings                           
                             using                                           System;                           
             
                             public                                           class                                           GFG {                           
                                         
                             // Function to find the lexicographically                           
                             // next string                           
                                                         static                                           String lexNext(String str,                                           int                                           n) {                           
                                                         char                                           [] s = str.ToCharArray();                           
                                                         // Iterate from last character                           
                                                         for                                           (                                           int                                           i = n - 1; i >= 0; i--) {                           
                                                         // If not 'z', increase by one                           
                                                         if                                           (s[i] !=                                           'z'                                           ) {                           
                                                         s[i]++;                           
                                                         return                                           new                                           String(s);                           
                                                         }                           
                                         
                                                         // if 'z', change it to 'a'                           
                                                         s[i] =                                           'a'                                           ;                           
                                                         }                           
                                                         return                                           null                                           ;                           
                                                         }                           
                                         
                             // Driver Code                           
                                                         static                                           public                                           void                                           Main() {                           
                                                         String S =                                           "abcdeg"                                           , T =                                           "abcfgh"                                           ;                           
                                                         int                                           n = S.Length;                           
                                                         String res = lexNext(S, n);                           
                                         
                                                         // If not equal, print the                           
                                                         // resultant string                           
                                                         if                                           (res != T) {                           
                                                         Console.Write(res);                           
                                                         }                                           else                                           {                           
                                                         Console.Write(                                           "-1"                                           );                           
                                                         }                           
                                                         }                           
                             }                           
                                         
                             // This code is contributed by 29AjayKumar                           

Javascript

                             <script>                           
             
                             // JavaScript program to find the string                           
                             // in lexicographic order which is                           
                             // in between given two strings                           
             
                             // Function to find the lexicographically                           
                             // next string                           
                             function                                           lexNext( s, n){                           
                                                         // Iterate from last character                           
                                                         for                                           (let i = n - 1; i >= 0; i--)                           
                                                         {                           
                                                         // If not 'z', increase by one                           
                                                         if                                           (s[i] !=                                           'z'                                           )                           
                                                         {                           
                                                         let code = s.charCodeAt(i)+1;                           
                                                         let str = String.fromCharCode(code);                           
                                                         return                                           s.substr(0,i)+str+s.substr(i+1);                           
             
                                                         }                           
                                         
                                                         // if 'z', change it to 'a'                           
                                                         s[i] =                                           'a'                                           ;                           
                                                         }                           
                                         
                             }                           
             
                             // Driver Code                           
                             let S =                                           "abcdeg"                                           ;                           
                             let T =                                           "abcfgh"                                           ;                           
                             let n = S.length;                           
                             let res = lexNext(S, n);                           
             
                             // If not equal, print the                           
                             // resultant string                           
                             if                                           (res != T)                           
                                                         document.write( res,                                           '<br>'                                           );                           
                                                         else                           
                                                         document.write(                                           "-1 <br>"                                           );                           
                                         
                             </script>                           

输出：

abcdeh

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章