按字典顺序排列的中间字符串-yiteyi-C++库

给两个字符串 A. 和 B .我们的任务是打印大于 A. （按词典编纂）但小于 B （词典编纂）。如果无法获得这样的字符串，请打印-1；

null

例如：

Input : a = "abg", b = "abj"Output : abhThe string "abh" is lexicographically greater than "abg" and smaller than"abj"        Input : a = "abc", b = "abd"Output :-1There is no string which is lexicographicallygreater than a but smaller than b/

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

由于可以有多个字符串满足上述条件，我们将字符串“a”转换为 下一步是词典编纂 到“a”。

接下来，为了按字典顺序查找，我们开始向后遍历字符串，并将所有字母“z”转换为字母“a”。如果我们遇到任何不是“z”的字母，那么我们将其增加1，并且不会进行进一步的遍历。如果这个字符串不小于“b”，那么我们将打印-1，因为没有字符串可以满足上述条件。

例如，string a=“ddzzz”和string b=“deaao”。因此，从向后开始，我们将所有字母“z”转换为字母“a”，直到我们到达字母“d”（在本例中）。将“d”增加一（到“e”）并从循环中中断。所以，弦 A. 将变成“deaaa”，在词典编纂上大于“ddzzz”，小于“deaao”。

C++

                         // C++ program to implement above approach                       
                         #include <iostream>                       
                         using                                     namespace                                     std;                       
           
                         // function to find lexicographically mid                       
                         // string.                       
                         void                                     lexMiddle(string a, string b)                       
                         {                       
                                                 // converting string "a" into its                       
                                                 // lexicographically next string                       
                                                 for                                     (                                     int                                     i = a.length() - 1; i >= 0; i--) {                       
           
                                                 // converting all letter "z" to letter "a"                       
                                                 if                                     (a[i] ==                                     'z'                                     )                       
                                                 a[i] =                                     'a'                                     ;                       
                                                 else                                     {                       
           
                                                 // if letter other than "z" is                       
                                                 // encountered, increment it by one                       
                                                 // and break                       
                                                 a[i]++;                       
                                                 break                                     ;                       
                                                 }                       
                                                 }                       
           
                                                 // if this new string "a" is lexicographically                       
                                                 // smaller than b                       
                                                 if                                     (a < b)                       
                                                 cout << a;                       
                                                 else                       
                                                 cout << -1;                       
                         }                       
           
                         // Driver function                       
                         int                                     main()                       
                         {                       
                                                 string a =                                     "geeks"                                     , b =                                     "heeks"                                     ;                       
                                                 lexMiddle(a, b);                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java program to implement                       
                         // above approach                       
                         class                                     GFG                       
                         {                       
           
                         // function to find lexicographically                       
                         // mid String.                       
                         static                                     void                                     lexMiddle(String a, String b)                       
                         {                       
                                                 String new_String =                                     ""                                     ;                       
                                   
                                                 // converting String "a" into its                       
                                                 // lexicographically next String                       
                                                 for                                     (                                     int                                     i = a.length() -                                     1                                     ; i >=                                     0                                     ; i--)                       
                                                 {                       
           
                                                 // converting all letter                       
                                                 // "z" to letter "a"                       
                                                 if                                     (a.charAt(i) ==                                     'z'                                     )                       
                                                 new_String =                                     'a'                                     + new_String;                       
                                                 else                       
                                                 {                       
                                   
                                                 // if letter other than "z" is                       
                                                 // encountered, increment it by                       
                                                 // one and break                       
                                                 new_String = (                                     char                                     )(a.charAt(i) +                                     1                                     ) +                       
                                                 new_String;                       
                                   
                                                 //compose the remaining string                       
                                                 for                                     (                                     int                                     j = i -                                     1                                     ; j >=                                     0                                     ; j--)                       
                                                 new_String = a.charAt(j) + new_String;                       
                                   
                                                 break                                     ;                       
                                                 }                       
                                                 }                       
           
                                                 // if this new String new_String is                       
                                                 // lexicographically smaller than b                       
                                                 if                                     (new_String.compareTo(b) <                                     0                                     )                       
                                                 System.out.println(new_String);                       
                                                 else                       
                                                 System.out.println(-                                     1                                     );                       
                         }                       
           
                         // Driver Code                       
                         public                                     static                                     void                                     main(String args[])                       
                         {                       
                                                 String a =                                     "geeks"                                     , b =                                     "heeks"                                     ;                       
                                                 lexMiddle(a, b);                       
                         }                       
                         }                       
           
                         // This code is contributed                       
                         // by Arnab Kundu                       

Python3

                         # Python3 program to implement above approach                       
           
                         # function to find lexicographically mid                       
                         # string.                       
                         def                                     lexMiddle( a, b):                       
           
                                                 # converting string "a" into its                       
                                                 # lexicographically next string                       
                                                 for                                     i                                     in                                     range                                     (                                     len                                     (a)                                     -                                     1                                     ,                                     -                                     1                                     ,                                     -                                     1                                     ):                       
                                   
                                                 ans                                     =                                     []                       
                                                 # converting all letter "z" to letter "a"                       
                                                 if                                     (a[i]                                     =                                     =                                     'z'                                     ):                       
                                                 a[i]                                     =                                     'a'                       
                                                 else                                     :                       
           
                                                 # if letter other than "z" is                       
                                                 # encountered, increment it by one                       
                                                 # and break                       
                                                 a[i]                                     =                                     chr                                     (                                     ord                                     (a[i])                                     +                                     1                                     )                       
                                                 break                       
                                   
                                   
           
                                                 # if this new string "a" is lexicographically                       
                                                 # smaller than b                       
                                                 if                                     (a < b):                       
                                                 return                                     a                       
                                                 else                                     :                       
                                                 return                                     -                                     1                       
           
           
           
                         # Driver function                       
                         if                                     __name__                                     =                                     =                                     '__main__'                                     :                       
                                                 a                                     =                                     list                                     (                                     "geeks"                                     )                       
                                                 b                                     =                                     list                                     (                                     "heeks"                                     )                       
                                                 ans                                     =                                     lexMiddle(a, b)                       
                                                 ans                                     =                                     ''.join(                                     map                                     (                                     str                                     , ans))                       
                                                 print                                     (ans)                       
           
                         # this code is contributed by ash264                       

C#

                         // C# program to implement above approach                       
                         using                                     System;                       
           
                         class                                     GFG                       
                         {                       
           
                         // function to find lexicographically                       
                         // mid String.                       
                         static                                     void                                     lexMiddle(                                     string                                     a,                                     string                                     b)                       
                         {                       
                                                 string                                     new_String =                                     ""                                     ;                       
                                   
                                                 // converting String "a" into its                       
                                                 // lexicographically next String                       
                                                 for                                     (                                     int                                     i = a.Length - 1; i >= 0; i--)                       
                                                 {                       
           
                                                 // converting all letter                       
                                                 // "z" to letter "a"                       
                                                 if                                     (a[i] ==                                     'z'                                     )                       
                                                 new_String =                                     'a'                                     + new_String;                       
                                                 else                       
                                                 {                       
                                   
                                                 // if letter other than "z" is                       
                                                 // encountered, increment it by                       
                                                 // one and break                       
                                                 new_String = (                                     char                                     )(a[i] + 1) +                       
                                                 new_String;                       
                                   
                                                 //compose the remaining string                       
                                                 for                                     (                                     int                                     j = i - 1; j >= 0; j--)                       
                                                 new_String = a[j] + new_String;                       
                                   
                                                 break                                     ;                       
                                                 }                       
                                                 }                       
           
                                                 // if this new String new_String is                       
                                                 // lexicographically smaller than b                       
                                                 if                                     (new_String.CompareTo(b) < 0)                       
                                                 Console.Write(new_String);                       
                                                 else                       
                                                 Console.Write(-1);                       
                         }                       
           
                         // Driver Code                       
                         public                                     static                                     void                                     Main()                       
                         {                       
                                                 string                                     a =                                     "geeks"                                     , b =                                     "heeks"                                     ;                       
                                                 lexMiddle(a, b);                       
                         }                       
                         }                       
           
                         // This code is contributed by ita_c                       

Javascript

                         <script>                       
           
                         // Javascript program to implement                       
                         // above approach                       
                                   
                         // Function to find lexicographically                       
                         // mid String.                       
                         function                                     lexMiddle(a, b)                       
                         {                       
                                                 let new_String =                                     ""                                     ;                       
                                   
                                                 // Converting String "a" into its                       
                                                 // lexicographically next String                       
                                                 for                                     (let i = a.length - 1; i >= 0; i--)                       
                                                 {                       
                                   
                                                 // Converting all letter                       
                                                 // "z" to letter "a"                       
                                                 if                                     (a[i] ==                                     'z'                                     )                       
                                                 new_String =                                     'a'                                     + new_String;                       
                                                 else                       
                                                 {                       
                                   
                                                 // If letter other than "z" is                       
                                                 // encountered, increment it by                       
                                                 // one and break                       
                                                 new_String = String.fromCharCode(                       
                                                 a[i].charCodeAt(0) + 1) + new_String;                       
                                   
                                                 // Compose the remaining string                       
                                                 for                                     (let j = i - 1; j >= 0; j--)                       
                                                 new_String = a[j] + new_String;                       
                                   
                                                 break                                     ;                       
                                                 }                       
                                                 }                       
                                   
                                                 // If this new String new_String is                       
                                                 // lexicographically smaller than b                       
                                                 if                                     (new_String < (b))                       
                                                 document.write(new_String);                       
                                                 else                       
                                                 document.write(-1);                       
                         }                       
           
                         // Driver Code                       
                         let a =                                     "geeks"                                     , b =                                     "heeks"                                     ;                       
           
                         lexMiddle(a, b);                       
                                   
                         // This code is contributed by avanitrachhadiya2155                       
           
                         </script>                       

输出：

geekt

时间复杂性： O（n）其中n是字符串“a”的长度

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

THE END

技术文章