Я дал номер и хочу, чтобы он возвращался как строка в расширенной форме. Например
expandedForm(12); # Should return "10 + 2"
expandedForm(42); # Should return "40 + 2"
expandedForm(70304); # Should return "70000 + 300 + 4"
Моя функция работает для первого и второго случаев, но с 70304 она дает следующее:
70 + 00 + 300 + 000 + 4
Здесь мой код
import java.util.Arrays;
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[j] += '0';
}
}
}
result = Arrays.toString(str);
result = result.substring(1, result.length()-1).replace(",", " +");
System.out.println(result);
return result;
}
Я думаю, что есть проблема со вторым циклом, но не могу понять, почему.
Вы должны добавить '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
Псевдокод использует целочисленную арифметику для извлечения десятичных цифр один за другим (с правой):
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
Вы можете сделать то же самое с чистой математикой, используя 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
Существует много вариантов. Если использование списка разрешено:
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;
}
Это также можно сделать рекурсивно. Вот пример реализации:
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:
n=70304, depth=1, remainder=70304%1 = 0. depth < n является правдивой, она будет делать рекурсивный вызов с 70304-0 и 1*10remainder равен 0, он ничего не добавит к результатуn=70304, depth=10, remainder=70304%10 = 4. depth < n по-прежнему остается правдой, она будет делать рекурсивный вызов с 70304-4 и 10*10remainder равен 4, он добавит " + " и этот 4 к результатуn=70300, depth=100, remainder=70300%100 = 0. depth < n по-прежнему остается правдой, она будет делать рекурсивный вызов с 70300-0 и 100*10remainder равен 0, он ничего не добавит к результатуn=70300, depth=1000, remainder=70300%1000 = 300. depth < n по-прежнему остается правдой, она будет делать рекурсивный вызов с 70300-300 и 1000*10remainder 300, он добавит " + " и этот 300 к результатуn=70000, depth=10000, remainder=70000%10000 = 0. depth < n по-прежнему остается правдой, она будет делать рекурсивный вызов с 70000-0 и 10000*10remainder равен 0, он ничего не добавит к результату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 определяет, является ли число, которое мы хотим добавить, не было 0package 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" на результат.
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';
}
}
}
Я думаю, что проблема этой проблемы заключается в отсутствии 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;
}
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 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;
}
}