Решение задачи про удаленную работу:
Процент сотрудников на удаленке: 20% (то есть из 100 сотрудников 20 работают на удаленке и 80 — в офисе).
Вероятность, что удаленный сотрудник работает меньше 8 часов: 50% (из 20 удаленных сотрудников, 10 работают меньше 8 часов).
Вероятность, что офисный сотрудник работает меньше 8 часов: 10% (из 80 офисных сотрудников, 8 работают меньше 8 часов).

Считаем общее количество сотрудников, которые работают меньше 8 часов.
Удаленные сотрудники: 10 (из 20).
Офисные сотрудники: 8 (из 80).
Итого сотрудников, работающих меньше 8 часов: [ 10 + 8 = 18 ]
Выясняем, сколько из работающих меньше 8 часов — это удаленные сотрудники.
У нас 10 удаленных сотрудников, которые работают меньше 8 часов.
Теперь находим долю удаленных сотрудников среди всех, кто работает меньше 8 часов.

Из 18 сотрудников, работающих меньше 8 часов, 10 являются удаленными.
Вероятность того, что сотрудник работает на удаленке, если он работает меньше 8 часов:

Это 10 удаленных сотрудников из 18 работающих меньше 8 часов: [ 10/18 = 0.56 ]
Ответ:
Таким образом, вероятность того, что сотрудник работает на удаленке, если он работает меньше 8 часов в день, составляет примерно 56%

Чему равно v?

Ответ на задачу про вычисление среднего: При использовании выражения LongStream.of(Long.MAX_VALUE, Long.MAX_VALUE) внутренняя работа функции average() сначала вычисляет сумму элементов. Поскольку оба значения равны Long.MAX_VALUE, сумма превышает Long.MAX_VALUE: [ Long.MAX_VALUE + Long.MAX_VALUE = 2 \times (2^{63} - 1) = 2^{64} - 2 ] Однако 2^{64} - 2 не может быть представлено типом long (она превышает Long.MAX_VALUE), в результате чего происходит переполнение.

Поскольку sum фактически переполняется и становится отрицательным (из-за переполнения), результатом вычисления среднего может стать отрицательное значение, что является контринтуитивным.

Сколько элементов будет в result?

Ответ на вопрос про перемножение iSet и jSet:
Элементов 8, так как 0 .0 и -0.0 считаются уникальными значениями
В стандартном IEEE 754, который используется для представления чисел с плавающей точкой, существуют два разных значения для нуля:

0.0 (положительный ноль)
-0.0 (отрицательный ноль)
В Java, хотя 0.0 и -0.0 эквивалентны при использовании оператора ==, они могут рассматриваться как отдельные значения:

HashSet использует hashCode() для определения уникальности объектов, и метод hashCode() для Double возвращает разные хэш-коды для 0.0 и -0.0. Из-за этого оба значения могут храниться в HashSet.

Таким образом, result будет содержать:
0.0 (положительный ноль)
-0.0 (отрицательный ноль)
0.25
-0.25
0.5
-0.5
1.0
-1.0

Поэтому result.size() возвращает 8, поскольку 0.0 и -0.0 считаются разными значениями в HashSet из-за нюансов представления чисел с плавающей точкой в Java (см. IEEE 754).

Что напечатает код?

Ответ на вопрос про перевод секунд в микросекунды:
Правильный ответ тут будет 705032704 из-за переполнения int.
При умножении двух целочисленных значений Java выполняет умножение с использованием типа int. Если результат этого умножения превышает максимальное значение, которое может храниться в int (которое составляет 2,147,483,647), происходит переполнение, что приводит к неправильному поведению.

Чтобы избежать этой проблемы при работе с большими числами, можно убедиться, что умножение выполняется с использованием типа long, добавив суффикс L к числу, на которое вы умножаете (в данном случае 1_000_000L). Это повысит уровень операции умножения до long, который имеет гораздо большее максимальное значение (до 9,223,372,036,854,775,807).

Вот исправленная строка кода:
long microseconds = seconds * 1_000_000L;

Что напечатает код?

Разъяснение вопроса про get/set name:
В коде метод main создает экземпляр класса B, устанавливает значение имени с помощью метода setName, а затем выводит значение имени с помощью метода getName. Однако выводится null, и это может быть непонятным на первый взгляд. Давайте разберемся в чем дело.

Класс A содержит поле name, которое является закрытым (private) и имеет геттер getName, который возвращает значение этого поля.
Класс B наследуется от класса A, но в нем есть собственное закрытое поле name и метод setName, который устанавливает значение этого поля.

Когда вы вызываете b.setName("name");, вы устанавливаете значение локального поля name в классе B, а не в классе A. Поэтому поле name в классе A по-прежнему остается null.

Когда вызывается System.out.println(b.getName());, этот метод берёт значение поля name из класса A, которое не было изменено, и таким образом возвращает null.

Что напечатает код?

Ответ на вопрос про Integer.MIN_VALUE/-Integer.MIN_VALUE:
Выражение System.out.println(Integer.MIN_VALUE == -Integer.MIN_VALUE); выводит true.
Давайте поймем почему так:
Integer.MIN_VALUE — это константа в Java, представляющая наименьшее возможное значение для типа int. Для 32-битного целочисленного типа это значение равно -2,147,483,648 (или −(2^31)).

Когда мы берем отрицательное значение от Integer.MIN_VALUE, мы вычисляем:
-Integer.MIN_VALUE = -(-2,147,483,648) = 2,147,483,648
Однако 2,147,483,648 не может быть представлено в типе int, так как максимальное значение для int — это 2,147,483,647 (или 2^31 - 1). Поэтому при попытке установить такое значение происходит переполнение.

При преобразовании 2,147,483,648 в тип int происходит переполнение. Оно «оборачивается» назад по кругу и становится равным Integer.MIN_VALUE, то есть -2,147,483,648.

Есть ли проблемы в этом коде?

Ответ на вопрос про Math.abs:

Когда вы вызываете Math.abs(Integer.MIN_VALUE) в Java, результатом будет Integer.MIN_VALUE, и вы получите отрицательное значение. Давайте разберемся, почему так происходит.

Метод Math.abs() возвращает абсолютное значение числа. То есть он возвращает положительное значение, если число отрицательное, и само число, если оно положительное.

Integer.MIN_VALUE представляет собой наименьшее возможное значение для типа int в Java, которое равно -2,147,483,648 (или −(2^31)).

Когда вы вызываете Math.abs(-2,147,483,648), метод пытается вернуть положительное значение этого числа. Однако в диапазоне int не существует представления для 2,147,483,648, так как максимальное положительное значение int — это 2,147,483,647 (или 2^31 - 1).
Следовательно, попытка преобразовать Integer.MIN_VALUE в положительное значение приводит к переполнению.

По сути, когда Math.abs() пытается вернуть -(-2,147,483,648), это значение не может быть представлено в типе int, и в результате вы получите Integer.MIN_VALUE, а не ожидаемое положительное число.

Как вариант решения можно использовать Math.absExact, он в этом случае кидает ArithmeticError.
Так же обратите внимание на метод Math.floorMod как замену для Math.abs() % intVal