Question

程序应该提供最长的升序。

所以，例如，如果我输入“12134707”，它应该给出输出= 1347但是它给出12 ...这绝对不是最长的。我错过了什么或做错了什么？

import java.util.Scanner;        
public class Ascending
{

public static void main(String args[]){

    System.out.print("Enter a number = ");

    Scanner in = new Scanner(System.in);
    String n = in.nextLine();

    //print soluton
    System.out.println("output = " + itsAscending(n));
}

public static String itsAscending(String n) {
    int length = n.length(); 

    String maxlongest = "";


    for(int i = 1; i < length; i++) {

        char first = n.charAt(i-1); 
        char second = n.charAt(i);      
        char next = n.charAt(i+1);
        int f = (int)(first - 48);      
        int s = (int)(second - 48);     
        int nx = (int)(next - 48);

        String longest = "";

        int max = 0;


        //test to find the ascending order
        if (f<s){

            longest = longest + f;

            if(n.length()>2){

                if(f<s){
                    longest = longest + s;
                    length = longest.length();
                    i++;
                }
                else{
                    i++; 
                    continue;
                }
            }

            //test to find the longest string
            for (i=1; i<length; i++){
                if (length > max){
                    max = length;
                    maxlongest = longest;
                    return maxlongest;
                }
                else {
                    return maxlongest;
                }
            }
        }
    }
    return maxlongest;
 }
}

Answer 1

嘿，你搞砸了代码＆amp;许多地方的逻辑。您正在与for循环中的长度变量进行比较并对其进行修改。你的第二个循环也在第一个循环中。我认为这是一个错误。重新开始你的逻辑和变量再次..你的长度变量＆amp; i变量用于多个地方，而应使用相同的腼腆。

P.S：我知道它的硬件任务：D

Answer 2

我建议您通过将功能分成不同的功能来简化代码：

解析字符串：

public static int[] parseString(String str) {
    int[] result = new int[str.length];
    for (int i = 0; i < str.length; i++) {
        result[i] = (int)(str.charAt(i) - 48);
    }
    return result;
}

解决问题：

public static String solve(String str) {
    int[] a = parseString(str);
    int length = 1;
    int maxStart = 0;
    int start = 0;
    for (int i = 1; i < a.length; a++) {
        if (a[i] <= a[i-1]) {
            if (length < (start - i)) {
                length = start - i;
                maxStart = start;
            }
            start = i;
        }
    }
    return str.substring(maxStart, maxStart+length);
}

这只适用于非空字符串，但我认为你可以自己解决这个问题......

Answer 3

