Question

我想知道我的字符串中的数字是否按升序排列，如果它们的顺序递增，我们需要打印TRUE，否则如果它们不按递增顺序排列，我们需要打印FALSE。

*重要提示：在没有数字的字符串中没有空格＆＃34; 字符串序列是：

CASE 1 :1234   (Easy)      1 <2<3<4  TRUE
CASE 2 :9101112 (Medium)   9<10<11<12 TRUE
CASE 3 :9991000  (Hard)     999<1000  TRUE
CASE 4 :10203    (Easy)     1<02<03   FALSE (numbers cannot have 0 separated).

// converting string into array of numbers
String[] str = s.split("");
int[] numbers = new int[str.length];
int i = 0;

for (String a : str) {
    numbers[i] = Integer.parseInt(a.trim());
    i++;
}
for(int j=0;j<str.length;j++)
     System.out.print(numbers[j]+" ");

//to verify whether they differ by 1 or not
int flag=0;

for(int j=0;j<numbers.length-1;j++){
    int result=Integer.parseInt(numbers[j]+""+numbers[j+1]) ;

    if(numbers[j]>=0 && numbers[j]<=8 && numbers[j+1]==numbers[j]+1){   
    flag=1;
    }
    else if(numbers[j]==9){
    int res=Integer.parseInt(numbers[j+1]+""+numbers[j+2]) ;
            if(res==numbers[j]+1)
            flag=1;
    }
    else if(result>9){

}
}
}
`

这是我现在写的代码，但是我无法理解如何执行大于1的数字，如99或999。你能告诉我如何执行这个或任何其他最佳方法来解决这个问题吗？

由于 Aastha Jain

Answer 1

我将为您描述解决方案，但您必须编写代码。

您知道输入字符串是一个数字递增的序列，但您不知道第一个数字中有多少位数。

这意味着您首先要假设它是1位数。如果失败，则尝试2位数，然后是3位，依此类推，直到您尝试了整个输入长度的一半。你停在一半，因为超过一半的东西不能跟随下一个号码。

如果你的外循环，尝试从1开始的第一个数字的长度。

在循环中，使用substring(begin, end)提取第一个数字，并使用Integer.parseInt(s)将其解析为数字。这是序列的第一个数字。

然后启动另一个（内部）循环，逐个递增该数字，使用Integer.toString(i)将数字格式化为文本，并检查输入的下N个字符（使用{{1}提取}）火柴。如果它不匹配，则退出内循环，使外循环尝试下一个较大的初始数。

如果所有增加的数字与输入字符串的长度完全匹配，则表示您找到了一个好的序列。

Answer 2

这是Andreas建议的伪代码的代码。谢谢你的帮助。

       for (int a0 = 0; a0 < q; a0++) {
            String s = in.next();

            boolean flag = true;

            for (int i = 1; i < s.length() / 2; i++) {
                int first = Integer.parseInt(s.substring(0, i));
                            int k=1;
                for (int j = i; j < s.length(); j++) {
                 if (Integer.toString(first + (k++)).equals(s.substring(j, j + i)))
               flag = true;
                else{
                    flag=false;
                    break;
                }    
            }

            if (flag)
                System.out.println("YES");
            else
                System.out.println("NO");

        }

Answer 3

我建议以下解决方案。此代码生成输入序列的所有子字符串，根据它们的起始索引对它们进行排序，然后检查是否存在从起始索引到结束索引的路径，在该索引上出现的所有数字都是有序的。但是，我注意到您的示例中存在错误（我猜？）：10203也应该评估为true，因为10<203。

import java.util.*;
import java.util.stream.Collectors;

public class PlayGround {


    private static class Entry {

        public Entry(int sidx, int eidx, int val) {
            this.sidx = sidx;
            this.eidx = eidx;
            this.val = val;
        }

        public int sidx = 0;
        public int eidx = 0;
        public int val = 0;

        @Override
        public String toString(){
            return String.valueOf(this.val);
        }
    }

    public static void main(String[] args) {
        assert(check("1234"));
        assert(check("9101112"));
        assert(check("9991000"));
        assert(check("10203"));
    }

    private static boolean check(String seq) {

        TreeMap<Integer,Set<Entry>> em = new TreeMap();


        // compute all substrings of seq and put them into tree map
        for(int i = 0; i < seq.length(); i++) {
            for(int k = 1 ; k <= seq.length()-i; k++) {
                String s = seq.substring(i,i+k);

                if(s.startsWith("0")){
                    continue;
                }

                if(!em.containsKey(i))
                    em.put(i, new HashSet<>());

                Entry e = new Entry(i, i+k, Integer.parseInt(s));
                em.get(i).add(e);
            }
        }


        if(em.size() <= 1)
            return false;


        Map.Entry<Integer,Set<Entry>> first = em.entrySet().iterator().next();

        LinkedList<Entry> wlist = new LinkedList<>();

        wlist.addAll(first.getValue().stream().filter(e -> e.eidx < seq
                .length()).collect(Collectors.toSet()));


        while(!wlist.isEmpty()) {
            Entry e = wlist.pop();

            if(e.eidx == seq.length()) {
                return true;
            }

            int nidx = e.eidx + 1;

            if(!em.containsKey(nidx))
                continue;

            wlist.addAll(em.get(nidx).stream().filter(n -> n.val > e.val).collect
                    (Collectors.toSet()));
        }

        return false;
    }
}

Answer 4

假设输入的字符串用空格分隔，那么下面的代码如下，因为如果数字输入为整数，我们无法区分。

boolean increasing = true;
String string = "1 7 3 4"; // CHANGE NUMBERS
String strNumbers[] = string.split(" "); // separate by spaces.


for(int i = 0; i < strNumbers.length - 1; i++) {

  // if current number is greater than the next number.
  if(Integer.parseInt(strNumbers[i]) > Integer.parseInt(strNumbers[i + 1])) {
    increasing = false;
    break; // exit loop
  }
}

if(increasing) System.out.println("TRUE");
else System.out.println("FALSE");

增加字符串java中的数字序列

4 个答案: