Tasks

Complete the task of the chosen difficulty level for your variant number.

Variants

Variant 1. Fuel consumption

1. Initial level. Create a Java console program using JDK 27: distance d km 0..10000, consumption r L/100 km 0..50, price p UAH/L 0..1000; print liters d*r/100 and cost d*r*p/100. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: distance d km 0..10000, consumption r L/100 km 0..50, price p UAH/L 0..1000; print liters d*r/100 and cost d*r*p/100. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: distance d km 0..10000, consumption r L/100 km 0..50, price p UAH/L 0..1000; print liters d*r/100 and cost d*r*p/100. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 2. Painting a room

1. Initial level. Create a Java console program using JDK 27: length a, width b, height h 1..100 m, area of openings s from 0 to 2(a+b)*h, coverage per can c 0.1..100 m², price p 0..10000; print ceil((2(a+b)*h-s)/c) cans and the price. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: length a, width b, height h 1..100 m, area of openings s from 0 to 2(a+b)*h, coverage per can c 0.1..100 m², price p 0..10000; print ceil((2(a+b)*h-s)/c) cans and the price. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: length a, width b, height h 1..100 m, area of openings s from 0 to 2(a+b)*h, coverage per can c 0.1..100 m², price p 0..10000; print ceil((2(a+b)*h-s)/c) cans and the price. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 3. Laying tiles

1. Initial level. Create a Java console program using JDK 27: room sides a,b 1..100 m, tile side t 0.05..2 m, tile price p 0..10000; ignoring the shapes of offcuts, print ceil(a*b/(t*t)*1.1) tiles and their price. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: room sides a,b 1..100 m, tile side t 0.05..2 m, tile price p 0..10000; ignoring the shapes of offcuts, print ceil(a*b/(t*t)*1.1) tiles and their price. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: room sides a,b 1..100 m, tile side t 0.05..2 m, tile price p 0..10000; ignoring the shapes of offcuts, print ceil(a*b/(t*t)*1.1) tiles and their price. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 4. Pizza by area

1. Initial level. Create a Java console program using JDK 27: two diameters d1,d2 1..100 cm and prices p1,p2 0..10000; print the areas pi*d*d/4 and the price per square centimeter of each pizza. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: two diameters d1,d2 1..100 cm and prices p1,p2 0..10000; print the areas pi*d*d/4 and the price per square centimeter of each pizza. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: two diameters d1,d2 1..100 cm and prices p1,p2 0..10000; print the areas pi*d*d/4 and the price per square centimeter of each pizza. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 5. An educational energy formula

1. Initial level. Create a Java console program using JDK 27: mass m 1..300 kg, height h 30..250 cm, age a 1..120 years, a given coefficient k from -200 to 200; print the hypothetical index 10*m+6.25*h-5*a+k, without medical recommendations. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: mass m 1..300 kg, height h 30..250 cm, age a 1..120 years, a given coefficient k from -200 to 200; print the hypothetical index 10*m+6.25*h-5*a+k, without medical recommendations. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: mass m 1..300 kg, height h 30..250 cm, age a 1..120 years, a given coefficient k from -200 to 200; print the hypothetical index 10*m+6.25*h-5*a+k, without medical recommendations. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 6. Utilities

1. Initial level. Create a Java console program using JDK 27: previous x and current y meter readings 0..1000000 with y>=x, rate t 0..1000; print consumption y-x and payment (y-x)*t. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: previous x and current y meter readings 0..1000000 with y>=x, rate t 0..1000; print consumption y-x and payment (y-x)*t. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: previous x and current y meter readings 0..1000000 with y>=x, rate t 0..1000; print consumption y-x and payment (y-x)*t. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 7. Downloading a file

1. Initial level. Create a Java console program using JDK 27: size s 0..100000 MiB and speed v 0.1..10000 Mbit/s; print seconds s*1048576*8/(v*1000000), ignoring protocol overhead. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: size s 0..100000 MiB and speed v 0.1..10000 Mbit/s; print seconds s*1048576*8/(v*1000000), ignoring protocol overhead. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: size s 0..100000 MiB and speed v 0.1..10000 Mbit/s; print seconds s*1048576*8/(v*1000000), ignoring protocol overhead. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 8. Fencing a plot

1. Initial level. Create a Java console program using JDK 27: sides a,b 1..1000 m, maximum post spacing s 0.1..10 m, and price per meter p 0..10000; print the perimeter, ceil(2(a+b)/s) posts for a closed fence, and the fencing material cost. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: sides a,b 1..1000 m, maximum post spacing s 0.1..10 m, and price per meter p 0..10000; print the perimeter, ceil(2(a+b)/s) posts for a closed fence, and the fencing material cost. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: sides a,b 1..1000 m, maximum post spacing s 0.1..10 m, and price per meter p 0..10000; print the perimeter, ceil(2(a+b)/s) posts for a closed fence, and the fencing material cost. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 9. Hourly pay

1. Initial level. Create a Java console program using JDK 27: hours h 0..168 and rate r 0..10000; print the educational pay calculation min(h,40)*r+max(h-40,0)*1.5*r before taxes. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: hours h 0..168 and rate r 0..10000; print the educational pay calculation min(h,40)*r+max(h-40,0)*1.5*r before taxes. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: hours h 0..168 and rate r 0..10000; print the educational pay calculation min(h,40)*r+max(h-40,0)*1.5*r before taxes. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 10. Swimming pool volume

1. Initial level. Create a Java console program using JDK 27: length a, width b, depth h 0.1..100 m, flow rate q 0.1..1000 m³/hour, and water price p 0..1000; print a*b*h, time volume/q, and payment volume*p. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: length a, width b, depth h 0.1..100 m, flow rate q 0.1..1000 m³/hour, and water price p 0..1000; print a*b*h, time volume/q, and payment volume*p. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: length a, width b, depth h 0.1..100 m, flow rate q 0.1..1000 m³/hour, and water price p 0..1000; print a*b*h, time volume/q, and payment volume*p. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 11. Pocket expenses

1. Initial level. Create a Java console program using JDK 27: total expenses s 0..100000 UAH over d 1..31 days; print average expenses s/d and a 30-day forecast assuming a constant average. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: total expenses s 0..100000 UAH over d 1..31 days; print average expenses s/d and a 30-day forecast assuming a constant average. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: total expenses s 0..100000 UAH over d 1..31 days; print average expenses s/d and a 30-day forecast assuming a constant average. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 12. Bicycle trip

1. Initial level. Create a Java console program using JDK 27: distance d 0.1..1000 km, time t 1..1440 min, and hypothetical consumption e 0..100 units/min; print speed d*60/t in km/h, pace t/d, and e*t without health recommendations. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: distance d 0.1..1000 km, time t 1..1440 min, and hypothetical consumption e 0..100 units/min; print speed d*60/t in km/h, pace t/d, and e*t without health recommendations. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: distance d 0.1..1000 km, time t 1..1440 min, and hypothetical consumption e 0..100 units/min; print speed d*60/t in km/h, pace t/d, and e*t without health recommendations. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 13. Solar panel

1. Initial level. Create a Java console program using JDK 27: power p 0..100 kW, equivalent sun hours h 0..24, and coefficient k 0..1; print p*h*k kWh per day and for 30 identical days. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: power p 0..100 kW, equivalent sun hours h 0..24, and coefficient k 0..1; print p*h*k kWh per day and for 30 identical days. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: power p 0..100 kW, equivalent sun hours h 0..24, and coefficient k 0..1; print p*h*k kWh per day and for 30 identical days. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 14. Monitor screen

1. Initial level. Create a Java console program using JDK 27: diagonal d 1..100 inches, width w and height h 1..20000 pixels; print sqrt(w*w+h*h)/d PPI and the ratio w/h. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: diagonal d 1..100 inches, width w and height h 1..20000 pixels; print sqrt(w*w+h*h)/d PPI and the ratio w/h. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: diagonal d 1..100 inches, width w and height h 1..20000 pixels; print sqrt(w*w+h*h)/d PPI and the ratio w/h. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 15. Aquarium

1. Initial level. Create a Java console program using JDK 27: length a, width b, height h 1..500 cm, and fill coefficient k 0..1; print liters a*b*h*k/1000 and the educational water mass calculation at 1 kg/L. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: length a, width b, height h 1..500 cm, and fill coefficient k 0..1; print liters a*b*h*k/1000 and the educational water mass calculation at 1 kg/L. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: length a, width b, height h 1..500 cm, and fill coefficient k 0..1; print liters a*b*h*k/1000 and the educational water mass calculation at 1 kg/L. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 16. Office coffee

1. Initial level. Create a Java console program using JDK 27: n 1..1000 employees, c 0..20 cups per day, g 1..100 g per cup, d 1..31 days, price p 0..10000 UAH/kg; print n*c*g*d/1000 kg and the budget. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: n 1..1000 employees, c 0..20 cups per day, g 1..100 g per cup, d 1..31 days, price p 0..10000 UAH/kg; print n*c*g*d/1000 kg and the budget. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: n 1..1000 employees, c 0..20 cups per day, g 1..100 g per cup, d 1..31 days, price p 0..10000 UAH/kg; print n*c*g*d/1000 kg and the budget. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 17. Printing documents

1. Initial level. Create a Java console program using JDK 27: n 1..100000 pages per copy, c 1..1000 copies, cartridge yield r 1..100000 pages; each copy starts on a new sheet: print ceil(n/2)*c sheets and ceil(n*c/r) cartridges. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: n 1..100000 pages per copy, c 1..1000 copies, cartridge yield r 1..100000 pages; each copy starts on a new sheet: print ceil(n/2)*c sheets and ceil(n*c/r) cartridges. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: n 1..100000 pages per copy, c 1..1000 copies, cartridge yield r 1..100000 pages; each copy starts on a new sheet: print ceil(n/2)*c sheets and ceil(n*c/r) cartridges. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 18. Train trip

1. Initial level. Create a Java console program using JDK 27: hour h 0..23, minute m 0..59, duration t 0..10000 min; print the arrival day floor((60*h+m+t)/1440), hour, and minute modulo one day. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: hour h 0..23, minute m 0..59, duration t 0..10000 min; print the arrival day floor((60*h+m+t)/1440), hour, and minute modulo one day. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: hour h 0..23, minute m 0..59, duration t 0..10000 min; print the arrival day floor((60*h+m+t)/1440), hour, and minute modulo one day. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 19. Restaurant tip

1. Initial level. Create a Java console program using JDK 27: bill s 0..100000 UAH, tip p 0..100 percent, n 1..100 people; print the total s*(1+p/100) and each person's equal share. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: bill s 0..100000 UAH, tip p 0..100 percent, n 1..100 people; print the total s*(1+p/100) and each person's equal share. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: bill s 0..100000 UAH, tip p 0..100 percent, n 1..100 people; print the total s*(1+p/100) and each person's equal share. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 20. Running distance

1. Initial level. Create a Java console program using JDK 27: distance d 0.1..100 km and time t 1..1440 min; print pace t/d min/km and times 5*t/d and 10*t/d at a constant pace, without physiological predictions. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: distance d 0.1..100 km and time t 1..1440 min; print pace t/d min/km and times 5*t/d and 10*t/d at a constant pace, without physiological predictions. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: distance d 0.1..100 km and time t 1..1440 min; print pace t/d min/km and times 5*t/d and 10*t/d at a constant pace, without physiological predictions. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 21. Parcel

1. Initial level. Create a Java console program using JDK 27: sides a,b,c 1..300 cm, actual mass m 0..1000 kg, rate p 0..1000 UAH/kg; billable mass is max(m,a*b*c/5000); print it and the educational price calculation. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: sides a,b,c 1..300 cm, actual mass m 0..1000 kg, rate p 0..1000 UAH/kg; billable mass is max(m,a*b*c/5000); print it and the educational price calculation. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: sides a,b,c 1..300 cm, actual mass m 0..1000 kg, rate p 0..1000 UAH/kg; billable mass is max(m,a*b*c/5000); print it and the educational price calculation. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 22. Charging an electric vehicle

1. Initial level. Create a Java console program using JDK 27: capacity e 1..200 kWh, initial percentage a and target b 0..100 with b>=a, power p 0.1..500 kW, rate t 0..100; assuming constant efficiency of 1, print energy e*(b-a)/100, time, and price. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: capacity e 1..200 kWh, initial percentage a and target b 0..100 with b>=a, power p 0.1..500 kW, rate t 0..100; assuming constant efficiency of 1, print energy e*(b-a)/100, time, and price. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: capacity e 1..200 kWh, initial percentage a and target b 0..100 with b>=a, power p 0.1..500 kW, rate t 0..100; assuming constant efficiency of 1, print energy e*(b-a)/100, time, and price. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 23. Sales target

1. Initial level. Create a Java console program using JDK 27: target p 1..100000000 UAH, actual sales f 0..100000000 UAH, educational bonus rate k 0..0.5; print 100*f/p percent and a bonus of max(f-p,0)*k. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: target p 1..100000000 UAH, actual sales f 0..100000000 UAH, educational bonus rate k 0..0.5; print 100*f/p percent and a bonus of max(f-p,0)*k. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: target p 1..100000000 UAH, actual sales f 0..100000000 UAH, educational bonus rate k 0..0.5; print 100*f/p percent and a bonus of max(f-p,0)*k. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 24. Canning

