Как найти произведение чисел в java

I need to find the sum and the product of the digits of the number entered. I have the sum part down but the only problem with it is that when I enter a number for the first time it gives me the right answer but when I enter another number, it just adds the sum of the first number and the sum of the second number together and then checks if the sum of the two sums is odd(sorry if its kind of confusing). For the product part of the code I just can’t seem to figure out how to do it.

Finally if the sum and the product both are odd I need it to say that the number entered is an Extremely odd number.

Here is the assignment:

This Java application checks whole numbers in the interval [101, 100001] to see if they are «extremely odd» and «super extremely odd» numbers.

A whole number is «extremely odd» if…

(0) it’s an odd number
(1) it has an odd number of digits
(2) all of its digits are odd numbers
(3) the sum of its digits is an odd number
(4) the product of its digits is an odd number

A «super extremely odd» number is an extremely odd number such that…

(5) all digits comprising the sum of its digits are odd numbers
(6) all digits comprising the product of its digits are odd numbers

Loop prompting the user to enter positive whole numbers. Looping ends when a -1 is entered. For each number entered, check to see if its extremely odd (or super extremely odd).

If somebody could just explain what the requirements for the super extremely odd numbers part are saying that would be appreciated because English is not my first language.
I don’t need anyone to do the whole assignment. I just need help on the parts that I’m stuck in. Thank you in advance!

public class TestOddNumbers {

  public static void main(String[] args) {

    Scanner stdin = new Scanner(System.in);
    int userInput;
    int sum = 0;
    int product = 1;
    final int EXIT = -1;
    final int MIN = 101;
    final int MAX = 100001;
    String total = "";

    do{
        System.out.println("Please enter a positive whole number between "
                + "" + MIN + " and " + MAX + ". Enter " + EXIT + " "
                + "when you are done entering numbers.");

        userInput = stdin.nextInt();
        total += String.valueOf(userInput);

        if(userInput==EXIT){
        System.out.println("Thanks for playing!");
        break;
        }

        if(userInput > MIN && userInput < MAX){
            if(userInput % 2 == 1){
            System.out.println("It's an odd number");
            }
            else{
                System.out.println("Not an odd number");
            }

            if(total.length() %2 == 1){
            System.out.println("It also has an odd number of digits");
            }
            else{
            System.out.println("Does not have an odd number of digits");
            }

            boolean[] allOdds = {true};

            String.valueOf(userInput).chars().forEach(i -> {
            if(Integer.parseInt(String.valueOf((char)i))%2==0){
            allOdds[0] = false;
            }
            });

            if(allOdds[0]){
                System.out.println("all digits are odds");
            }
            else{
                System.out.println("all digits are not odds");
            }

            // The sum code block
            while (userInput != 0) {
                sum += userInput % 10;
                userInput /= 10;
            }
            if((sum += userInput) % 2 == 1){
                System.out.println("The sum of the digits are odd");
            }
            else{
                System.out.println("The sum of the digits are not odd");
            }

            // The product code block
            while(userInput != 0) {
                product *= userInput % 10;
                userInput /= 10;
            }
            if((sum *= userInput) % 2 == 1){
                System.out.println("The product of the digits are odd");
            }
            else{
                System.out.println("The product of the digits are not odd");
            }

        }
        else{
            System.out.println("Check the bounds again!!");
        }

        System.out.println();
    } 
    while(userInput > MIN || userInput < MAX);

   }
}

Java содержит набор встроенных математических операторов для выполнения простых арифметических операций над переменными. Они достаточно просты. Также есть класс Java Math, который содержит методы для выполнения более сложных математических вычислений.

Четыре основных математических оператора.

Сложение

Оператор + выполняет сложение двух значений. Это может быть добавление двух констант, константы и переменной или переменной и переменной. Вот несколько примеров:

int sum1 = 10 + 20;      // adding two constant values
int sum2 = sum1 + 33;    // adding a variable and a constant
int sum3 = sum2 + sum2;  // adding two variables

Оператор + заменит два значения на сумму двух значений во время выполнения. Таким образом, в месте, где записано выражение sum1 + 33, во время выполнения будет заменено суммой значения sum1 и постоянного значения 33.

Конечно, вы можете создавать более длинные цепочки дополнений, и таким образом добавлять более двух чисел. Вот пример добавления трех или более значений вместе:

int sum1 = 10 + 20 + 30;
int sum3 = sum2 + 99 + 123 + 1191;

Обычно используемая математическая операция над переменными – установить переменную равной ее собственному значению плюс другое значение. Вот как это выглядит:

int result = 10;
result = result + 20;

Вторая строка этого примера устанавливает переменную суммы, равную ее собственному значению (перед присвоением нового значения) + 20. Что означает 10 + 20.

Поскольку добавление значения в переменную Java является очень распространенной операцией, есть встроенный оператор для этой конкретной цели. Это оператор + =. Вот пример выше, переписанный с использованием оператора:

int result = 10;
result += 20;

Вторая строка в этом примере добавляет 20 к переменной result. Это эквивалентно коду результата = результат + 20;

Вычитание

Оператор “-” выполняет вычитание одного значения из другого. Это может быть вычитание постоянного значения из другого постоянного значения, постоянного значения из переменной или переменной из переменной. Вот несколько примеров:

int diff1 = 200 - 10;
int diff2 = diff1 - 5;
int diff3 = diff1 - diff2;

Оператор “-” заменит два значения разницей между двумя значениями, так же как с оператором +.

Вы можете создавать более длинные цепочки вычитаний. Вот пример вычитания двух значений из другого в дном выражении Java:

int diff = 200 - 10 - 20;

Это работает и для переменных.

Помните, минус минус равно плюс, как в обычной математике. Вот пример этого:

int diff = 200 -(-10);

После выполнения этого математического выражения переменная diff будет содержать значение 210, потому что -(- 10) равно +10 согласно стандартным математическим правилам.

Как и в случае с дополнением, Java содержит оператор, специально предназначенный для вычитания значения из переменной и присвоения результата переменной. Вот первое, как это будет выглядеть без этого оператора:

int result = 200;
result = result - 10;

Вот как выглядит та же математическая операция с оператором “-=”:

int result = 200;
result -= 10;

Умножение

Оператор * выполняет умножение двух значений. Значения могут быть либо двумя постоянными значениями, переменной и постоянным значением, либо двумя переменными. Вот несколько примеров:

int prod1 = 10 * 20;
int prod2 = prod1 * 5;
int prod3 = prod1 * prod2;

Оператор * заменит математическое выражение умножения на произведение двух значений во время выполнения.

Вы можете создавать более длинные цепочки умножения, используя оператор *. Вот пример:

int prod = 10 * 20 * 30;

Умножение переменной на значение и присвоение значения обратно переменной является обычной математической операцией в приложениях Java. Поэтому Java содержит явный оператор для этой операции. Оператор “*=”. Вот пример, как будет выглядеть вычисление без оператора:

int result = 10;
result = result * 20;

Вторая строка этого примера умножает значение переменной результата (до присвоения результата этого вычисления) на 20 и присваивает значение обратно переменной результата.

Вот как выглядит та же математическая операция с оператором:

int result = 10;
result *= 20;

Деление

Оператор “/” выполняет деление одного значения на другое. Это может быть деление одной константы на другую, переменной на константу или одной переменной на другую переменную.

int division1 = 100 / 10;
int division2 = division1 / 2;
int division3 = division1 / division2;

Вы можете объединить несколько значений для деления, но из-за приоритета математического оператора Java (объясненного позже) вы должны обратить внимание на то, как объединяете значения.

int division = 100 / 10 / 2;

После выполнения этого математического выражения переменная деления будет содержать значение 5. Это результат, потому что математическое выражение рассчитывалось сначала путем деления 100 на 10 (= 10), а затем 10 на 2 (= 5). Но что, если вы хотели сначала разделить 10 на 2 (= 5), а затем разделить 100 на 5 (= 20)? Вы должны были бы использовать скобки для достижения этого, например:

int division = 100 /(10 / 2)

Java также содержит оператор быстрого доступа для деления значения переменной на другое значение и присвоения этого значения обратно переменной. Оператор “/=”. Вот как выглядит математическая операция без оператора:

int result = 100;
result = result / 5;

Во второй строке этого примера значение переменной результата (значение, которое оно имело до присвоения результата этого вычисления) делится на 5 и присваивает результат обратно переменной результата.

Вот как выглядит та же математическая операция с оператором “/=”:

int result = 100;
result /= 5;

Остаток / Модуль

Математическая операция остаток выполняет целочисленное деление одного значения на другое и возвращает остаток этого деления. Оператор для операции остаток / по модулю – это символ % (процент). Вот пример работы модуля:

int value    = 100;
int remainder = value % 9;

100, деленное на 9 – это 11 с остатком 1 (11 умножить на 9 – 99). Таким образом, переменной остатка присваивается значение 1.

Java также содержит оператор быстрого доступа для деления переменной на другое значение и назначения оставшейся части этого деления переменной. Оператор “%=”. Вот пример:

int result = 100;
result %= 9;

Вторая строка этого примера назначит значение 1 переменной результата. 1 является результатом 100% 9.

Приоритет оператора Java Math

Как только вы начинаете комбинировать математические операторы Java в математических выражениях, становится важным контролировать, когда и какие вычисления выполнять, чтобы получить желаемый результат. Математические операторы Java имеют естественный приоритет операторов, который аналогичен приоритетам стандартных математических операторов.

Математические операторы * и / для умножения и деления имеют приоритет над операторами + и -. Это означает, что умножения и деления вычисляются перед сложением и вычитанием в математических выражениях. В случае наличия нескольких операторов * и / они будут рассчитаны слева направо. Посмотрите на это математическое выражение:

int result = 100 * 100 / 5 + 200 * 3 / 2;

Сначала выполняются умножения и деления. Есть две группы из трех умножений и делений. Каждая группа выполняется слева направо:

100 * 100 = 10000;
10000 / 5 = 2000;

200 * 3 = 600;
600 / 2 = 300;

После вычисления умножения и деления математическое выражение выглядит так:

int result = 2000 + 600;

Теперь сложения и вычитания выполняются. Таким образом, значение, присвоенное переменной результата, равно 2000 + 600 = 2600.

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

int result = 100 * 100 /(5 + 200) * 3 / 2;

Значение 100 все еще умножается на 100 (= 10 000), но теперь оно делится на 5 + 200 (= 205) вместо 5. После этого деления результат умножается на 3, а затем делится на 2. Результат выполнения 72 (округление вычислений влияет на результат).

Java Integer Math

Математические операции, выполняемые с целочисленными типами Java (byte, short, int и long), ведут себя немного иначе, чем обычные математические операции. Поскольку целочисленные типы не могут содержать дроби, в каждом вычислении с одним или несколькими целочисленными типами все дроби в результате обрезаются. Посмотрите на это математическое выражение:

int result = 100 / 8;

Результат этого деления будет 12,5, но так как два числа являются целыми числами, фракция .5 обрезается. Результат, следовательно, всего 12.

Округление также происходит в подрезультатах больших вычислений.

С плавающей точкой Math

Java содержит два типа данных с плавающей точкой: float и double. Они могут содержать дроби в числах. Если нужны дробные выражения в математических выражениях, вы должны использовать один из этих типов данных. Вот пример математического выражения с плавающей точкой:

double result = 100 / 8;

