Java - number in expanded form

You should be adding '0's to str[i], not 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';
      }
    }
  }

This will result in:

70000 + 0 + 300 + 0 + 4

You still have to get rid of the 0 digits.

One possible way to get rid of them:

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

Now the output is

70000 + 300 + 4

Pseudocode uses integer arithmetics to extract decimal digits one-by-one (from the right one):

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

You could do the same with pure math, using modulo % and integer division /, e.g. using 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

There are many variations possible. If the usage of a list is allowed:

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

One could also work directly on 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;
}

This is also possible to do recursively. Here an example implementation:

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
}

The second method is so we can call the method with just a single input n. For example:

String result = f(70304);

Which will result in the String 70000 + 300 + 4.

Try it online.

To explain a bit more in depth of what this recursive method does, let's just do a step-by-step for the input 70304:

1. In the first recursive iteration: n=70304, depth=1, remainder=70304%1 = 0.
   • Since depth < n is truthy, it will do a recursive call with 70304-0 and 1*10
   • And since remainder is 0, it will append nothing more to the result
2. In the second recursive iteration: n=70304, depth=10, remainder=70304%10 = 4.
   • Since depth < n is still truthy, it will do a recursive call with 70304-4 and 10*10
   • And since remainder is 4, it will append a " + " and this 4 to the result
3. In the third recursive iteration: n=70300, depth=100, remainder=70300%100 = 0.
   • Since depth < n is still truthy, it will do a recursive call with 70300-0 and 100*10
   • And since remainder is 0, it will append nothing more to the result
4. In the fourth recursive iteration: n=70300, depth=1000, remainder=70300%1000 = 300.
   • Since depth < n is still truthy, it will do a recursive call with 70300-300 and 1000*10
   • And since remainder is 300, it will append a " + " and this 300 to the result
5. In the fifth recursive iteration: n=70000, depth=10000, remainder=70000%10000 = 0.
   • Since depth < n is still truthy, it will do a recursive call with 70000-0 and 10000*10
   • And since remainder is 0, it will append nothing more to the result
6. In the sixth recursive iteration: n=70000, depth=100000, remainder=70000%100000 = 70000.
   • Since now depth < n is falsey, it won't do any more recursive calls, but instead return the current n (which is 70000).

And since these were all recursive calls, we should actually look at it backwards for the result, so it will result in 70000 + 300 + 4.

So in general:

• The depth < n if-check is to see when we are done with the recursive calls.
• The g(n-remainder, depth*10) will remove the digits we've already output in a previous recursive iteration, and goes to the next 10^k power in the next recursive iteration
• The remainder != 0 if-check determines if the number we want to append was not a 0

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

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

Output : 70000 + 0 + 300 + 0 + 4

Solution in most inner loop you need to add '0' to str[i] : str[i] += '0';

Then you need to replace "+ 0" from the resulted output.

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

I think the challenge of this problem is omitting 0(zero) and extra +(plus) while iterating throughout the number. String concat function can be used with condition as bellow:

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

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

public static String expandedForm(int num)
{
    int numberOfDigits =(int) Math.floor(Math.log10(num)+1);
    String result="";
    while(numberOfDigits-->0){
        int divisor = (int)Math.pow(10,numberOfDigits);
        int quotient = num/divisor;
        num%=divisor;
        int value = quotient * divisor;
        if(value!=0)
            result+=value+(numberOfDigits != 0 ?"+":"");
    }
    return result;
}

Try with this.

Find number of digits and iterate for every single digit.

Make a divisor of 10 power (number of digits -1) and divide the number to get quotient.

Take reminder for next iteration.

Multiply quotient and divisor and store in result if it value is not zero.

Simple Javascript Expanded Form of a number Asked in interviews for beginners/Juniors

function expandedForm(n){
let temp = n;
let count=0;
while(temp>0){
    console.log(((temp%10)*(10**count)));
    count++;
    temp = Math.floor(temp/10); 
}

}

output will be like this:-

7 80 400 5000 10000