在第二个循环中：

    //test to find the longest string
    for (i=1; i<length; i++){
        if (length > max){
            max = length;
            maxlongest = longest;
            return maxlongest;
        }
        else {
            return maxlongest;
        }
    }`

if将执行或else将执行，但在两种情况下都会return。所以你的第二个for循环不会执行多次，也会导致终止第一个循环你可以删除第二个循环并在其中返回语句并且没有理由再次检查if(f<s)。

Answer 4

试试这个：

import java.util.Scanner;


public class Ascending {

/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner scanner = new Scanner ( System.in) ;
    String s = scanner.nextLine();
    String res = getAsc(s);
    System.out.println(res);

}

private static String getAsc (String n) {
    String tmp="" , org="" ;
    char cf,cs;
    int f,s ;
    for (int i=1;i < n.length(); i++) {
        cf = n.charAt(i-1);
        cs = n.charAt(i);
        f = (int) (cf - 48);
        s = (int) (cs - 48 ) ;
        if (f  < s ) {
            tmp += cf ;
        }
        else {
            tmp += cf;
            if (tmp.length() > org.length()) {
                org = tmp ;
            }
            tmp = "";
        }
    }

    return org;
}

}

Answer 5

我建议使用列表，以便更容易跟踪最大和临时字符串。

public static String itsAscending(String n) {
    List<Integer> maxLongest = new ArrayList<Integer>();
    List<Integer> tempLongest = new ArrayList<Integer>();

    for(int i = 0; i < n.length(); i++) {
        int digit = (int)(n.charAt(i) - 48);             
        if (tempLongest.size() > 0 && digit < tempLongest.get(tempLongest.size() - 1)) {
            tempLongest.clear();
        }
        tempLongest.add(digit);
        if (tempLongest.size() > maxLongest.size()) {
            maxLongest.clear();
            maxLongest.addAll(tempLongest);
        }
    }
    String returnString = "";
    for (int digit : maxLongest){ 
        returnString += digit;
    }
    return returnString;
}

Answer 6

一些注意事项：

您不需要将字符转换为字符：字符可比;
您不需要将整数表达式转换为int;
你的“测试找到最长的字符串”循环似乎毫无意义：你在第一次迭代中无条件返回;
朝第一个循环的底部无条件地增加i;这应该发生在if声明之外;
您拥有不在任何地方使用的next变量;
您的length变量是多余的：它只是longest字符串的长度。

由于所有这些问题，从头开始比尝试在代码中找到可以更改以使其工作的单个点更容易。所以这就是我得到的：

static String in;
public static void main(String args[]) {
  System.out.print("Enter a number = ");
  in = new Scanner(System.in).nextLine();
  System.out.println("output = " + longestAscending(0, ""));
}
static String longestAscending(int start, String longest) {
  if (start >= in.length()) return longest;
  int prev, i;
  for (i = start, prev = 0; i < in.length() && in.charAt(i) > prev; 
       prev = in.charAt(i++));
  return longestAscending(i,
          i - start > longest.length()? in.substring(start, i) : longest);
}

Answer 7

一个类似的问题和我的解决方案。该解决方案也可以适用于解决OP解决方案

字母数字字符串中最长的升序序列编码问题：

想象您正在工作，并且被赋予编写一个将在我们的一种产品中使用的功能的任务。

第1部分）用您选择的编程语言（您应该在答案中命名），编写一个函数，该函数将文本字符串作为其单个输入并返回一个整数，该整数是最长的升序数字序列的长度在字符串中找到。任何非数字字符都将终止数字序列，但否则应忽略。

第2部分）您想要使用哪些测试用例来测试您的功能，以证明其正常工作？为什么？给出测试输入字符串和预期输出的具体示例。

例如：

如果输入字符串为“ 5123a4”，则输出整数应为3，因为序列“ 123”是最长的升序序列，长度为3。

如果输入字符串为“ bb54324687cc”，则输出整数应为4，因为序列“ 2468”是最长的升序序列，长度为4。

打包com.company;

    import java.util.Hashtable;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Scanner;

公共类主要{

public static void main(String[] args) {
    // write your code here
    System.out.print("Enter a number = ");

    Scanner in = new Scanner(System.in);
    String n = in.nextLine();
    System.out.println("n = "+n);
    longestAscending(n);

    //n = "bb54324687cc";



}
public static Hashtable<String,Integer>longestAscending(String n) {
    Hashtable<String,Integer> h= new Hashtable<String, Integer>() ;
    String tempMax ="";
    int lenghtString=0;
    System.out.println("n.length()-1="+(n.length()-1));
    // int digit = 0;
    for (int i=0; i<=n.length()-2;i++)
    {
        int homePositionDigit = (int)(n.charAt(i) - 48);
        int neighbourPositionDigit = (int)(n.charAt(i+1) - 48);

        System.out.print(" i = "+i +"  homePositionDigit ="+(n.charAt(i)-48));
        System.out.println("  neighbourPositionDigit ="+(n.charAt(i+1)-48));

        if ((homePositionDigit <=9 )&& (neighbourPositionDigit<=9))
        {
            if (n.charAt(i)<n.charAt(i+1))
            {
                tempMax=tempMax+n.charAt(i);
                lenghtString=tempMax.length();
                h.put(tempMax,lenghtString);
                System.out.println("hash table h="+h);

            }

        }
        else
        if ((homePositionDigit>9)&&(tempMax!="")&&((n.charAt(i-1)-48)<=9))
        {
            tempMax=tempMax+n.charAt(i-1);
            lenghtString=tempMax.length();
            h.put(tempMax,lenghtString);
            tempMax="";
            lenghtString=0;

        }
    }

    System.out.println("hash table h="+h);
    Iterator<Map.Entry<String,Integer>> it = h.entrySet().iterator();
    int kontor=0,max=0 ;
    while (it.hasNext()) {
        Map.Entry<String,Integer> entry = it.next();
        if (kontor==0)
            max=entry.getValue();
        System.out.println("max este = "+max+" entry.getValue()= "+entry.getValue());


        if (entry.getValue() > max   ) {
            max=entry.getValue();
        }
        kontor++;
    }
    System.out.println("max este "+max);
    System.out.println("hash table este "+h);

    it=h.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<String,Integer> entry = it.next();
        if (max==entry.getValue()) {
            System.out.println("the longest sequence of ascending digits in a  String is   = " + entry.getKey()+" and has the lenght of= "+max );
        }
    }
    return h;

}

}

在字符串中查找最长的升序序列

7 个答案: