1

该程序应该给出最长的升序。

因此，例如，如果我输入“12134707”，它应该给出 output = 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;
 }
}
4

7 回答 7

0

尝试这个 ： 

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;
}

}

于 2013-03-18T08:57:36.680 回答
0

嘿，你在很多地方都搞乱了代码和逻辑。您正在与 for 循环中的长度变量进行比较并对其进行修改。您的第二个 for 循环也在第一个循环内。我认为这是一个错误。重新开始重新审视你的逻辑和变量。你的长度变量和 i 变量在多个地方使用，而不是应该使用相同的腼腆。

PS：我知道这是一个硬件任务：D

于 2013-03-18T08:47:58.037 回答
0

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

解析字符串：

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);
}

这仅适用于非空字符串，但我假设您可以自己修复...

于 2013-03-18T08:48:52.703 回答
0

我建议使用列表来更轻松地跟踪最大和临时字符串。

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;
}
于 2013-03-18T09:04:16.170 回答
0

在第二个循环中： 

    //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)再次检查。

于 2013-03-18T08:56:07.453 回答
0

一些注意事项：

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

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

public static void main(String[] args) {
    System.out.print("Enter a number = ");
    String in = new Scanner(System.in).nextLine();
    System.out.println("output = " + longestAscending(in));
}

static String longestAscending(String in) {
    int startOfLongest = 0;
    int endOfLongest = 0;
    for (int start = 0; start < in.length();) {
        int end = start;
        for (int prevChar = -1;
             end < in.length() && in.charAt(end) > prevChar;
             prevChar = in.charAt(end), end++)
        { }
        if (end - start > endOfLongest - startOfLongest) {
            startOfLongest = start;
            endOfLongest = end;
        }
        start = end;
    }
    return in.substring(startOfLongest, endOfLongest);
}
于 2013-03-18T09:07:35.037 回答
0

有点类似的问题和我的解决方案。这个解决方案也可以适应解决 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;

}

}

于 2019-09-13T13:25:15.023 回答