Увеличение последовательности номеров в строке java

Question

Я хочу найти, будут ли цифры в моей строке в порядке возрастания, и если они в порядке возрастания, нам нужно напечатать TRUE else, если они не в порядке возрастания, нам нужно распечатать FALSE ,

* ВАЖНО: ЕСТЬ НЕТ МЕСТА В STRING, которые ЧИСЛА» Последовательность Строка являются:

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

предполагало введенная строка отделяется пробелами, т Ниже приведен следующий код, потому что мы не можем сказать разницу, если номер введен как целое число.

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

Answer 2

Я собираюсь описать решение для вас, но вам нужно написать код.

Вы знаете, что входная строка представляет собой последовательность возрастающих чисел, но вы не знаете, сколько цифр находится в первом номере.

Это означает, что вы начинаете с предположения, что это 1 цифра. Если это не удастся, вы попробуете 2 цифры, затем 3 и т. Д., Пока не попробуете половину всей длины ввода. Вы останавливаетесь наполовину, потому что больше половины не может иметь следующий номер после него.

Это, если ваш внешний контур, используя длину первого номера от 1 и выше.

В цикле вы извлекаете первый номер, используя substring(begin, end), и анализируйте его на число, используя Integer.parseInt(s). Это первый номер последовательности.

Затем вы запускаете другой (внутренний) цикл, увеличивая это число на единицу за раз, форматируя число до текста с помощью Integer.toString(i) и проверяете соответствие следующих N символов ввода (извлеченных с использованием substring(begin, end)). Если это не соответствует, вы выходите из внутреннего цикла, чтобы сделать внешний цикл попыткой со следующим большим начальным номером.

Если все увеличивающиеся числа совпадают точно с длиной входной строки, вы нашли хорошую последовательность.

Answer 3

Это код для псевдокода, предложенный Андреасом. Спасибо за помощь.

 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 4

Я предлагаю следующее решение. Этот код генерирует все подстроки входной последовательности, заказывает их на основе их начального индекса, а затем проверяет, существует ли путь, который ведет от начального индекса до конечного индекса, по которому все упорядоченные числа упорядочены. Однако, я заметил ошибку (я думаю?) В вашем примере: 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; 
    } 
}