Как суммировать цифры, если вводится число при добавлении степени n-го к каждому di git, соответствующему формуле, приведенной ниже?

Question

Мне трудно найти решение этой проблемы. Я пытаюсь разработать программу в Java, которая принимает число в качестве входных данных и печатает сумму мощности каждого di git, так что мощность nth di git равна (n-1) th di git. Однако для первого di git мощность должна быть такой же, как у последнего di git. например, у нас есть вход 123, тогда шаблон должен быть 1 ^ 3 + 2 ^ 1 + 3 ^ 2. Это сбивает меня с толку, и я буду признателен за любые идеи.

import java.util.Scanner;

public class MyTest {
    public static void main(String[] args) {

        int input;
        Scanner scanner = new Scanner(System.in);
        input = scanner.nextInt();
        System.out.println(logic(input));
    }

    public static int logic(int input) {
        int sum = 0;
        while (input != 0) {
            sum = sum + input % 10;
            input = input / 10;
        }
        return sum
    }
}

Это все, что у меня есть до сих пор.

Формула:

если входное число равно 123, то окончательный результат должен быть суммой:

1 ^ 3 + 2 ^ 1 + 3 ^ 2

Answer 1

Вот решение:

import static java.lang.Math.pow;
import java.util.Scanner;  
public class Main
{
    public static void main(String[] args) 
    {
        Scanner myObj = new Scanner(System.in);
        System.out.print("Enter number: ");
        int a = myObj.nextInt();;
        String number = String.valueOf(a);
        char[] digi = number.toCharArray();
        int n = String.valueOf(a).length();
        double sum = 0.0;int t = 1;
        double r =(double) (digi[0] - '0');
        double s =(double) (digi[n-1] - '0');
        sum += pow(r,s);       

        while(t<n)
        {
         double d = (double) (digi[t] - '0');
         double e = (double) (digi[t-1] - '0');
         sum += pow(d,e);t++;
        }

        int ans = (int) sum;
        System.out.print(ans);
    }
}

Ваш ввод:

Enter number: 123                                                                                                                   
12

Тестовый пример # 1:

Enter number: 653                                                                                                                    
16084    

Тестовый пример # 2:

Enter number: 7899                                                                                                                   
472917969

Answer 2

Сделайте это следующим образом:

import java.util.Scanner;

public class MyTest {
    public static void main(String[] args) {
        String input = "";
        Scanner scanner = new Scanner(System.in);
        do {
            System.out.print("Enter the number: ");
            input = scanner.nextLine();
        } while (!input.matches("\\d+"));// Allow only positive int
        int num = Integer.parseInt(input);
        System.out.println(logic(num));
    }

    public static int logic(int input) {
        String[] digits = String.valueOf(input).split("");// Split on each digit
        int sum = 0;
        for (int i = 0; i < digits.length; i++) {
            int j = (i + 2) % digits.length;
            sum += Math.pow(Integer.parseInt(digits[i]), Integer.parseInt(digits[j]));
        }
        return sum;
    }
}

Пробный прогон:

Enter the number: 123
12

[Обновление]:

Вы можете улучшить производительность функции, анализируя каждое di git в int и сохраняя их в int[]. Затем вы можете просто использовать цифры из этого int[] вместо анализа цифр при вычислении мощности.

public static int logic(int input) {
    String[] arr = String.valueOf(input).split("");// Split on each digit
    int[] digits = new int[arr.length];

    // Fill digits[] with corresponding elements of arr[] parsed into int
    for (int i = 0; i < arr.length; i++) {
        digits[i] = Integer.parseInt(arr[i]);
    }

    int sum = 0;
    for (int i = 0; i < digits.length; i++) {
        int j = (i + 2) % digits.length;// The alternate index
        sum += Math.pow(digits[i], digits[j]);
    }
    return sum;
}

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

Answer 3

Мне нравится короткий и лаконичный код.

int sum = 0;
Integer[] integers = Stream.of(Integer.toString(input).toCharArray())
  .map(String::valueOf)
  .map(Integer::parseInt)
  .toArray(Integer[]::new);
for (int i = 0 ; i < integers.length ; i++) {
  sum += i == 0 ? 
    Math.pow(integers[i], integers[integers.length - 1]) : 
    Math.pow(integers[i], integers[i - 1]);
}

Answer 4

Почему вы не можете просто создать массив отдельных цифр, а затем выполнить a для l oop над этим массивом?

Что-то вроде следующего:

int i =0;
while(n>0){
arr[i] = n%10;
n = n / 10;
i++;
}

Теперь в в этом случае arr [0] будет фактически единицей di git, а arr [1] будет десятками di git и так далее.

Итак, вам нужно сделать:

int sum = 0;
for(int i=0; i<arr.length-2; i++){
sum = sum + math.pow(arr[i], arr[i+1]);
}
// and finally 
sum = sum + math.pow(arr[arr.length-1], arr[0]);

Обратите внимание на последний блок суммы, он поднимает первое число di git слева в степень последнего di git в номер справа.

PS: Я только что написал формат типа псевдокода, может понадобиться поправить синтаксис.