fedor/tasks-to-mdl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Generate pandoc dataclasses

Browse Source
This commit is contained in:
fedor
2026-09-14 19:26:07 +03:00
parent 0aaa074bc6
commit 6962cf3e73
11 changed files with 1971 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files
input/T02.md
+380
View File
@@ -0,0 +1,380 @@
# Целые числа в Java: теория и практика
## 1. Что такое целые числа и зачем они нужны
**Целое число** — это число без дробной части: ..., −3, −2, −1, 0, 1, 2, 3, ...
В программировании целые числа используются для:
- счёта объектов (количество учеников, итераций цикла);
- индексов массивов и коллекций;
- идентификаторов (номер заказа, ID пользователя);
- работы с денежными суммами в копейках/центах (чтобы избежать ошибок округления);
- битовых операций и работы с памятью.
> ⚠️ **Важно:** в Java нельзя хранить в целочисленной переменной дробное значение — компилятор выдаст ошибку или потребует явного приведения.
---
## 2. Примитивные целочисленные типы
В Java **4 примитивных целочисленных типа**, различающихся диапазоном и объёмом памяти:
| Тип | Размер | Диапазон | Применение |
|-----|--------|----------|------------|
| `byte` | 8 бит | от −128 до 127 | экономия памяти в массивах, работа с байтами |
| `short` | 16 бит | от −32 768 до 32 767 | редко, в основном в устаревшем коде |
| `int` | 32 бита | от −2 147 483 648 до 2 147 483 647 | **основной тип по умолчанию** |
| `long` | 64 бита | от −9.2·10¹⁸ до 9.2·10¹⁸ | большие числа, время в миллисекундах |
**Запомните:** по умолчанию любое целое литеральное число в Java имеет тип `int`. Чтобы получить `long`, добавьте суффикс `L`:
```java
int a = 2_000_000_000; // ок
long b = 9_000_000_000L; // без L будет ошибка компиляции
```
---
## 3. Объявление переменных и литералы
```java
byte small = 100;
short medium = 30_000;
int normal = 1_000_000;
long big = 123_456_789_012L;
// Системы счисления:
int decimal = 255; // 10-я
int hex = 0xFF; // 16-я (префикс 0x)
int binary = 0b1111_1111; // 2-я (префикс 0b)
int octal = 0377; // 8-я (ведущий 0)
// Подчёркивания для читаемости
int million = 1_000_000;
```
**Константы** (`final`) — значение нельзя изменить после инициализации:
```java
final int MAX_SCORE = 100;
// MAX_SCORE = 200; // ошибка компиляции
```
---
## 4. Ввод целых чисел (класс `Scanner`)
Самый простой способ — `java.util.Scanner`.
```java
import java.util.Scanner;
public class InputDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Введите целое число: ");
int n = sc.nextInt(); // читает int
System.out.print("Введите длинное число: ");
long L = sc.nextLong(); // читает long
System.out.print("Введите байт: ");
byte b = sc.nextByte();
System.out.println(String.format("Вы ввели: %d, %d, %d", n, L, b));
sc.close();
}
}
```
Для чтения из файла/строки можно использовать `Scanner(new File("input.txt"))` или `BufferedReader`.
---
## 5. Вывод целых чисел
```java
int x = 42;
// Если нужно вывести только число — подходит обычный println:
System.out.println(x); // 42
// Когда нужен текст или форматирование — String.format:
System.out.println(String.format("x = %d", x));
// Форматирование в разных системах счисления:
System.out.println(String.format("hex = %x, bin = %s",
255, Integer.toBinaryString(255)));
// hex = ff, bin = 11111111
// Выравнивание и ширина поля:
System.out.println(String.format("|%5d|", 42)); // | 42|
System.out.println(String.format("|%-5d|", 42)); // |42 |
System.out.println(String.format("|%05d|", 42)); // |00042|
```
Часто используемые спецификаторы `String.format`:
| Спецификатор | Смысл |
|--------------|-------|
| `%d` | целое в 10-й системе |
| `%x` | 16-я система |
| `%o` | 8-я система |
| `%05d` | целое с ведущими нулями, ширина 5 |
| `%n` | перевод строки (переносимый) |
---
## 6. Основные операции
### 6.1 Арифметические
```java
int a = 17, b = 5;
System.out.println(a + b); // 22
System.out.println(a - b); // 12
System.out.println(a * b); // 85
System.out.println(a / b); // 3 — ЦЕЛОЧИСЛЕННОЕ деление
System.out.println(a % b); // 2 — остаток от деления
```
> ⚠️ Деление целых чисел **отбрасывает дробную часть**, а не округляет: `7 / 2 == 3`, `-7 / 2 == -3` (округление к нулю).
### 6.2 Операции присваивания
```java
int x = 10;
x += 5; // x = 15
x -= 3; // x = 12
x *= 2; // x = 24
x /= 4; // x = 6
x %= 4; // x = 2
x++; // x = 3
x--; // x = 2
```
### 6.3 Сравнение
```java
int p = 5, q = 7;
boolean r1 = p == q; // false
boolean r2 = p != q; // true
boolean r3 = p < q; // true
boolean r4 = p >= q; // false
```
### 6.4 Побитовые операции
```java
int m = 0b1100; // 12
int n = 0b1010; // 10
System.out.println(m & n); // 8
System.out.println(m | n); // 14
System.out.println(m ^ n); // 6
System.out.println(~m); // -13
System.out.println(m << 1); // 24 (сдвиг влево = ×2)
System.out.println(m >> 1); // 6 (сдвиг вправо)
System.out.println(m >>> 1); // 6 (беззнаковый сдвиг)
```
### 6.5 Приведение типов
**Автоматическое** (расширяющее) — от меньшего к большему:
```java
byte b = 100;
int i = b; // ок
long l = i; // ок
```
**Явное** (сужающее) — от большего к меньшему, возможна потеря данных:
```java
int big = 300;
byte small = (byte) big; // 300 % 256 = 44 (переполнение)
```
**Переполнение** — опасная ситуация: `int` не может выйти за пределы диапазона и «зацикливается»:
```java
int max = Integer.MAX_VALUE;
System.out.println(max + 1); // -2147483648
```
---
## 7. Критерии применимости целых чисел
Используйте целочисленный тип, если:
1. **Величина по своей природе дискретна** — количество, индекс, счётчик.
2. **Нужна точность без округлений** — деньги (лучше в копейках), ID, временные метки.
3. **Выполняются операции над целыми** — деление нацело, остаток, битовые сдвиги.
4. **Важна производительность** — целочисленная арифметика быстрее вещественной.
5. **Нужна экономия памяти** — например, `byte[]` для большого массива.
**Не используйте целые числа**, если:
- величина непрерывна (расстояние, температура, вес) — берите `double`/`float`;
- нужна высокая точность над дробными числами — `BigDecimal`.
**Выбор типа:**
- по умолчанию — `int`;
- если значения > 2·10⁹ или работа со временем в мс — `long`;
- для больших массивов малых чисел — `byte`/`short`;
- для чисел, не помещающихся ни в один примитив (> 9.2·10¹⁸) — `BigInteger`.
---
## 8. Классы стандартной библиотеки
### 8.1 Классы-обёртки: `Integer`, `Long`, `Short`, `Byte`
Каждому примитиву соответствует класс-обёртка. Нужен для:
- хранения в коллекциях (`ArrayList<Integer>`);
- использования полезных методов;
- `null`-значений (например, «значение отсутствует»).
```java
Integer obj = 42; // автоупаковка (autoboxing)
int prim = obj; // автораспаковка (unboxing)
// Полезные методы (там, где выводится только число — println):
System.out.println(Integer.MAX_VALUE); // 2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648
System.out.println(Integer.parseInt("123")); // 123
System.out.println(Integer.compare(3, 5)); // -1
System.out.println(Integer.max(3, 5)); // 5
System.out.println(Integer.sum(3, 5)); // 8
System.out.println(Integer.bitCount(7)); // 3
System.out.println(Integer.numberOfLeadingZeros(1)); // 31
// Там, где результат — строка — String.format:
System.out.println(String.format("%s", Integer.toBinaryString(10))); // 1010
System.out.println(String.format("%s", Integer.toHexString(255))); // ff
```
> ⚠️ Сравнивайте объекты-обёртки через `.equals()`, а не `==`:
> ```java
> Integer a = 1000, b = 1000;
> System.out.println(a == b); // false (разные объекты)
> System.out.println(a.equals(b)); // true
> ```
> Кэш `Integer` работает только для значений от −128 до 127, поэтому `Integer a = 100; Integer b = 100; a == b` даст `true`, но для 1000 — уже `false`.
### 8.2 `BigInteger` — для чисел произвольной длины
Когда `long` недостаточно (факториалы, криптография, длинная арифметика):
```java
import java.math.BigInteger;
BigInteger a = new BigInteger("123456789012345678901234567890");
BigInteger b = BigInteger.valueOf(987654321L);
System.out.println(a.add(b)); // сложение
System.out.println(a.subtract(b)); // вычитание
System.out.println(a.multiply(b)); // умножение
System.out.println(a.divide(b)); // деление
System.out.println(a.mod(b)); // остаток
System.out.println(a.pow(2)); // возведение в степень
System.out.println(a.gcd(b)); // НОД
// Факториал 100:
BigInteger fact = BigInteger.ONE;
for (int i = 2; i <= 100; i++)
fact = fact.multiply(BigInteger.valueOf(i));
System.out.println(fact);
```
`BigInteger` **иммутабелен** — операции возвращают новый объект, а не меняют исходный.
### 8.3 `Math` — математические функции
Работает с `double`, но есть методы и для целых:
```java
System.out.println(Math.abs(-7)); // 7
System.out.println(Math.max(3, 8)); // 8
System.out.println(Math.min(3, 8)); // 3
// Math.pow / Math.sqrt возвращают double — для форматирования используем String.format:
System.out.println(String.format("%.1f", Math.pow(2, 10))); // 1024.0
System.out.println(String.format("%.1f", Math.sqrt(144))); // 12.0
```
### 8.4 `Random` — генерация случайных чисел
```java
import java.util.Random;
Random rnd = new Random();
int r1 = rnd.nextInt(); // любое int
int r2 = rnd.nextInt(100); // [0, 100)
int r3 = rnd.nextInt(50) + 1; // [1, 50]
System.out.println(r2);
System.out.println(r3);
// Начиная с Java 17 — RandomGenerator:
// int r = java.util.random.RandomGenerator.getDefault().nextInt(1, 101);
```
---
## 9. Мини-пример: сумма цифр числа
```java
import java.util.Scanner;
public class SumDigits {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Введите целое число: ");
long n = Math.abs(sc.nextLong());
int sum = 0;
while (n > 0) {
sum += (int)(n % 10); // последняя цифра
n /= 10; // отбрасываем её
}
System.out.println(sum);
}
}
```
Здесь задействованы: `long`, `%` и `/`, приведение типов, ввод/вывод, `Math.abs`.
---
## 10. Типичные ошибки
| Ошибка | Как избежать |
|--------|--------------|
| Деление нацело вместо дробного | Привести один операнд: `(double) a / b` |
| Переполнение `int` | Использовать `long` или `Math.addExact` (бросает исключение) |
| Сравнение обёрток через `==` | Использовать `.equals()` |
| Забыть `L` у большого литерала | `long x = 3000000000L;` |
| `NullPointerException` при распаковке | Проверять на `null` перед присваиванием в примитив |
| Потеря точности при `(int) longValue` | Проверять диапазон или использовать `Math.toIntExact` |
```java
// Безопасные операции (Java 8+):
int sum = Math.addExact(1_000_000_000, 1_000_000_000); // ArithmeticException
int prod = Math.multiplyExact(100_000, 100_000); // исключение
```
---
## 11. Итоги
- В Java 4 примитивных целочисленных типа; основной — `int`, для больших значений — `long`.
- По умолчанию целые литералы — `int`, для `long` нужен суффикс `L`.
- Деление целых **отбрасывает** дробную часть, остаток даёт `%`.
- Для чисел > 9.2·10¹⁸ используйте `BigInteger`.
- Для коллекций и `null` — классы-обёртки (`Integer`, `Long`, ...).
- Всегда проверяйте возможность **переполнения** и корректность приведения типов.
input/problems.html
+267
View File
@@ -0,0 +1,267 @@
<h1 id="задач-по-теме-целые-числа-на-java">10 задач по теме «Целые
числа» на Java</h1>
<p>Все решения используют только арифметические операторы
(<code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>,
<code>%</code>) и стандартный ввод/вывод. Без <code>if</code>,
<code>for</code>, <code>while</code>, <code>switch</code> и без создания
собственных функций.</p>
<hr />
<h2 id="задача-1.-сумма-и-произведение-цифр-двузначного-числа">Задача 1.
Сумма и произведение цифр двузначного числа</h2>
<p><strong>Условие:</strong> Дано двузначное число. Найти сумму и
произведение его цифр.</p>
<table>
<thead>
<tr>
<th><strong>Ввод:</strong></th>
<th><strong>Вывод:</strong></th>
</tr>
</thead>
<tbody>
<tr>
<td>47</td>
<td>11 28</td>
</tr>
</tbody>
</table>
<p><strong>Решение:</strong></p>
<div class="sourceCode" id="cb1"><pre
class="sourceCode java"><code class="sourceCode java"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> <span class="im">java</span><span class="op">.</span><span class="im">util</span><span class="op">.</span><span class="im">Scanner</span><span class="op">;</span></span>
<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a><span class="kw">public</span> <span class="kw">class</span> Task1 <span class="op">{</span></span>
<span id="cb1-4"><a href="#cb1-4" aria-hidden="true" tabindex="-1"></a> <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span><span class="op">(</span><span class="bu">String</span><span class="op">[]</span> args<span class="op">)</span> <span class="op">{</span></span>
<span id="cb1-5"><a href="#cb1-5" aria-hidden="true" tabindex="-1"></a> <span class="bu">Scanner</span> sc <span class="op">=</span> <span class="kw">new</span> <span class="bu">Scanner</span><span class="op">(</span><span class="bu">System</span><span class="op">.</span><span class="fu">in</span><span class="op">);</span></span>
<span id="cb1-6"><a href="#cb1-6" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> n <span class="op">=</span> sc<span class="op">.</span><span class="fu">nextInt</span><span class="op">();</span></span>
<span id="cb1-7"><a href="#cb1-7" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> a <span class="op">=</span> n <span class="op">/</span> <span class="dv">10</span><span class="op">;</span></span>
<span id="cb1-8"><a href="#cb1-8" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> b <span class="op">=</span> n <span class="op">%</span> <span class="dv">10</span><span class="op">;</span></span>
<span id="cb1-9"><a href="#cb1-9" aria-hidden="true" tabindex="-1"></a> <span class="bu">System</span><span class="op">.</span><span class="fu">out</span><span class="op">.</span><span class="fu">println</span><span class="op">(</span>a <span class="op">+</span> b<span class="op">);</span></span>
<span id="cb1-10"><a href="#cb1-10" aria-hidden="true" tabindex="-1"></a> <span class="bu">System</span><span class="op">.</span><span class="fu">out</span><span class="op">.</span><span class="fu">println</span><span class="op">(</span>a <span class="op">*</span> b<span class="op">);</span></span>
<span id="cb1-11"><a href="#cb1-11" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
<span id="cb1-12"><a href="#cb1-12" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
<hr />
<h2 id="задача-2.-число-обратное-двузначному">Задача 2. Число, обратное
двузначному</h2>
<p><strong>Условие:</strong> Дано двузначное число. Получить число,
записанное теми же цифрами в обратном порядке.</p>
<table>
<thead>
<tr>
<th><strong>Ввод:</strong></th>
<th><strong>Вывод:</strong></th>
</tr>
</thead>
<tbody>
<tr>
<td>47</td>
<td>74</td>
</tr>
</tbody>
</table>
<p><strong>Решение:</strong></p>
<div class="sourceCode" id="cb2"><pre
class="sourceCode java"><code class="sourceCode java"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> <span class="im">java</span><span class="op">.</span><span class="im">util</span><span class="op">.</span><span class="im">Scanner</span><span class="op">;</span></span>
<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a><span class="kw">public</span> <span class="kw">class</span> Task2 <span class="op">{</span></span>
<span id="cb2-4"><a href="#cb2-4" aria-hidden="true" tabindex="-1"></a> <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span><span class="op">(</span><span class="bu">String</span><span class="op">[]</span> args<span class="op">)</span> <span class="op">{</span></span>
<span id="cb2-5"><a href="#cb2-5" aria-hidden="true" tabindex="-1"></a> <span class="bu">Scanner</span> sc <span class="op">=</span> <span class="kw">new</span> <span class="bu">Scanner</span><span class="op">(</span><span class="bu">System</span><span class="op">.</span><span class="fu">in</span><span class="op">);</span></span>
<span id="cb2-6"><a href="#cb2-6" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> n <span class="op">=</span> sc<span class="op">.</span><span class="fu">nextInt</span><span class="op">();</span></span>
<span id="cb2-7"><a href="#cb2-7" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> result <span class="op">=</span> <span class="op">(</span>n <span class="op">%</span> <span class="dv">10</span><span class="op">)</span> <span class="op">*</span> <span class="dv">10</span> <span class="op">+</span> <span class="op">(</span>n <span class="op">/</span> <span class="dv">10</span><span class="op">);</span></span>
<span id="cb2-8"><a href="#cb2-8" aria-hidden="true" tabindex="-1"></a> <span class="bu">System</span><span class="op">.</span><span class="fu">out</span><span class="op">.</span><span class="fu">println</span><span class="op">(</span>result<span class="op">);</span></span>
<span id="cb2-9"><a href="#cb2-9" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
<span id="cb2-10"><a href="#cb2-10" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
<hr />
<h2 id="задача-3.-сумма-цифр-трёхзначного-числа">Задача 3. Сумма цифр
трёхзначного числа</h2>
<p><strong>Условие:</strong> Дано трёхзначное число. Найти сумму его
цифр.</p>
<table>
<thead>
<tr>
<th><strong>Ввод:</strong></th>
<th><strong>Вывод:</strong></th>
</tr>
</thead>
<tbody>
<tr>
<td>385</td>
<td>16</td>
</tr>
</tbody>
</table>
<p><strong>Решение:</strong></p>
<div class="sourceCode" id="cb3"><pre
class="sourceCode java"><code class="sourceCode java"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> <span class="im">java</span><span class="op">.</span><span class="im">util</span><span class="op">.</span><span class="im">Scanner</span><span class="op">;</span></span>
<span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb3-3"><a href="#cb3-3" aria-hidden="true" tabindex="-1"></a><span class="kw">public</span> <span class="kw">class</span> Task3 <span class="op">{</span></span>
<span id="cb3-4"><a href="#cb3-4" aria-hidden="true" tabindex="-1"></a> <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span><span class="op">(</span><span class="bu">String</span><span class="op">[]</span> args<span class="op">)</span> <span class="op">{</span></span>
<span id="cb3-5"><a href="#cb3-5" aria-hidden="true" tabindex="-1"></a> <span class="bu">Scanner</span> sc <span class="op">=</span> <span class="kw">new</span> <span class="bu">Scanner</span><span class="op">(</span><span class="bu">System</span><span class="op">.</span><span class="fu">in</span><span class="op">);</span></span>
<span id="cb3-6"><a href="#cb3-6" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> n <span class="op">=</span> sc<span class="op">.</span><span class="fu">nextInt</span><span class="op">();</span></span>
<span id="cb3-7"><a href="#cb3-7" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> sum <span class="op">=</span> n <span class="op">/</span> <span class="dv">100</span> <span class="op">+</span> <span class="op">(</span>n <span class="op">/</span> <span class="dv">10</span><span class="op">)</span> <span class="op">%</span> <span class="dv">10</span> <span class="op">+</span> n <span class="op">%</span> <span class="dv">10</span><span class="op">;</span></span>
<span id="cb3-8"><a href="#cb3-8" aria-hidden="true" tabindex="-1"></a> <span class="bu">System</span><span class="op">.</span><span class="fu">out</span><span class="op">.</span><span class="fu">println</span><span class="op">(</span>sum<span class="op">);</span></span>
<span id="cb3-9"><a href="#cb3-9" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
<span id="cb3-10"><a href="#cb3-10" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
<hr />
<h2 id="задача-4.-перевод-секунд-в-часы-минуты-и-секунды">Задача 4.
Перевод секунд в часы, минуты и секунды</h2>
<p><strong>Условие:</strong> Дано целое число секунд <code>t</code>.
Перевести в часы, минуты и секунды.</p>
<table>
<thead>
<tr>
<th><strong>Ввод:</strong></th>
<th><strong>Вывод:</strong></th>
</tr>
</thead>
<tbody>
<tr>
<td>7265</td>
<td>2 1 5</td>
</tr>
</tbody>
</table>
<p><strong>Решение:</strong></p>
<div class="sourceCode" id="cb4"><pre
class="sourceCode java"><code class="sourceCode java"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> <span class="im">java</span><span class="op">.</span><span class="im">util</span><span class="op">.</span><span class="im">Scanner</span><span class="op">;</span></span>
<span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a><span class="kw">public</span> <span class="kw">class</span> Task4 <span class="op">{</span></span>
<span id="cb4-4"><a href="#cb4-4" aria-hidden="true" tabindex="-1"></a> <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span><span class="op">(</span><span class="bu">String</span><span class="op">[]</span> args<span class="op">)</span> <span class="op">{</span></span>
<span id="cb4-5"><a href="#cb4-5" aria-hidden="true" tabindex="-1"></a> <span class="bu">Scanner</span> sc <span class="op">=</span> <span class="kw">new</span> <span class="bu">Scanner</span><span class="op">(</span><span class="bu">System</span><span class="op">.</span><span class="fu">in</span><span class="op">);</span></span>
<span id="cb4-6"><a href="#cb4-6" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> t <span class="op">=</span> sc<span class="op">.</span><span class="fu">nextInt</span><span class="op">();</span></span>
<span id="cb4-7"><a href="#cb4-7" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> h <span class="op">=</span> t <span class="op">/</span> <span class="dv">3600</span><span class="op">;</span></span>
<span id="cb4-8"><a href="#cb4-8" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> m <span class="op">=</span> <span class="op">(</span>t <span class="op">%</span> <span class="dv">3600</span><span class="op">)</span> <span class="op">/</span> <span class="dv">60</span><span class="op">;</span></span>
<span id="cb4-9"><a href="#cb4-9" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> s <span class="op">=</span> t <span class="op">%</span> <span class="dv">60</span><span class="op">;</span></span>
<span id="cb4-10"><a href="#cb4-10" aria-hidden="true" tabindex="-1"></a> <span class="bu">System</span><span class="op">.</span><span class="fu">out</span><span class="op">.</span><span class="fu">println</span><span class="op">(</span>h<span class="op">);</span></span>
<span id="cb4-11"><a href="#cb4-11" aria-hidden="true" tabindex="-1"></a> <span class="bu">System</span><span class="op">.</span><span class="fu">out</span><span class="op">.</span><span class="fu">println</span><span class="op">(</span>m<span class="op">);</span></span>
<span id="cb4-12"><a href="#cb4-12" aria-hidden="true" tabindex="-1"></a> <span class="bu">System</span><span class="op">.</span><span class="fu">out</span><span class="op">.</span><span class="fu">println</span><span class="op">(</span>s<span class="op">);</span></span>
<span id="cb4-13"><a href="#cb4-13" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
<span id="cb4-14"><a href="#cb4-14" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
<hr />
<h2 id="задача-5.-последняя-цифра-числа-в-степени">Задача 5. Последняя
цифра числа в степени</h2>
<p><strong>Условие:</strong> Дано число <code>n</code>. Найти последнюю
цифру числа <code>n²</code>.</p>
<table>
<thead>
<tr>
<th><strong>Ввод:</strong></th>
<th><strong>Вывод:</strong></th>
</tr>
</thead>
<tbody>
<tr>
<td>37</td>
<td></td>
</tr>
</tbody>
</table>
<p><strong>Решение:</strong></p>
<div class="sourceCode" id="cb5"><pre
class="sourceCode java"><code class="sourceCode java"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> <span class="im">java</span><span class="op">.</span><span class="im">util</span><span class="op">.</span><span class="im">Scanner</span><span class="op">;</span></span>
<span id="cb5-2"><a href="#cb5-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb5-3"><a href="#cb5-3" aria-hidden="true" tabindex="-1"></a><span class="kw">public</span> <span class="kw">class</span> Task5 <span class="op">{</span></span>
<span id="cb5-4"><a href="#cb5-4" aria-hidden="true" tabindex="-1"></a> <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span><span class="op">(</span><span class="bu">String</span><span class="op">[]</span> args<span class="op">)</span> <span class="op">{</span></span>
<span id="cb5-5"><a href="#cb5-5" aria-hidden="true" tabindex="-1"></a> <span class="bu">Scanner</span> sc <span class="op">=</span> <span class="kw">new</span> <span class="bu">Scanner</span><span class="op">(</span><span class="bu">System</span><span class="op">.</span><span class="fu">in</span><span class="op">);</span></span>
<span id="cb5-6"><a href="#cb5-6" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> n <span class="op">=</span> sc<span class="op">.</span><span class="fu">nextInt</span><span class="op">();</span></span>
<span id="cb5-7"><a href="#cb5-7" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> last <span class="op">=</span> n <span class="op">%</span> <span class="dv">10</span><span class="op">;</span></span>
<span id="cb5-8"><a href="#cb5-8" aria-hidden="true" tabindex="-1"></a> <span class="bu">System</span><span class="op">.</span><span class="fu">out</span><span class="op">.</span><span class="fu">println</span><span class="op">((</span>last <span class="op">*</span> last <span class="op">*</span> last <span class="op">*</span> last<span class="op">)</span> <span class="op">%</span> <span class="dv">10</span><span class="op">);</span></span>
<span id="cb5-9"><a href="#cb5-9" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
<span id="cb5-10"><a href="#cb5-10" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
<hr />
<h2
id="задача-7.-обмен-цифр-трёхзначного-числа-циклический-сдвиг">Задача 7.
Обмен цифр трёхзначного числа (циклический сдвиг)</h2>
<p><strong>Условие:</strong> Дано трёхзначное число <code>abc</code>.
Получить число <code>bca</code> (первую цифру в конец).</p>
<table>
<thead>
<tr>
<th><strong>Ввод:</strong></th>
<th><strong>Вывод:</strong></th>
</tr>
</thead>
<tbody>
<tr>
<td>385</td>
<td>853</td>
</tr>
</tbody>
</table>
<p><strong>Решение:</strong></p>
<div class="sourceCode" id="cb6"><pre
class="sourceCode java"><code class="sourceCode java"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> <span class="im">java</span><span class="op">.</span><span class="im">util</span><span class="op">.</span><span class="im">Scanner</span><span class="op">;</span></span>
<span id="cb6-2"><a href="#cb6-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb6-3"><a href="#cb6-3" aria-hidden="true" tabindex="-1"></a><span class="kw">public</span> <span class="kw">class</span> Task7 <span class="op">{</span></span>
<span id="cb6-4"><a href="#cb6-4" aria-hidden="true" tabindex="-1"></a> <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span><span class="op">(</span><span class="bu">String</span><span class="op">[]</span> args<span class="op">)</span> <span class="op">{</span></span>
<span id="cb6-5"><a href="#cb6-5" aria-hidden="true" tabindex="-1"></a> <span class="bu">Scanner</span> sc <span class="op">=</span> <span class="kw">new</span> <span class="bu">Scanner</span><span class="op">(</span><span class="bu">System</span><span class="op">.</span><span class="fu">in</span><span class="op">);</span></span>
<span id="cb6-6"><a href="#cb6-6" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> n <span class="op">=</span> sc<span class="op">.</span><span class="fu">nextInt</span><span class="op">();</span></span>
<span id="cb6-7"><a href="#cb6-7" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> a <span class="op">=</span> n <span class="op">/</span> <span class="dv">100</span><span class="op">;</span></span>
<span id="cb6-8"><a href="#cb6-8" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> b <span class="op">=</span> <span class="op">(</span>n <span class="op">/</span> <span class="dv">10</span><span class="op">)</span> <span class="op">%</span> <span class="dv">10</span><span class="op">;</span></span>
<span id="cb6-9"><a href="#cb6-9" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> c <span class="op">=</span> n <span class="op">%</span> <span class="dv">10</span><span class="op">;</span></span>
<span id="cb6-10"><a href="#cb6-10" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> result <span class="op">=</span> b <span class="op">*</span> <span class="dv">100</span> <span class="op">+</span> c <span class="op">*</span> <span class="dv">10</span> <span class="op">+</span> a<span class="op">;</span></span>
<span id="cb6-11"><a href="#cb6-11" aria-hidden="true" tabindex="-1"></a> <span class="bu">System</span><span class="op">.</span><span class="fu">out</span><span class="op">.</span><span class="fu">println</span><span class="op">(</span>result<span class="op">);</span></span>
<span id="cb6-12"><a href="#cb6-12" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
<span id="cb6-13"><a href="#cb6-13" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
<hr />
<h2 id="задача-8.-сумма-цифр-четырёхзначного-числа">Задача 8. Сумма цифр
четырёхзначного числа</h2>
<p><strong>Условие:</strong> Дано четырёхзначное число. Найти сумму его
цифр.</p>
<table>
<thead>
<tr>
<th><strong>Ввод:</strong></th>
<th><strong>Вывод:</strong></th>
</tr>
</thead>
<tbody>
<tr>
<td>1234</td>
<td>10</td>
</tr>
</tbody>
</table>
<p><strong>Решение:</strong></p>
<div class="sourceCode" id="cb7"><pre
class="sourceCode java"><code class="sourceCode java"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> <span class="im">java</span><span class="op">.</span><span class="im">util</span><span class="op">.</span><span class="im">Scanner</span><span class="op">;</span></span>
<span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb7-3"><a href="#cb7-3" aria-hidden="true" tabindex="-1"></a><span class="kw">public</span> <span class="kw">class</span> Task8 <span class="op">{</span></span>
<span id="cb7-4"><a href="#cb7-4" aria-hidden="true" tabindex="-1"></a> <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span><span class="op">(</span><span class="bu">String</span><span class="op">[]</span> args<span class="op">)</span> <span class="op">{</span></span>
<span id="cb7-5"><a href="#cb7-5" aria-hidden="true" tabindex="-1"></a> <span class="bu">Scanner</span> sc <span class="op">=</span> <span class="kw">new</span> <span class="bu">Scanner</span><span class="op">(</span><span class="bu">System</span><span class="op">.</span><span class="fu">in</span><span class="op">);</span></span>
<span id="cb7-6"><a href="#cb7-6" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> n <span class="op">=</span> sc<span class="op">.</span><span class="fu">nextInt</span><span class="op">();</span></span>
<span id="cb7-7"><a href="#cb7-7" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> sum <span class="op">=</span> n <span class="op">/</span> <span class="dv">1000</span> <span class="op">+</span> <span class="op">(</span>n <span class="op">/</span> <span class="dv">100</span><span class="op">)</span> <span class="op">%</span> <span class="dv">10</span> <span class="op">+</span> <span class="op">(</span>n <span class="op">/</span> <span class="dv">10</span><span class="op">)</span> <span class="op">%</span> <span class="dv">10</span> <span class="op">+</span> n <span class="op">%</span> <span class="dv">10</span><span class="op">;</span></span>
<span id="cb7-8"><a href="#cb7-8" aria-hidden="true" tabindex="-1"></a> <span class="bu">System</span><span class="op">.</span><span class="fu">out</span><span class="op">.</span><span class="fu">println</span><span class="op">(</span>sum<span class="op">);</span></span>
<span id="cb7-9"><a href="#cb7-9" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
<span id="cb7-10"><a href="#cb7-10" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
<hr />
<h2 id="задача-9.-количество-полных-минут-в-сутках">Задача 9. Количество
полных минут в сутках</h2>
<p><strong>Условие:</strong> Дано число минут <code>m</code>. Найти
количество полных суток и остаток минут.</p>
<table>
<thead>
<tr>
<th><strong>Ввод:</strong></th>
<th><strong>Вывод:</strong></th>
</tr>
</thead>
<tbody>
<tr>
<td>5000</td>
<td>3 680</td>
</tr>
</tbody>
</table>
<p><strong>Решение:</strong></p>
<div class="sourceCode" id="cb8"><pre
class="sourceCode java"><code class="sourceCode java"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> <span class="im">java</span><span class="op">.</span><span class="im">util</span><span class="op">.</span><span class="im">Scanner</span><span class="op">;</span></span>
<span id="cb8-2"><a href="#cb8-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb8-3"><a href="#cb8-3" aria-hidden="true" tabindex="-1"></a><span class="kw">public</span> <span class="kw">class</span> Task9 <span class="op">{</span></span>
<span id="cb8-4"><a href="#cb8-4" aria-hidden="true" tabindex="-1"></a> <span class="kw">public</span> <span class="dt">static</span> <span class="dt">void</span> <span class="fu">main</span><span class="op">(</span><span class="bu">String</span><span class="op">[]</span> args<span class="op">)</span> <span class="op">{</span></span>
<span id="cb8-5"><a href="#cb8-5" aria-hidden="true" tabindex="-1"></a> <span class="bu">Scanner</span> sc <span class="op">=</span> <span class="kw">new</span> <span class="bu">Scanner</span><span class="op">(</span><span class="bu">System</span><span class="op">.</span><span class="fu">in</span><span class="op">);</span></span>
<span id="cb8-6"><a href="#cb8-6" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> m <span class="op">=</span> sc<span class="op">.</span><span class="fu">nextInt</span><span class="op">();</span></span>
<span id="cb8-7"><a href="#cb8-7" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> days <span class="op">=</span> m <span class="op">/</span> <span class="dv">1440</span><span class="op">;</span></span>
<span id="cb8-8"><a href="#cb8-8" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> rest <span class="op">=</span> m <span class="op">%</span> <span class="dv">1440</span><span class="op">;</span></span>
<span id="cb8-9"><a href="#cb8-9" aria-hidden="true" tabindex="-1"></a> <span class="bu">System</span><span class="op">.</span><span class="fu">out</span><span class="op">.</span><span class="fu">println</span><span class="op">(</span>days<span class="op">);</span></span>
<span id="cb8-10"><a href="#cb8-10" aria-hidden="true" tabindex="-1"></a> <span class="bu">System</span><span class="op">.</span><span class="fu">out</span><span class="op">.</span><span class="fu">println</span><span class="op">(</span>rest<span class="op">);</span></span>
<span id="cb8-11"><a href="#cb8-11" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
<span id="cb8-12"><a href="#cb8-12" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
input/problems.md
+210
View File
@@ -0,0 +1,210 @@
# 10 задач по теме «Целые числа» на Java
Все решения используют только арифметические операторы (`+`, `-`, `*`, `/`, `%`) и стандартный ввод/вывод. Без `if`, `for`, `while`, `switch` и без создания собственных функций.
---
## Задача 1. Сумма и произведение цифр двузначного числа
**Условие:** Дано двузначное число. Найти сумму и произведение его цифр.
|**Ввод:** |**Вывод:**|
|--|--|
| 47 | 11 28 |
**Решение:**
```java
import java.util.Scanner;
public class Task1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a = n / 10;
int b = n % 10;
System.out.println(a + b);
System.out.println(a * b);
}
}
```
---
## Задача 2. Число, обратное двузначному
**Условие:** Дано двузначное число. Получить число, записанное теми же цифрами в обратном порядке.
|**Ввод:** |**Вывод:**|
|--|--|
| 47 | 74 |
**Решение:**
```java
import java.util.Scanner;
public class Task2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int result = (n % 10) * 10 + (n / 10);
System.out.println(result);
}
}
```
---
## Задача 3. Сумма цифр трёхзначного числа
**Условие:** Дано трёхзначное число. Найти сумму его цифр.
|**Ввод:** |**Вывод:**|
|--|--|
| 385 | 16 |
**Решение:**
```java
import java.util.Scanner;
public class Task3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int sum = n / 100 + (n / 10) % 10 + n % 10;
System.out.println(sum);
}
}
```
---
## Задача 4. Перевод секунд в часы, минуты и секунды
**Условие:** Дано целое число секунд `t`. Перевести в часы, минуты и секунды.
|**Ввод:** |**Вывод:**|
|--|--|
| 7265 | 2 1 5 |
**Решение:**
```java
import java.util.Scanner;
public class Task4 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
int h = t / 3600;
int m = (t % 3600) / 60;
int s = t % 60;
System.out.println(h);
System.out.println(m);
System.out.println(s);
}
}
```
---
## Задача 5. Последняя цифра числа в степени
**Условие:** Дано число `n`. Найти последнюю цифру числа `n²`.
|**Ввод:** |**Вывод:**|
|--|--|
| 37 | |
**Решение:**
```java
import java.util.Scanner;
public class Task5 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int last = n % 10;
System.out.println((last * last * last * last) % 10);
}
}
```
---
## Задача 7. Обмен цифр трёхзначного числа (циклический сдвиг)
**Условие:** Дано трёхзначное число `abc`. Получить число `bca` (первую цифру в конец).
|**Ввод:** |**Вывод:**|
|--|--|
| 385 | 853 |
**Решение:**
```java
import java.util.Scanner;
public class Task7 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a = n / 100;
int b = (n / 10) % 10;
int c = n % 10;
int result = b * 100 + c * 10 + a;
System.out.println(result);
}
}
```
---
## Задача 8. Сумма цифр четырёхзначного числа
**Условие:** Дано четырёхзначное число. Найти сумму его цифр.
|**Ввод:** |**Вывод:**|
|--|--|
| 1234 | 10 |
**Решение:**
```java
import java.util.Scanner;
public class Task8 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int sum = n / 1000 + (n / 100) % 10 + (n / 10) % 10 + n % 10;
System.out.println(sum);
}
}
```
---
## Задача 9. Количество полных минут в сутках
**Условие:** Дано число минут `m`. Найти количество полных суток и остаток минут.
|**Ввод:** |**Вывод:**|
|--|--|
| 5000 | 3 680 |
**Решение:**
```java
import java.util.Scanner;
public class Task9 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
int days = m / 1440;
int rest = m % 1440;
System.out.println(days);
System.out.println(rest);
}
}
```
input/problems.txt
+220
View File
@@ -0,0 +1,220 @@
# 10 задач по теме «Целые числа» на Java
Все решения используют только арифметические операторы (`+`, `-`, `*`,
`/`, `%`) и стандартный ввод/вывод. Без `if`, `for`, `while`, `switch` и
без создания собственных функций.
------------------------------------------------------------------------
## Задача 1. Сумма и произведение цифр двузначного числа
**Условие:** Дано двузначное число. Найти сумму и произведение его цифр.
**Ввод:** **Вывод:**
----------- ------------
47 11 28
**Решение:**
``` java
import java.util.Scanner;
public class Task1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a = n / 10;
int b = n % 10;
System.out.println(a + b);
System.out.println(a * b);
}
}
```
------------------------------------------------------------------------
## Задача 2. Число, обратное двузначному
**Условие:** Дано двузначное число. Получить число, записанное теми же
цифрами в обратном порядке.
**Ввод:** **Вывод:**
----------- ------------
47 74
**Решение:**
``` java
import java.util.Scanner;
public class Task2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int result = (n % 10) * 10 + (n / 10);
System.out.println(result);
}
}
```
------------------------------------------------------------------------
## Задача 3. Сумма цифр трёхзначного числа
**Условие:** Дано трёхзначное число. Найти сумму его цифр.
**Ввод:** **Вывод:**
----------- ------------
385 16
**Решение:**
``` java
import java.util.Scanner;
public class Task3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int sum = n / 100 + (n / 10) % 10 + n % 10;
System.out.println(sum);
}
}
```
------------------------------------------------------------------------
## Задача 4. Перевод секунд в часы, минуты и секунды
**Условие:** Дано целое число секунд `t`. Перевести в часы, минуты и
секунды.
**Ввод:** **Вывод:**
----------- ------------
7265 2 1 5
**Решение:**
``` java
import java.util.Scanner;
public class Task4 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
int h = t / 3600;
int m = (t % 3600) / 60;
int s = t % 60;
System.out.println(h);
System.out.println(m);
System.out.println(s);
}
}
```
------------------------------------------------------------------------
## Задача 5. Последняя цифра числа в степени
**Условие:** Дано число `n`. Найти последнюю цифру числа `n²`.
**Ввод:** **Вывод:**
----------- ------------
37
**Решение:**
``` java
import java.util.Scanner;
public class Task5 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int last = n % 10;
System.out.println((last * last * last * last) % 10);
}
}
```
------------------------------------------------------------------------
## Задача 7. Обмен цифр трёхзначного числа (циклический сдвиг)
**Условие:** Дано трёхзначное число `abc`. Получить число `bca` (первую
цифру в конец).
**Ввод:** **Вывод:**
----------- ------------
385 853
**Решение:**
``` java
import java.util.Scanner;
public class Task7 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a = n / 100;
int b = (n / 10) % 10;
int c = n % 10;
int result = b * 100 + c * 10 + a;
System.out.println(result);
}
}
```
------------------------------------------------------------------------
## Задача 8. Сумма цифр четырёхзначного числа
**Условие:** Дано четырёхзначное число. Найти сумму его цифр.
**Ввод:** **Вывод:**
----------- ------------
1234 10
**Решение:**
``` java
import java.util.Scanner;
public class Task8 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int sum = n / 1000 + (n / 100) % 10 + (n / 10) % 10 + n % 10;
System.out.println(sum);
}
}
```
------------------------------------------------------------------------
## Задача 9. Количество полных минут в сутках
**Условие:** Дано число минут `m`. Найти количество полных суток и
остаток минут.
**Ввод:** **Вывод:**
----------- ------------
5000 3 680
**Решение:**
``` java
import java.util.Scanner;
public class Task9 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
int days = m / 1440;
int rest = m % 1440;
System.out.println(days);
System.out.println(rest);
}
}
```
input/problems.xml
+377
View File
@@ -0,0 +1,377 @@
<?xml version='1.0' ?>
<Pandoc api-version="1,23,1,2">
<meta />
<blocks>
<Header id="задач-по-теме-целые-числа-на-java" level="1">10 задач по теме «Целые числа» на Java</Header>
<Para>Все решения используют только арифметические операторы (<Code>+</Code>, <Code>-</Code>, <Code>*</Code>, <Code>/</Code>, <Code>%</Code>) и стандартный ввод/вывод. Без <Code>if</Code>, <Code>for</Code>, <Code>while</Code>, <Code>switch</Code> и без создания собственных функций.</Para>
<HorizontalRule />
<Header id="задача-1.-сумма-и-произведение-цифр-двузначного-числа" level="2">Задача 1. Сумма и произведение цифр двузначного числа</Header>
<Para><Strong>Условие:</Strong> Дано двузначное число. Найти сумму и произведение его цифр.</Para>
<Table>
<Caption />
<colspecs>
<ColSpec alignment="AlignDefault" col-width="0" />
<ColSpec alignment="AlignDefault" col-width="0" />
</colspecs>
<TableHead>
<Row>
<Cell alignment="AlignDefault">
<Plain><Strong>Ввод:</Strong></Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain><Strong>Вывод:</Strong></Plain>
</Cell>
</Row>
</TableHead>
<TableBody row-head-columns="0">
<header />
<body>
<Row>
<Cell alignment="AlignDefault">
<Plain>47</Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain>11 28</Plain>
</Cell>
</Row>
</body>
</TableBody>
<TableFoot />
</Table>
<Para><Strong>Решение:</Strong></Para>
<CodeBlock class="java">import java.util.Scanner;
public class Task1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a = n / 10;
int b = n % 10;
System.out.println(a + b);
System.out.println(a * b);
}
}</CodeBlock>
<HorizontalRule />
<Header id="задача-2.-число-обратное-двузначному" level="2">Задача 2. Число, обратное двузначному</Header>
<Para><Strong>Условие:</Strong> Дано двузначное число. Получить число, записанное теми же цифрами в обратном порядке.</Para>
<Table>
<Caption />
<colspecs>
<ColSpec alignment="AlignDefault" col-width="0" />
<ColSpec alignment="AlignDefault" col-width="0" />
</colspecs>
<TableHead>
<Row>
<Cell alignment="AlignDefault">
<Plain><Strong>Ввод:</Strong></Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain><Strong>Вывод:</Strong></Plain>
</Cell>
</Row>
</TableHead>
<TableBody row-head-columns="0">
<header />
<body>
<Row>
<Cell alignment="AlignDefault">
<Plain>47</Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain>74</Plain>
</Cell>
</Row>
</body>
</TableBody>
<TableFoot />
</Table>
<Para><Strong>Решение:</Strong></Para>
<CodeBlock class="java">import java.util.Scanner;
public class Task2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int result = (n % 10) * 10 + (n / 10);
System.out.println(result);
}
}</CodeBlock>
<HorizontalRule />
<Header id="задача-3.-сумма-цифр-трёхзначного-числа" level="2">Задача 3. Сумма цифр трёхзначного числа</Header>
<Para><Strong>Условие:</Strong> Дано трёхзначное число. Найти сумму его цифр.</Para>
<Table>
<Caption />
<colspecs>
<ColSpec alignment="AlignDefault" col-width="0" />
<ColSpec alignment="AlignDefault" col-width="0" />
</colspecs>
<TableHead>
<Row>
<Cell alignment="AlignDefault">
<Plain><Strong>Ввод:</Strong></Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain><Strong>Вывод:</Strong></Plain>
</Cell>
</Row>
</TableHead>
<TableBody row-head-columns="0">
<header />
<body>
<Row>
<Cell alignment="AlignDefault">
<Plain>385</Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain>16</Plain>
</Cell>
</Row>
</body>
</TableBody>
<TableFoot />
</Table>
<Para><Strong>Решение:</Strong></Para>
<CodeBlock class="java">import java.util.Scanner;
public class Task3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int sum = n / 100 + (n / 10) % 10 + n % 10;
System.out.println(sum);
}
}</CodeBlock>
<HorizontalRule />
<Header id="задача-4.-перевод-секунд-в-часы-минуты-и-секунды" level="2">Задача 4. Перевод секунд в часы, минуты и секунды</Header>
<Para><Strong>Условие:</Strong> Дано целое число секунд <Code>t</Code>. Перевести в часы, минуты и секунды.</Para>
<Table>
<Caption />
<colspecs>
<ColSpec alignment="AlignDefault" col-width="0" />
<ColSpec alignment="AlignDefault" col-width="0" />
</colspecs>
<TableHead>
<Row>
<Cell alignment="AlignDefault">
<Plain><Strong>Ввод:</Strong></Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain><Strong>Вывод:</Strong></Plain>
</Cell>
</Row>
</TableHead>
<TableBody row-head-columns="0">
<header />
<body>
<Row>
<Cell alignment="AlignDefault">
<Plain>7265</Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain>2 1 5</Plain>
</Cell>
</Row>
</body>
</TableBody>
<TableFoot />
</Table>
<Para><Strong>Решение:</Strong></Para>
<CodeBlock class="java">import java.util.Scanner;
public class Task4 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
int h = t / 3600;
int m = (t % 3600) / 60;
int s = t % 60;
System.out.println(h);
System.out.println(m);
System.out.println(s);
}
}</CodeBlock>
<HorizontalRule />
<Header id="задача-5.-последняя-цифра-числа-в-степени" level="2">Задача 5. Последняя цифра числа в степени</Header>
<Para><Strong>Условие:</Strong> Дано число <Code>n</Code>. Найти последнюю цифру числа <Code>n²</Code>.</Para>
<Table>
<Caption />
<colspecs>
<ColSpec alignment="AlignDefault" col-width="0" />
<ColSpec alignment="AlignDefault" col-width="0" />
</colspecs>
<TableHead>
<Row>
<Cell alignment="AlignDefault">
<Plain><Strong>Ввод:</Strong></Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain><Strong>Вывод:</Strong></Plain>
</Cell>
</Row>
</TableHead>
<TableBody row-head-columns="0">
<header />
<body>
<Row>
<Cell alignment="AlignDefault">
<Plain>37</Plain>
</Cell>
<Cell alignment="AlignDefault" />
</Row>
</body>
</TableBody>
<TableFoot />
</Table>
<Para><Strong>Решение:</Strong></Para>
<CodeBlock class="java">import java.util.Scanner;
public class Task5 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int last = n % 10;
System.out.println((last * last * last * last) % 10);
}
}</CodeBlock>
<HorizontalRule />
<Header id="задача-7.-обмен-цифр-трёхзначного-числа-циклический-сдвиг" level="2">Задача 7. Обмен цифр трёхзначного числа (циклический сдвиг)</Header>
<Para><Strong>Условие:</Strong> Дано трёхзначное число <Code>abc</Code>. Получить число <Code>bca</Code> (первую цифру в конец).</Para>
<Table>
<Caption />
<colspecs>
<ColSpec alignment="AlignDefault" col-width="0" />
<ColSpec alignment="AlignDefault" col-width="0" />
</colspecs>
<TableHead>
<Row>
<Cell alignment="AlignDefault">
<Plain><Strong>Ввод:</Strong></Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain><Strong>Вывод:</Strong></Plain>
</Cell>
</Row>
</TableHead>
<TableBody row-head-columns="0">
<header />
<body>
<Row>
<Cell alignment="AlignDefault">
<Plain>385</Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain>853</Plain>
</Cell>
</Row>
</body>
</TableBody>
<TableFoot />
</Table>
<Para><Strong>Решение:</Strong></Para>
<CodeBlock class="java">import java.util.Scanner;
public class Task7 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a = n / 100;
int b = (n / 10) % 10;
int c = n % 10;
int result = b * 100 + c * 10 + a;
System.out.println(result);
}
}</CodeBlock>
<HorizontalRule />
<Header id="задача-8.-сумма-цифр-четырёхзначного-числа" level="2">Задача 8. Сумма цифр четырёхзначного числа</Header>
<Para><Strong>Условие:</Strong> Дано четырёхзначное число. Найти сумму его цифр.</Para>
<Table>
<Caption />
<colspecs>
<ColSpec alignment="AlignDefault" col-width="0" />
<ColSpec alignment="AlignDefault" col-width="0" />
</colspecs>
<TableHead>
<Row>
<Cell alignment="AlignDefault">
<Plain><Strong>Ввод:</Strong></Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain><Strong>Вывод:</Strong></Plain>
</Cell>
</Row>
</TableHead>
<TableBody row-head-columns="0">
<header />
<body>
<Row>
<Cell alignment="AlignDefault">
<Plain>1234</Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain>10</Plain>
</Cell>
</Row>
</body>
</TableBody>
<TableFoot />
</Table>
<Para><Strong>Решение:</Strong></Para>
<CodeBlock class="java">import java.util.Scanner;
public class Task8 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int sum = n / 1000 + (n / 100) % 10 + (n / 10) % 10 + n % 10;
System.out.println(sum);
}
}</CodeBlock>
<HorizontalRule />
<Header id="задача-9.-количество-полных-минут-в-сутках" level="2">Задача 9. Количество полных минут в сутках</Header>
<Para><Strong>Условие:</Strong> Дано число минут <Code>m</Code>. Найти количество полных суток и остаток минут.</Para>
<Table>
<Caption />
<colspecs>
<ColSpec alignment="AlignDefault" col-width="0" />
<ColSpec alignment="AlignDefault" col-width="0" />
</colspecs>
<TableHead>
<Row>
<Cell alignment="AlignDefault">
<Plain><Strong>Ввод:</Strong></Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain><Strong>Вывод:</Strong></Plain>
</Cell>
</Row>
</TableHead>
<TableBody row-head-columns="0">
<header />
<body>
<Row>
<Cell alignment="AlignDefault">
<Plain>5000</Plain>
</Cell>
<Cell alignment="AlignDefault">
<Plain>3 680</Plain>
</Cell>
</Row>
</body>
</TableBody>
<TableFoot />
</Table>
<Para><Strong>Решение:</Strong></Para>
<CodeBlock class="java">import java.util.Scanner;
public class Task9 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
int days = m / 1440;
int rest = m % 1440;
System.out.println(days);
System.out.println(rest);
}
}</CodeBlock>
</blocks>
</Pandoc>
input/problems2.md
+175
View File
@@ -0,0 +1,175 @@
# Задачи по побитовым операциям на Java
> **Условие:** без использования операторов выбора (`if`, `switch`, `?:`), циклов (`for`, `while`, `do`) и объявления новых функций. Только `main`, побитовые операции, арифметика и `System.out.println`.
---
## Задача 1. Умножить число на 4 без умножения
**Условие:** Дано целое число `n`. Получить `n * 4`, используя только побитовые операции.
|**Ввод:** |**Вывод:**|
|--|--|
| 5 | 20 |
**Решение:**
```java
public class Task1 {
public static void main(String[] args) {
int n = 5;
int result = n << 2; // сдвиг влево на 2 = умножение на 4
System.out.println(result);
}
}
```
---
## Задача 2. Разделить число на 2 без деления
**Условие:** Дано целое число `n`. Получить `n / 2`, используя только побитовые операции.
|**Ввод:** |**Вывод:**|
|--|--|
| 20 | 10 |
**Решение:**
```java
public class Task2 {
public static void main(String[] args) {
int n = 20;
int result = n >> 1; // сдвиг вправо на 1 = деление на 2
System.out.println(result);
}
}
```
---
## Задача 3. Проверить, чётное ли число
**Условие:** Дано целое число `n`. Вывести `1`, если оно чётное, и `0`, если нечётное.
|**Ввод:** |**Вывод:**|
|--|--|
| 7 | 0 |
**Решение:**
```java
public class Task3 {
public static void main(String[] args) {
int n = 7;
int result = (n & 1) ^ 1; // если младший бит 1 → 0, иначе → 1
System.out.println(result);
}
}
```
---
## Задача 4. Обнулить младший бит
**Условие:** Дано целое число `n`. Обнулить его самый младший установленный бит.
|**Ввод:** |**Вывод:**|
|--|--|
| 12 | 8 |
**Решение:**
```java
public class Task4 {
public static void main(String[] args) {
int n = 12;
int result = n & (n - 1); // трюк: убирает младший установленный бит
System.out.println(result);
}
}
```
---
## Задача 5. Установить k-й бит в 1
**Условие:** Даны число `n` и позиция `k` (нумерация с 0). Установить `k`-й бит в 1.
|**Ввод:** |**Вывод:**|
|--|--|
| 8 2 | 12 |
**Решение:**
```java
public class Task6 {
public static void main(String[] args) {
int n = 8; // 1000
int k = 2;
int result = n | (1 << k); // 1000 | 0100 = 1100 = 12
System.out.println(result);
}
}
```
---
## Задача 6. Инвертировать k-й бит
**Условие:** Даны число `n` и позиция `k`. Инвертировать `k`-й бит.
|**Ввод:** |**Вывод:**|
|--|--|
| 10 1 | 8 |
**Решение:**
```java
public class Task7 {
public static void main(String[] args) {
int n = 10; // 1010
int k = 1;
int result = n ^ (1 << k); // 1010 ^ 0010 = 1000 = 8
System.out.println(result);
}
}
```
---
## Задача 7. Умножить число на 5 без умножения
**Условие:** Дано целое число `n`. Получить `n * 5`, используя только сдвиги и сложение.
|**Ввод:** |**Вывод:**|
|--|--|
| 7 | 35 |
**Решение:**
```java
public class Task10 {
public static void main(String[] args) {
int n = 7;
int result = (n << 2) + n; // 4n + n = 5n
System.out.println(result);
}
}
```
---
## Задача 8. Умножить число на 3 без умножения
**Условие:** Дано целое число `n`. Получить `n * 3`, используя только сдвиги и сложение.
|**Ввод:** |**Вывод:**|
|--|--|
| 7 | 21 |
**Решение:**
```java
public class Task10 {
public static void main(String[] args) {
int n = 7;
int result = (n << 1) + n; // 2n + n = 3n
System.out.println(result);
}
}
```
justfile
+7 -1
View File
@@ -5,4 +5,10 @@ root := justfile_directory()
[working-directory: 'src/tasks_to_mdl'] [working-directory: 'src/tasks_to_mdl']
xml-to-dataclasses: xml-to-dataclasses:
uv run xsdata generate --package gen --include-header {{ root }}/input/nothing.xml uv run xsdata generate --package mdl --include-header {{ root }}/input/nothing.xml
[working-directory: 'src/tasks_to_mdl']
pandoc-to-dataclasses:
uv run xsdata generate --package pandoc --include-header {{ root }}/input/problems.xml
gen-dataclasses: pandoc-to-dataclasses xml-to-dataclasses
src/tasks_to_mdl/gen/__init__.py → src/tasks_to_mdl/mdl/__init__.py
+2 -2
View File
@@ -1,10 +1,10 @@
"""This file was generated by xsdata, v26.2, on 2026-09-14 16:00:22 """This file was generated by xsdata, v26.2, on 2026-09-14 19:25:20
Generator: DataclassGenerator Generator: DataclassGenerator
See: https://xsdata.readthedocs.io/ See: https://xsdata.readthedocs.io/
""" """
from gen.quiz import ( from mdl.quiz import (
Display, Display,
Expected, Expected,
Extra, Extra,
src/tasks_to_mdl/gen/quiz.py → src/tasks_to_mdl/mdl/quiz.py
+1 -1
View File
@@ -1,4 +1,4 @@
"""This file was generated by xsdata, v26.2, on 2026-09-14 16:00:22 """This file was generated by xsdata, v26.2, on 2026-09-14 19:25:20
Generator: DataclassGenerator Generator: DataclassGenerator
See: https://xsdata.readthedocs.io/ See: https://xsdata.readthedocs.io/
src/tasks_to_mdl/pandoc/__init__.py
+39
View File
@@ -0,0 +1,39 @@
"""This file was generated by xsdata, v26.2, on 2026-09-14 19:25:20
Generator: DataclassGenerator
See: https://xsdata.readthedocs.io/
"""
from pandoc.pandoc import (
Blocks,
Body,
Cell,
CodeBlock,
ColSpec,
Colspecs,
Header,
Pandoc,
Para,
Plain,
Row,
Table,
TableBody,
TableHead,
)
__all__ = [
"Cell",
"CodeBlock",
"ColSpec",
"Header",
"Pandoc",
"Para",
"Plain",
"Row",
"Table",
"TableBody",
"TableHead",
"Blocks",
"Body",
"Colspecs",
]
src/tasks_to_mdl/pandoc/pandoc.py
+293
View File
@@ -0,0 +1,293 @@
"""This file was generated by xsdata, v26.2, on 2026-09-14 19:25:20
Generator: DataclassGenerator
See: https://xsdata.readthedocs.io/
"""
from __future__ import annotations
from dataclasses import dataclass, field
from typing import ForwardRef
@dataclass(kw_only=True)
class CodeBlock:
class_value: str = field(
metadata={
"name": "class",
"type": "Attribute",
}
)
value: str = field(default="")
@dataclass(kw_only=True)
class ColSpec:
alignment: str = field(
metadata={
"type": "Attribute",
}
)
col_width: int = field(
metadata={
"name": "col-width",
"type": "Attribute",
}
)
@dataclass(kw_only=True)
class Header:
id: str = field(
metadata={
"type": "Attribute",
}
)
level: int = field(
metadata={
"type": "Attribute",
}
)
value: str = field(default="")
@dataclass(kw_only=True)
class Para:
content: list[object] = field(
default_factory=list,
metadata={
"type": "Wildcard",
"namespace": "##any",
"mixed": True,
"choices": (
{
"name": "Strong",
"type": ForwardRef("Para.Strong"),
},
{
"name": "Code",
"type": ForwardRef("Para.Code"),
},
{
"type": ForwardRef("Para.Value"),
},
),
},
)
@dataclass(kw_only=True)
class Strong:
value: str = field(default="")
@dataclass(kw_only=True)
class Code:
value: str = field(default="")
@dataclass(kw_only=True)
class Value:
value: str = field(default="")
@dataclass(kw_only=True)
class Plain:
strong: str = field(
metadata={
"name": "Strong",
"type": "Element",
}
)
@dataclass(kw_only=True)
class Cell:
alignment: str = field(
metadata={
"type": "Attribute",
}
)
plain: None | str | int | Plain = field(
default=None,
metadata={
"name": "Plain",
"type": "Element",
},
)
@dataclass(kw_only=True)
class Colspecs:
class Meta:
name = "colspecs"
col_spec: list[ColSpec] = field(
default_factory=list,
metadata={
"name": "ColSpec",
"type": "Element",
"min_occurs": 1,
},
)
@dataclass(kw_only=True)
class Row:
cell: list[Cell] = field(
default_factory=list,
metadata={
"name": "Cell",
"type": "Element",
"min_occurs": 1,
},
)
@dataclass(kw_only=True)
class TableHead:
row: Row = field(
metadata={
"name": "Row",
"type": "Element",
}
)
@dataclass(kw_only=True)
class Body:
class Meta:
name = "body"
row: Row = field(
metadata={
"name": "Row",
"type": "Element",
}
)
@dataclass(kw_only=True)
class TableBody:
row_head_columns: int = field(
metadata={
"name": "row-head-columns",
"type": "Attribute",
}
)
header: None | object = field(
default=None,
metadata={
"type": "Element",
},
)
body: Body = field(
metadata={
"type": "Element",
}
)
@dataclass(kw_only=True)
class Table:
caption: None | object = field(
default=None,
metadata={
"name": "Caption",
"type": "Element",
},
)
colspecs: Colspecs = field(
metadata={
"type": "Element",
}
)
table_head: TableHead = field(
metadata={
"name": "TableHead",
"type": "Element",
}
)
table_body: TableBody = field(
metadata={
"name": "TableBody",
"type": "Element",
}
)
table_foot: None | object = field(
default=None,
metadata={
"name": "TableFoot",
"type": "Element",
},
)
@dataclass(kw_only=True)
class Blocks:
class Meta:
name = "blocks"
header: list[Header] = field(
default_factory=list,
metadata={
"name": "Header",
"type": "Element",
"min_occurs": 1,
"sequence": 1,
},
)
para: list[Para] = field(
default_factory=list,
metadata={
"name": "Para",
"type": "Element",
"min_occurs": 1,
"sequence": 1,
},
)
horizontal_rule: list[object] = field(
default_factory=list,
metadata={
"name": "HorizontalRule",
"type": "Element",
"min_occurs": 1,
"sequence": 1,
},
)
table: list[Table] = field(
default_factory=list,
metadata={
"name": "Table",
"type": "Element",
"min_occurs": 1,
"sequence": 1,
},
)
code_block: list[CodeBlock] = field(
default_factory=list,
metadata={
"name": "CodeBlock",
"type": "Element",
"min_occurs": 1,
"sequence": 1,
},
)
@dataclass(kw_only=True)
class Pandoc:
api_version: str = field(
metadata={
"name": "api-version",
"type": "Attribute",
}
)
meta: None | object = field(
default=None,
metadata={
"type": "Element",
},
)
blocks: Blocks = field(
metadata={
"type": "Element",
}
)