查找字符串中的最长长度数字-yiteyi-C++库

给定一组数字和字符。编写一个程序来查找字符串中最大位数的数字。注：该数字可能不是字符串中的最大数字。例如，如果字符串是“a123bc321”，那么答案可以是123或321，因为问题是找到长度最长而不是最大值的数字。 例如：

null

Input: geeks100for1234geeksOutput: 1234Input: abx12321bst1234yzOutput: 12321

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

方法： 其思想是遍历字符串，如果遇到一个数字，则存储其位置，并从该位置进一步遍历，直到出现一个字符。每次遇到一个连续的数字序列时，存储其长度，并将其与之前的“查找一个数字序列”的长度匹配，以找出所有连续数字序列的最大值。下面是上述方法的实现。

C++

                         // C++ code for finding the longest                       
                         // length integer                       
                         #include <iostream>                       
                         using                                     namespace                                     std;                       
           
                         string longestInteger(string str,                                     int                                     l)                       
                         {                       
                                                 int                                     count = 0, max = 0, pos = -1, pre_pos, pre_len, len = 0;                       
                                                 // Traverse the string                       
                                                 for                                     (                                     int                                     i = 0; i < l; i++) {                       
                                                 // Store the previous position and previous length                       
                                                 // of the digits encountered.                       
                                                 pre_pos = pos;                       
                                                 pre_len = len;                       
                                                 count = 0;                       
                                                 len = 0;                       
           
                                                 // If first digit occurs, store its position in pos                       
                                                 if                                     (                                     isdigit                                     (str[i]))                       
                                                 pos = i;                       
           
                                                 // Traverse the string till a character occurs.                       
                                                 while                                     (                                     isdigit                                     (str[i])) {                       
                                                 count++;                       
                                                 i++;                       
                                                 len++;                       
                                                 }                       
           
                                                 // Check if the length of the string is                       
                                                 // greater than the previous ones or not.                       
                                                 if                                     (count > max) {                       
                                                 max = count;                       
                                                 }                       
                                                 else                                     {                       
                                                 pos = pre_pos;                       
                                                 len = pre_len;                       
                                                 }                       
                                                 }                       
                                                 return                                     (str.substr(pos, len));                       
                         }                       
           
                         // Driver code                       
                         int                                     main()                       
                         {                       
                                                 string str =                                     "geeks100for1234geeks"                                     ;                       
                                                 int                                     l = str.length();                       
                                                 cout << longestInteger(str, l);                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java code for finding the                       
                         // longest length integer                       
                         import                                     java.io.*;                       
                         import                                     java.util.*;                       
                         import                                     java.lang.*;                       
           
                         class                                     GFG                       
                         {                       
                         static                                     String longestInteger(String str,                                     int                                     l)                       
                         {                       
                                                 int                                     count =                                     0                                     , max =                                     0                                     ,                       
                                                 pos = -                                     1                                     , pre_pos,                       
                                                 pre_len, len =                                     0                                     ;                       
                                   
                                                 // Traverse the string                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < l; i++)                       
                                                 {                       
                                                 // Store the previous position                       
                                                 // and previous length of the                       
                                                 // digits encountered.                       
                                                 pre_pos = pos;                       
                                                 pre_len = len;                       
                                                 count =                                     0                                     ;                       
                                                 len =                                     0                                     ;                       
           
                                                 // If first digit occurs,                       
                                                 // store its position in pos                       
                                                 if                                     (Character.isDigit(str.charAt(i)))                       
                                                 pos = i;                       
           
                                                 // Traverse the string                       
                                                 // till a character occurs.                       
                                                 while                                     (Character.isDigit(str.charAt(i)))                       
                                                 {                       
                                                 count++;                       
                                                 i++;                       
                                                 len++;                       
                                                 }                       
           
                                                 // Check if the length of                       
                                                 // the string is greater                       
                                                 // than the previous ones                       
                                                 // or not.                       
                                                 if                                     (count > max)                       
                                                 {                       
                                                 max = count;                       
                                                 }                       
                                                 else                       
                                                 {                       
                                                 pos = pre_pos;                       
                                                 len = pre_len;                       
                                                 }                       
                                                 }                       
                                                 return                                     (str.substring(pos, pos + len));                       
                         }                       
           
                         // Driver code                       
                         public                                     static                                     void                                     main(String[] args)                       
                         {                       
                                                 String str =                                     "geeks100for1234geeks"                                     ;                       
                                                 int                                     l = str.length();                       
                                                 System.out.print(longestInteger(str, l));                       
                         }                       
                         }                       

C#

                         // C# code for finding the                       
                         // longest length integer                       
                         using                                     System;                       
           
                         class                                     GFG                       
                         {                       
                         static                                     string                                     longestInteger(                                     string                                     str,                       
                                                 int                                     l)                       
                         {                       
                                                 int                                     count = 0, max = 0,                       
                                                 pos = -1, pre_pos,                       
                                                 pre_len, len = 0;                       
                                   
                                                 // Traverse the string                       
                                                 for                                     (                                     int                                     i = 0; i < l; i++)                       
                                                 {                       
                                                 // Store the previous position                       
                                                 // and previous length of the                       
                                                 // digits encountered.                       
                                                 pre_pos = pos;                       
                                                 pre_len = len;                       
                                                 count = 0;                       
                                                 len = 0;                       
           
                                                 // If first digit occurs,                       
                                                 // store its position in pos                       
                                                 if                                     (Char.IsDigit(str[i]))                       
                                                 pos = i;                       
           
                                                 // Traverse the string                       
                                                 // till a character occurs.                       
                                                 while                                     (Char.IsDigit(str[i]))                       
                                                 {                       
                                                 count++;                       
                                                 i++;                       
                                                 len++;                       
                                                 }                       
           
                                                 // Check if the length of                       
                                                 // the string is greater                       
                                                 // than the previous ones                       
                                                 // or not.                       
                                                 if                                     (count > max)                       
                                                 {                       
                                                 max = count;                       
                                                 }                       
                                                 else                       
                                                 {                       
                                                 pos = pre_pos;                       
                                                 len = pre_len;                       
                                                 }                       
                                                 }                       
                                                 return                                     (str.Substring(pos, len));                       
                         }                       
           
                         // Driver code                       
                         public                                     static                                     void                                     Main()                       
                         {                       
                                                 string                                     str =                                     "geeks100for1234geeks"                                     ;                       
                                                 int                                     l = str.Length;                       
                                                 Console.Write(longestInteger(str, l));                       
                         }                       
                         }                       
           
                         // This code is contributed                       
                         // by ChitraNayal                       

Python 3

                         # Python 3 code for finding the                       
                         # longest length integer                       
           
                         def                                     longestInteger(s, length):                       
                                                 count                                     =                                     0                       
                                                 maximum                                     =                                     0                       
                                                 pos                                     =                                     -                                     1                       
                                                 l                                     =                                     0                       
                                   
                                                 # Traverse the string                       
                                                 for                                     i                                     in                                     range                                     (length):                       
                                   
                                                 # Store the previous position                       
                                                 # and previous length of                       
                                                 # the digits encountered.                       
                                                 pre_pos                                     =                                     pos                       
                                                 pre_len                                     =                                     l                       
                                                 count                                     =                                     0                       
                                                 l                                     =                                     0                       
           
                                                 # If first digit occurs,                       
                                                 # store its position in pos                       
                                                 if                                     (s[i].isdecimal()):                       
                                                 pos                                     =                                     i                       
           
                                                 # Traverse the string                       
                                                 # till a character occurs.                       
                                                 while                                     (s[i].isdecimal()):                       
                                                 count                                     +                                     =                                     1                       
                                                 i                                     +                                     =                                     1                       
                                                 l                                     +                                     =                                     1                       
           
                                                 # Check if the length of                       
                                                 # the string is greater                       
                                                 # than the previous ones                       
                                                 # or not.                       
                                                 if                                     (count > maximum):                       
                                                 maximum                                     =                                     count                       
                                   
                                                 else                                     :                       
                                                 pos                                     =                                     pre_pos                       
                                                 l                                     =                                     pre_len                       
           
                                                 return                                     (s[pos: pos                                     +                                     l])                       
           
                         # Driver code                       
                         s                                     =                                     "geeks100for1234geeks"                       
                         length                                     =                                     len                                     (s)                       
                         print                                     (longestInteger(s, length))                       
           
                         # This code is contributed                       
                         # by ChitraNayal                       

PHP

                         <?php                       
                         // PHP code for finding the                       
                         // longest length integer                       
           
                         function                                     longestInteger(                                     $str                                     ,                                     $l                                     )                       
                         {                       
                                                 $count                                     = 0;                       
                                                 $max                                     = 0;                       
                                                 $pos                                     = -1;                       
                                                 $pre_pos                                     = 0;                       
                                                 $pre_len                                     = 0;                       
                                                 $len                                     = 0;                       
                                   
                                                 // Traverse the string                       
                                                 for                                     (                                     $i                                     = 0;                                     $i                                     <                                     $l                                     ;                                     $i                                     ++)                       
                                                 {                       
                                                 // Store the previous position                       
                                                 // and previous length of                       
                                                 // the digits encountered.                       
                                                 $pre_pos                                     =                                     $pos                                     ;                       
                                                 $pre_len                                     =                                     $len                                     ;                       
                                                 $count                                     = 0;                       
                                                 $len                                     = 0;                       
           
                                                 // If first digit occurs,                       
                                                 // store its position in pos                       
                                                 if                                     (                                     is_numeric                                     (                                     $str                                     [                                     $i                                     ]))                       
                                                 $pos                                     =                                     $i                                     ;                       
           
                                                 // Traverse the string till                       
                                                 // a character occurs.                       
                                                 while                                     (                                     is_numeric                                     (                                     $str                                     [                                     $i                                     ]))                       
                                                 {                       
                                                 $count                                     ++;                       
                                                 $i                                     ++;                       
                                                 $len                                     ++;                       
                                                 }                       
           
                                                 // Check if the length of                       
                                                 // the string is greater                       
                                                 // than the previous ones                       
                                                 // or not.                       
                                                 if                                     (                                     $count                                     >                                     $max                                     )                       
                                                 {                       
                                                 $max                                     =                                     $count                                     ;                       
                                                 }                       
                                                 else                       
                                                 {                       
                                                 $pos                                     =                                     $pre_pos                                     ;                       
                                                 $len                                     =                                     $pre_len                                     ;                       
                                                 }                       
                                                 }                       
                                                 return                                     (                                     substr                                     (                                     $str                                     ,                                     $pos                                     ,                                     $len                                     ));                       
                         }                       
           
                         // Driver code                       
                         $str                                     =                                     "geeks100for1234geeks"                                     ;                       
                         $l                                     =                                     strlen                                     (                                     $str                                     );                       
                         echo                                     longestInteger(                                     $str                                     ,                                     $l                                     );                       
           
                         // This code is contributed                       
                         // by ChitraNayal                       
                         ?>                       

Javascript

                         <script>                       
                         // Javascript code for finding the                       
                         // longest length integer                       
                                   
                                                 function                                     longestInteger(str,l)                       
                                                 {                       
                                                 let count = 0, max = 0,                       
                                                 pos = -1, pre_pos,                       
                                                 pre_len, len = 0;                       
                                   
                                                 // Traverse the string                       
                                                 for                                     (let i = 0; i < l; i++)                       
                                                 {                       
                                                 // Store the previous position                       
                                                 // and previous length of the                       
                                                 // digits encountered.                       
                                                 pre_pos = pos;                       
                                                 pre_len = len;                       
                                                 count = 0;                       
                                                 len = 0;                       
                                   
                                                 // If first digit occurs,                       
                                                 // store its position in pos                       
                                                 if                                     (!isNaN(String(str[i]) * 1))                       
                                                 pos = i;                       
                                   
                                                 // Traverse the string                       
                                                 // till a character occurs.                       
                                                 while                                     (!isNaN(String(str[i]) * 1))                       
                                                 {                       
                                                 count++;                       
                                                 i++;                       
                                                 len++;                       
                                                 }                       
                                   
                                                 // Check if the length of                       
                                                 // the string is greater                       
                                                 // than the previous ones                       
                                                 // or not.                       
                                                 if                                     (count > max)                       
                                                 {                       
                                                 max = count;                       
                                                 }                       
                                                 else                       
                                                 {                       
                                                 pos = pre_pos;                       
                                                 len = pre_len;                       
                                                 }                       
                                                 }                       
                                                 return                                     (str.substring(pos, pos + len));                       
                                                 }                       
                                   
                                                 // Driver code                       
                                                 let str =                                     "geeks100for1234geeks"                                     ;                       
                                                 let l = str.length;                       
                                                 document.write(longestInteger(str, l));                       
                                   
           
                         // This code is contributed by rag2127                       
                         </script>                       

输出：

时间复杂性： O（n） 辅助空间复杂性： O（1）

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

THE END

技术文章