1. Initial level. Create a Java console program using JDK 27: batch v 0..10000 L and jar b 0.1..10 L; print the number of full jars floor(v/b), the remainder, and ceil(v/b) jars required. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: batch v 0..10000 L and jar b 0.1..10 L; print the number of full jars floor(v/b), the remainder, and ceil(v/b) jars required. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: batch v 0..10000 L and jar b 0.1..10 L; print the number of full jars floor(v/b), the remainder, and ceil(v/b) jars required. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 25. Mobile plan

1. Initial level. Create a Java console program using JDK 27: minutes used m 0..10000, SMS s 0..10000, GB g 0..1000; a 200 UAH plan includes 100 min, 50 SMS, and 10 GB; overages cost 1, 2, and 20 UAH per unit; print the bill. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: minutes used m 0..10000, SMS s 0..10000, GB g 0..1000; a 200 UAH plan includes 100 min, 50 SMS, and 10 GB; overages cost 1, 2, and 20 UAH per unit; print the bill. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: minutes used m 0..10000, SMS s 0..10000, GB g 0..1000; a 200 UAH plan includes 100 min, 50 SMS, and 10 GB; overages cost 1, 2, and 20 UAH per unit; print the bill. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 26. Map scale

1. Initial level. Create a Java console program using JDK 27: scale 1:n, n 1..10000000, length d 0..1000 cm; print the real distance d*n/100 m and d*n/100000 km. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: scale 1:n, n 1..10000000, length d 0..1000 cm; print the real distance d*n/100 m and d*n/100000 km. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: scale 1:n, n 1..10000000, length d 0..1000 cm; print the real distance d*n/100 m and d*n/100000 km. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 27. Event duration

1. Initial level. Create a Java console program using JDK 27: integer seconds t 0..1000000000; print whole days, hours, minutes, and remaining seconds using division and remainder. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: integer seconds t 0..1000000000; print whole days, hours, minutes, and remaining seconds using division and remainder. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: integer seconds t 0..1000000000; print whole days, hours, minutes, and remaining seconds using division and remainder. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 28. Gravel path

1. Initial level. Create a Java console program using JDK 27: length a, width b 0.1..1000 m, thickness h 0.01..1 m, density r 100..3000 kg/m³; print volume a*b*h and mass volume*r. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: length a, width b 0.1..1000 m, thickness h 0.01..1 m, density r 100..3000 kg/m³; print volume a*b*h and mass volume*r. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: length a, width b 0.1..1000 m, thickness h 0.01..1 m, density r 100..3000 kg/m³; print volume a*b*h and mass volume*r. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 29. Electrical conductor

1. Initial level. Create a Java console program using JDK 27: educational positive resistance r 0.1..100000 ohms and voltage u 0..1000 V; print current u/r and power u*u/r without practical electrical installation instructions. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: educational positive resistance r 0.1..100000 ohms and voltage u 0..1000 V; print current u/r and power u*u/r without practical electrical installation instructions. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: educational positive resistance r 0.1..100000 ohms and voltage u 0..1000 V; print current u/r and power u*u/r without practical electrical installation instructions. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Variant 30. Cylindrical tank

1. Initial level. Create a Java console program using JDK 27: radius r 0.01..100 m and height h 0.01..100 m; print volume pi*r*r*h m³, liters, and the area of the two bases 2pi*r*r. Set the parameters in code. Print labeled results; display fractional numbers with two decimal places unless the problem specifies otherwise. Provide a manual reference calculation.

2. Basic level. Create a Java console program using JDK 27: radius r 0.01..100 m and height h 0.01..100 m; print volume pi*r*r*h m³, liters, and the area of the two bases 2pi*r*r. Read the parameters from the keyboard using Scanner; validate format and bounds, and print labeled results and a description of any failure. Submit a README with compilation/run commands and three meaningful Git commits.

3. Advanced level. Create a Java console program using JDK 27: radius r 0.01..100 m and height h 0.01..100 m; print volume pi*r*r*h m³, liters, and the area of the two bases 2pi*r*r. Accept parameters through the CLI in key=value format; with no arguments, prompt for keyboard input. Add --help and checks for format, finite numbers, and bounds; print errors to stderr, using exit codes 0 for success/help, 2 for invalid input, and 1 for an operational failure. Print an aligned report with a total. Submit at least five test cases, a README, and local Git history.

Procedure

1. Check the JDK and specify the actual build.
2. Create a Java project and a separate main class.
3. Record data units, the formula, and a manual result.
4. Run the program in the IDE and through the command line.
5. Create three meaningful local commits.
6. Check that the program runs from a clean directory following the README.
7. Explain the difference between compilation, execution, and formula errors.