Java - номер в развернутом виде

Ответ 1

Вы должны добавить '0 к str[i], а не str[j]:

  for(int i = 0; i < str.length-1; i++) {
    if(Integer.valueOf(str[i]) > 0) {
      for(int j = i; j < str.length-1; j++) {
        str[i] += '0';
      }
    }
  }

Это приведет к:

70000 + 0 + 300 + 0 + 4

Вам все равно придется избавиться от 0 цифр.

Один из возможных способов избавиться от них:

result = result.substring(1, result.length()-1).replace(", 0","").replace(",", " +");

Теперь выход

70000 + 300 + 4

Ответ 2

Псевдокод использует целочисленную арифметику для извлечения десятичных цифр один за другим (с правой):

mul = 1    //will contain power of 10
while (num > 0):
     dig = num % 10    //integer modulo retrieves the last digit
     if (dig > 0):   //filter out zero summands
          add (dig * mul) to output   //like 3 * 100 = 300
     num = num / 10 //integer division removes the last decimal digit  6519 => 651
     mul = mul * 10    //updates power of 10 for the next digit

Ответ 3

Вы можете сделать то же самое с чистой математикой, используя modulo % и целочисленное деление /, например, используя Stream API:

int n = 70304;
String res = IntStream
        .iterate(1, k -> n / k > 0, k -> k * 10) // divisors
        .map(k -> (n % (k*10) / k ) * k)         // get 1s, 10s, 100s, etc.
        .filter(x -> x > 0)                      // throw out zeros
        .mapToObj(Integer::toString)             // convert to string
        .collect(Collectors.joining(" + "));     // join with '+'
System.out.println(res); // 4 + 300 + 70000

Ответ 4

Существует много вариантов. Если использование списка разрешено:

public static String expandedForm(int num){

    String[] str = Integer.toString(num).split("");
    String result;
    List<String> l = new ArrayList<String>();

    for(int i = 0; i < str.length; i++){
        if(Integer.valueOf(str[i]) > 0){
            String s = str[i];
            for(int j = i; j < str.length - 1; j++){
                s += '0';
            }
            l.add(s);
        }
    }

    result = l.toString();
    result = result.substring(1, result.length() - 1).replace(",", " +");
    System.out.println(result);

    return result;
}

Можно также напрямую работать с результатом:

public static String expandedForm2(int num){

    String[] str = Integer.toString(num).split("");
    String result = "";

    for(int i = 0; i < str.length; i++){
        if(Integer.valueOf(str[i]) > 0){
            result += str[i];
            for(int j = i; j < str.length - 1; j++){
                result += '0';
            }
            result += " + ";
        }
    }
    result = result.substring(0, result.length() - 3);
    System.out.println(result);
    return result;
}

Ответ 5

Это также можно сделать рекурсивно. Вот пример реализации:

String g(int n, int depth){     // Recursive method with 2 int parameters & String return-type
  int remainder = n % depth;    //  The current recursive remainder
  if(depth < n){                //  If we aren't done with the number yet:
    int nextDepth = depth * 10; //   Go to the next depth (of the power of 10)
    int nextN = n - remainder;  //   Remove the remainder from the input 'n'
                                //   Do a recursive call with these next 'n' and 'depth'
    String resultRecursiveCall = g(nextN, nextDepth);
    if(remainder != 0){         //   If the remainder was not 0:
                                //    Append a " + " and this remainder to the result
      resultRecursiveCall += " + " + remainder;
    }
    return resultRecursiveCall; //   And return the result
  } else{                       //  Else:
    return Integer.toString(n); //   Simply return input 'n' as result
  }
}

String f(int n){                // Second method so we can accept just integer 'n'
  return g(n, 1);               //  Which will call the recursive call with parameters 'n' and 1
}

Второй метод заключается в том, что мы можем вызвать метод только с одним входом n. Например:

String result = f(70304);

Это приведет к появлению строки 70000 + 300 + 4.

Попробуйте в Интернете.

Чтобы объяснить немного больше того, что делает этот рекурсивный метод, давайте просто сделаем шаг за шагом для входа 70304:

1. В первой рекурсивной итерации: n=70304, depth=1, remainder=70304%1 = 0.
   • Поскольку depth < n является правдивой, она будет делать рекурсивный вызов с 70304-0 и 1*10
   • И так как remainder равен 0, он ничего не добавит к результату
2. Во второй рекурсивной итерации: n=70304, depth=10, remainder=70304%10 = 4.
   • Поскольку depth < n по-прежнему остается правдой, она будет делать рекурсивный вызов с 70304-4 и 10*10
   • А так как remainder равен 4, он добавит " + " и этот 4 к результату
3. В третьей рекурсивной итерации: n=70300, depth=100, remainder=70300%100 = 0.
   • Поскольку depth < n по-прежнему остается правдой, она будет делать рекурсивный вызов с 70300-0 и 100*10
   • И так как remainder равен 0, он ничего не добавит к результату
4. В четвертой рекурсивной итерации: n=70300, depth=1000, remainder=70300%1000 = 300.
   • Поскольку depth < n по-прежнему остается правдой, она будет делать рекурсивный вызов с 70300-300 и 1000*10
   • И так как remainder 300, он добавит " + " и этот 300 к результату
5. На пятой рекурсивной итерации: n=70000, depth=10000, remainder=70000%10000 = 0.
   • Поскольку depth < n по-прежнему остается правдой, она будет делать рекурсивный вызов с 70000-0 и 10000*10
   • И так как remainder равен 0, он ничего не добавит к результату
6. В шестой рекурсивной итерации: n=70000, depth=100000, remainder=70000%100000 = 70000.
   • Поскольку теперь depth < n ложна, она не будет делать никаких рекурсивных вызовов, а вместо этого возвращает текущий n (это 70000).

И поскольку это были все рекурсивные вызовы, мы должны на самом деле взглянуть на него назад для результата, так что это приведет к 70000 + 300 + 4.

Так что вообще:

• depth < n if-check - это увидеть, когда мы закончили рекурсивные вызовы.
• g(n-remainder, depth*10) удалит цифры, которые мы уже вывели в предыдущей рекурсивной итерации, и переходит к следующей мощности 10 ^k в следующей рекурсивной итерации
• remainder != 0 if-check определяет, является ли число, которое мы хотим добавить, не было 0

Ответ 6

package backup;

import java.util.Arrays;

public class FileOutput {

    public static void main(String[] args){

        String expForm = expandedForm(70304);
        //System.out.println(expForm);

    }

    public static String expandedForm(int num)
    {

      String[] str = Integer.toString(num).split("");
      String result = "";

      for(int i = 0; i < str.length-1; i++) {
        if(Integer.valueOf(str[i]) > 0) {
          for(int j = i; j < str.length-1; j++) {
            str[i] += '0';
          }
        }
      }

      result = Arrays.toString(str);
      result = result.substring(1, result.length()-1).replace(",", " +");
      System.out.println(result);

      return result;
    }
}

Выход: 70000 + 0 + 300 + 0 + 4

Решение в большинстве внутренних циклов вам нужно добавить '0' к str[i]: str[i] += '0';

Затем вам нужно заменить "+ 0" на результат.

Ответ 7

for(int i = 0; i < str.length; i++) {
    if(Integer.valueOf(str[i]) > 0) {
        for(int j = 0; j < str.length - i - 1; j++) {
            str[i] += '0';
        }
    }
}  

Ответ 8

Я думаю, что проблема этой проблемы заключается в отсутствии 0 (ноль) и дополнительных + (плюс) при повторении по всему номеру. Функция String concat может использоваться с условием ниже:

  public static String expandedForm(int num) {
    String st = String.valueOf(num);
    String finalResult = "";

    for (int i = 0; i < st.length(); i++) {
         String s = String.valueOf(st.charAt(i));
        if (Integer.valueOf(s) > 0) {
            for (int j = i; j < st.length() - 1; j++) {
                s = s.concat("0");
            }

            if (i == st.length() - 1) {
                finalResult = finalResult.concat(s);
            } else {
                finalResult = finalResult.concat(s + " + ");
            }       
        }
    }
    return finalResult;
}

Ответ 9

public static String expandedForm(int num)
{

  String[] str = Integer.toString(num).split("");
  String result = "";
  String st="";
  for(int i = 0; i < str.length-1; i++) {
    if(Integer.valueOf(str[i]) > 0) {
      for(int j = i; j < str.length-1; j++) {
        str[i] += '0';
      }
    }
  }

  for(String s:str) {
  st += s+" ";
  }
  result=st;
  result = result.substring(0, result.length()-1).replace(" 0","").replace(" ", " + ");
  System.out.println(result);

  return result;
}

Ответ 10

public class Kata
{

    public static String expandedForm(int num)
    {
        String outs = "";
        for (int i = 10; i < num; i *= 10) {
            int rem = num % i;
            outs = (rem > 0) ? " + " + rem + outs : outs;
            num -= rem;
        }
        outs = num + outs;

        return outs;
    }
}