Несмотря на то, что переменная результата теперь имеет тип с плавающей запятой (double), конечный результат по-прежнему равен 12 вместо 12,5. Причина в том, что оба значения в математическом выражении (100 и оба являются целыми числами. Таким образом, результат деления одного на другое сначала преобразуется в целое число (12), а затем присваивается переменной результата.

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

double no1 = 100;
double no2 = 8;

double result = no1 / no2;

Теперь переменная результата будет иметь значение 12,5.

В Java есть способ заставить все числа в расчете быть переменными с плавающей точкой. Вы ставите числа с большой буквы F или D. Вот пример:

double result = 100D / 8D;

Обратите внимание на прописные буквы D после каждого числа. Этот верхний регистр D говорит Java, что эти числа должны интерпретироваться как числа с плавающей запятой, и, таким образом, деление должно быть делением с плавающей запятой, которое сохраняет дроби вместо их обрезания.

На самом деле вы также можете сделать число длинным, добавив суффикс числа к верхнему регистру L, но long по-прежнему является целочисленным типом, поэтому он не будет сохранять дробные части в вычислениях.

Точность с плавающей точкой

Типы данных с плавающей точкой не являются точными на 100%. Вы можете столкнуться с ситуациями, когда числа со многими дробями не складываются с ожидаемым числом. Если вычисление с плавающей запятой приводит к числу с большим количеством дробей, чем может обработать число с плавающей запятой или двойное число, дроби могут быть обрезаны. Конечно, заданная точность может быть более чем достаточной для многих типов вычислений, но имейте в виду, что дроби могут фактически быть отсечены.

Посмотрите:

double resultDbl3 = 0D;
System.out.println("resultDbl3 = " + resultDbl3);

for(int i=0; i<100; i++){
    resultDbl3 += 0.01D;
}
System.out.println("resultDbl3 = " + resultDbl3);

Вывод выводится при выполнении этого кода с Java 8:

resultDbl3 = 0.0
resultDbl3 = 1.0000000000000007

Первый оператор System.out.println() правильно печатает значение 0.0, которое является начальным значением переменной resultDbl3.

Однако второй оператор System.out.println() выводит несколько странный результат. Добавление значения 0,01 к 0 всего 100 раз должно привести к значению 1,0, верно? Но каким-то образом окончательный результат 1.0000000000000007. Как видите, что-то не так во фракциях.

Обычно неточность с плавающей запятой незначительна, но все же важно знать об этом.

Класс Java Math

Класс Java Math предоставляет более сложные математические вычисления, чем те, которые предоставляют базовые математические операторы Java. Класс Math содержит методы для:

• нахождения максимального или минимального значений;
• значений округления;
• логарифмических функций;
• квадратного корня;
• тригонометрических функций (sin, cos, tan и т. д.).

Math находится в пакете java.lang, а не в пакете java.math. Таким образом, полное имя класса Math – это java.lang.Math.

Поскольку многие его функции независимы друг от друга, каждый метод будет объяснен в своем собственном разделе ниже.

Основные математические функции

Java.lang.Math содержит набор базовых математических функций для получения абсолютного значения, наибольшего и наименьшего из двух значений, округления значений, случайных значений и т. д.

Math.abs()

Функция Math.abs() возвращает абсолютное положительное значение переданного ей параметра. Если значение параметра является отрицательным, знак “-” удаляется и возвращается положительное значение, соответствующее отрицательному значению без знака. Вот два примера:

int abs1 = Math.abs(10);  // abs1 = 10

int abs2 = Math.abs(-20); // abs2 = 20

Абсолютное значение 10 равно 10. Абсолютное значение -20 равно 20.

Метод Math.abs() представлен в 4 версиях:

Math.abs(int)
Math.abs(long)
Math.abs(float)
Math.abs(double)

Какой из этих методов вызывается, зависит от типа параметра, передаваемого методу Math.abs().

Math.ceil()

Функция округляет значение с плавающей запятой до ближайшего целого числа. Округленное значение возвращается как двойное. Вот пример:

double ceil = Math.ceil(7.343);  // ceil = 8.0

После выполнения этого Java-кода переменная ceil будет содержать значение 8.0.

Math.floor()

Функция Math.floor() округляет значение с плавающей запятой до ближайшего целочисленного значения. Округленное значение возвращается как двойное. Вот пример:

double floor = Math.floor(7.343);  // floor = 7.0

После выполнения ceil будет содержать значение 8.0.

Math.floorDiv()

Метод Math.floorDiv() делит одно целое число (int или long) на другое и округляет результат до ближайшего целочисленного значения. Если результат положительный, эффект такой же, как при использовании оператора “/” (деления), описанного ранее в этом тексте.

Однако, если результат отрицательный, результат не тот же. С помощью оператора “/” дроби просто усекаются. Для положительных чисел это соответствует округлению в меньшую сторону, для отрицательных – в большую. Метод floorDiv() округляет до ближайшего отрицательного целого числа, вместо того, которое будет происходить при усечении дроби.

Вот пример:

double result3 = Math.floorDiv(-100,9);
System.out.println("result3: " + result3);

double result4 = -100 / 9;
System.out.println("result4: " + result4);

Выходные данные:

result3: -12.0
result4: -11.0

Это показывает разницу между оператором “/” и Math.floorDiv().

Math.min()

Метод Math.min() возвращает наименьшее из двух значений, переданных ему в качестве параметра:

int min = Math.min(10, 20);

После выполнения этого кода переменная min будет содержать значение 10.

Math.max()

Метод Math.max() возвращает наибольшее из двух значений, переданных ему в качестве параметра:

int max = Math.max(10, 20);

После выполнения этого кода переменная max будет содержать значение 20.

Math.round()

Метод Math.round() округляет число с плавающей точкой или удваивается до ближайшего целого числа, используя обычные правила математического округления (вверх или вниз):

double roundedDown = Math.round(23.445);
double roundedUp   = Math.round(23.545);

После выполнения этих двух операторов Java переменная roundedDown будет содержать значение 23,0, а переменная roundndedUp будет содержать значение 24,0.

Math.random()

Метод Math.random() возвращает случайное число с плавающей запятой в диапазоне от 0 до 1. Конечно, это число не полностью случайное, но результат некоторого вычисления, которое должно сделать его настолько непредсказуемым, насколько это возможно. Вот пример:

double random = Math.random();

Чтобы получить случайное значение между 0 и, например, 100, умножьте значение, возвращаемое Math.random(), на максимальное число (например, 100). Вот пример того, как это может выглядеть:

double random = Math.random() * 100D;

Если вам нужно целочисленное значение, используйте метод round(), floor() или ceil().

Экспоненциальные и логарифмические функции

Класс Java Math также содержит набор функций, предназначенных для экспоненциальных и логарифмических вычислений.

Math.exp()

Функция Math.exp() возвращает число Эйлера, возведенное в степень значения, указанного в качестве параметра:

double exp1 = Math.exp(1);
System.out.println("exp1 = " + exp1);

double exp2 = Math.exp(2);
System.out.println("exp2 = " + exp2);

Итог:

exp1 = 2.718281828459045
exp2 = 7.38905609893065

Math.log()

Метод Math.log() предоставляет логарифм данного параметра. Основой для логарифма является число Эйлера. Таким образом, Math.log() предоставляет обратную функцию Math.exp(). Вот пример:

double log1  = Math.log(1);
System.out.println("log1 = " + log1);

double log10 = Math.log(10);
System.out.println("log10 = " + log10);

Вывод:

log1 = 0.0
log10 = 2.302585092994046

Math.log10()

Метод Math.log10 работает подобно методу Math.log(), за исключением того, что использует 10 как основу для вычисления логарифма вместо числа Эйлера:

double log10_1   = Math.log10(1);
System.out.println("log10_1 = " + log10_1);

double log10_100 = Math.log10(100);
System.out.println("log10_100 = " + log10_100);

Вывод:

log10_1 = 0.0
log10_100 = 2.0

Math.pow()

Функция Math.pow() принимает два параметра. Метод возвращает значение первого параметра, возведенное в степень второго параметра. Вот пример:

double pow2 = Math.pow(2,2);
System.out.println("pow2 = " + pow2);

double pow8 = Math.pow(2,8);
System.out.println("pow8 = " + pow8);

Вывод:

pow2 = 4.0
pow8 = 256.0

Другими словами, пример Math.pow() вычисляет значения 2, ² и 28, которые равны 4 и 256.

Math.sqrt()

Метод Math.sqrt() вычисляет квадратный корень заданного ему параметра:

double sqrt4 = Math.sqrt(4);
System.out.println("sqrt4 = " + sqrt4);

double sqrt9 = Math.sqrt(9);
System.out.println("sqrt9 = " + sqrt9);

Вывод:

sqrt4 = 2.0
sqrt9 = 3.0

Тригонометрические функции

Класс Java Math содержит набор тригонометрических функций. Эти функции могут вычислять значения, используемые в тригонометрии, такие как синус, косинус, тангенс и т. д.

Mathkpi

Константа Math.PI представляет собой двойное значение, значение которого очень близко к значению PI – математическому определению PI.

Math.sin()

Метод Math.sin() вычисляет значение синуса некоторого значения угла в радианах:

double sin = Math.sin(Math.PI);
System.out.println("sin = " + sin);

Math.cos()

Метод Math.cos() вычисляет значение косинуса некоторого значения угла в радианах:

double cos = Math.cos(Math.PI);
System.out.println("cos = " + cos);

Math.tan()

Метод Math.tan() вычисляет значение тангенса некоторого значения угла в радианах:

double tan = Math.tan(Math.PI);
System.out.println("tan = " + tan);

Math.asin()

Метод Math.asin() вычисляет значение синусоиды значения от 1 до -1:

double asin = Math.asin(1.0);
System.out.println("asin = " + asin);

Math.acos()

Метод Math.acos() вычисляет значение арккосинуса от 1 до -1:

double acos = Math.acos(1.0);
System.out.println("acos = " + acos);

Math.atan()

Метод Math.atan() вычисляет значение арктангенса для значения от 1 до -1:

double atan = Math.atan(1.0);
System.out.println("atan = " + atan);

Math.atan2()

Вот что говорит JavaDoc:

Msgstr “Возвращает угол тета от преобразования прямоугольных координат (x, y) в полярные координаты (r, тета)”.

Если вам нужен этот метод, пожалуйста, прочитайте JavaDoc.

Math.sinh()

Метод Math.sinh() вычисляет значение гиперболического синуса значения между 1 и -1:

double sinh = Math.sinh(1.0);
System.out.println("sinh = " + sinh);

Math.cosh()

Метод Math.cosh() вычисляет значение гиперболического косинуса от 1 до -1:

double cosh = Math.cosh(1.0);
System.out.println("cosh = " + cosh);

Math.tanh()

Метод Math.tanh() вычисляет значение гиперболического тангенса значения от 1 до -1:

double tanh = Math.tanh(1.0);
System.out.println("tanh = " + tanh);

Math.toDegrees()

Метод Math.toDegrees() преобразует угол в радианах в градусы:

double degrees = Math.toDegrees(Math.PI);
System.out.println("degrees = " + degrees);

Math.toRadians()

Метод Math.toRadians() преобразует угол в градусах в радианы:

double radians = Math.toRadians(180);
System.out.println("radians = " + radians);