Repository: allicen/Java-1000 Branch: master Commit: 614c2af783aa Files: 697 Total size: 1.0 MB Directory structure: gitextract_lj836lbl/ ├── Not_deaf_phone/ │ ├── NotDeafPhone.java │ └── README.md ├── README.md ├── _other_tasks_/ │ ├── README.md │ ├── a_glutton/ │ │ ├── Glutton.java │ │ └── README.md │ ├── b_robot_secretary/ │ │ ├── README.md │ │ └── RobotSecretary.java │ ├── b_test_task_in_naumen/ │ │ ├── README.md │ │ └── TestTaskInNaumen.java │ ├── big_add_one/ │ │ ├── BigAddOne.java │ │ ├── BigAddOneShort.java │ │ └── README.md │ ├── big_comparing_numbers/ │ │ ├── BigComparingNumbers.java │ │ ├── BigComparingNumbersShort.java │ │ └── README.md │ ├── big_difference_numbers/ │ │ ├── BigDifferenceNumbers.java │ │ ├── BigDifferenceNumbersShort.java │ │ └── README.md │ ├── big_multiplication/ │ │ ├── BigMultiplication.java │ │ ├── BigMultiplicationShort.java │ │ └── README.md │ ├── big_sum_numbers/ │ │ ├── BigSumNumbers.java │ │ ├── BigSumNumbersShort.java │ │ └── README.md │ ├── book/ │ │ ├── Book.java │ │ └── README.md │ ├── c_walk/ │ │ ├── README.md │ │ └── Walk.java │ ├── champion/ │ │ └── Champion.java │ ├── collector/ │ │ ├── Collector.java │ │ └── README.md │ ├── d_leras_pens/ │ │ ├── LerasPens.java │ │ └── README.md │ ├── d_reliable_tag/ │ │ ├── README.md │ │ └── ReliableTag.java │ ├── e_knights_and_knaves/ │ │ ├── KnightsAndKnaves.java │ │ └── README.md │ ├── exit_from_maze/ │ │ ├── ExitFromMaze.java │ │ └── README.md │ ├── f_positive_divisors/ │ │ ├── PositiveDivisors.java │ │ └── README.md │ ├── g_couriers_implementation/ │ │ ├── CouriersImplementation.java │ │ ├── README.md │ │ └── variant_two.py │ ├── gcd/ │ │ ├── Gcd.java │ │ └── README.md │ ├── i_basketball_game/ │ │ ├── BasketballGame.java │ │ └── README.md │ ├── intern_day/ │ │ ├── InternDay.java │ │ └── README.md │ ├── inverse_simple_module/ │ │ ├── InverseSimpleModule.java │ │ └── README.md │ ├── j_digital_protocol/ │ │ ├── DigitalProtocol.java │ │ └── README.md │ ├── kvn/ │ │ ├── Kvn.java │ │ └── README.md │ ├── large_prime_numbers/ │ │ ├── LargePrimeNumbers.java │ │ └── README.md │ ├── microbiology/ │ │ ├── Microbiology.java │ │ └── README.md │ ├── multigraph/ │ │ ├── Multigraph.java │ │ └── README.md │ ├── numbers/ │ │ ├── Numbers.java │ │ └── README.md │ ├── numeric_palindrome/ │ │ ├── NumericPalindrome.java │ │ └── README.md │ ├── play/ │ │ ├── Play.java │ │ └── README.md │ ├── rapid_exponentiation/ │ │ ├── README.md │ │ └── RapidExponentiation.java │ ├── search/ │ │ ├── README.md │ │ └── Search.java │ ├── second_above/ │ │ ├── README.md │ │ └── SecondAbove.java │ └── tower/ │ ├── README.md │ └── Tower.java ├── a_plus_b/ │ ├── README.md │ └── Summ.java ├── a_yandex/ │ └── Main.java ├── abba_gold/ │ ├── AbbaGold.java │ └── README.md ├── acm_world_finals/ │ ├── AcmWorldFnals.java │ └── README.md ├── adjacent_cells/ │ ├── AdjacentCells.java │ └── README.md ├── adjustment/ │ ├── Adjustment.java │ └── README.md ├── alarm/ │ ├── Alarm.java │ └── README.md ├── alcohol/ │ ├── Alcohol.java │ └── README.md ├── alibaba/ │ ├── Alibaba.java │ └── README.md ├── alien/ │ ├── Alien.java │ └── README.md ├── alphabet/ │ ├── Alphabet.java │ └── README.md ├── amount_two/ │ ├── AmountTwo.java │ └── README.md ├── anagram_two/ │ ├── AnagramTwo.java │ └── README.md ├── anagrams/ │ ├── Anagrams.java │ └── README.md ├── anti_palindrome/ │ ├── AntiPalindrome.java │ └── README.md ├── area_triangle/ │ ├── README.md │ └── areaTriangle.java ├── arithmetic/ │ ├── Arithmetic.java │ └── README.md ├── arithmetic_progression/ │ ├── ArithmeticProgression.java │ └── README.md ├── arrange/ │ ├── Arrange.java │ └── README.md ├── arrival_time/ │ ├── ArrivalTime.java │ └── README.md ├── arrows/ │ ├── Arrows.java │ └── README.md ├── artist/ │ ├── Artist.java │ └── README.md ├── automorphic_numbers/ │ ├── AutomorphicNumbers.java │ └── README.md ├── ballot/ │ ├── Ballot.java │ └── README.md ├── base_of_terrorists/ │ ├── BaseOfTerrorists.java │ └── README.md ├── basketball/ │ ├── Basketball.java │ └── README.md ├── beads/ │ ├── Beads.java │ └── README.md ├── beautiful_numbers/ │ ├── BeautifulNumbers.java │ └── README.md ├── beautiful_wall/ │ ├── BeautifulWall.java │ └── README.md ├── bell/ │ ├── Bell.java │ └── README.md ├── bertrand_postulate/ │ ├── BertrandPostulate.java │ └── README.md ├── best_divider/ │ ├── BestDivider.java │ └── README.md ├── binary_numbers/ │ ├── BinaryNumbers.java │ └── README.md ├── birthday/ │ ├── Birthday.java │ └── README.md ├── birthday_two/ │ ├── BirthdayTwo.java │ └── README.md ├── bit_reverse/ │ ├── BitReverse.java │ └── README.md ├── black_white_graphics/ │ ├── BlackWhiteGraphics.java │ └── README.md ├── board/ │ ├── Board.java │ └── README.md ├── bolts_nuts/ │ ├── BoltsNuts.java │ └── README.md ├── bowling/ │ ├── Bowling.java │ └── README.md ├── boxes/ │ ├── Boxes.java │ └── README.md ├── building_of_schools/ │ ├── BuildingOfSchools.java │ └── README.md ├── bulls_cows/ │ ├── BullsCows.java │ └── README.md ├── bus_tour/ │ ├── BusTour.java │ └── README.md ├── business/ │ ├── Business.java │ └── README.md ├── cake/ │ ├── Cake.java │ └── README.md ├── cake_two/ │ ├── CakeTwo.java │ └── README.md ├── carousel/ │ ├── Carousel.java │ └── README.md ├── casting/ │ ├── Casting.java │ └── README.md ├── castle/ │ ├── Castle.java │ └── README.md ├── cell/ │ ├── Cell.java │ └── README.md ├── census/ │ ├── Census.java │ └── README.md ├── checking_for_likability/ │ ├── CheckingForLikability.java │ └── README.md ├── chess/ │ ├── Chess.java │ └── README.md ├── chess_field/ │ ├── ChessField.java │ └── README.md ├── chess_horse/ │ ├── ChessHorse.java │ └── README.md ├── chess_workshop/ │ ├── ChessWorkshop.java │ └── README.md ├── chessboard/ │ ├── Chessboard.java │ └── README.md ├── chessboard_figure/ │ ├── ChessboardFigure.java │ └── README.md ├── chest_of_billy_bones/ │ ├── ChestOfBillyBones.java │ └── README.md ├── circle/ │ ├── Circle.java │ └── README.md ├── circle_two/ │ ├── CircleTwo.java │ └── README.md ├── clock/ │ ├── Clock.java │ └── README.md ├── clock_fight/ │ ├── ClockFight.java │ └── README.md ├── clothes/ │ ├── Clothes.java │ └── README.md ├── coin/ │ ├── Coin.java │ └── README.md ├── coin_two/ │ ├── CoinTwo.java │ └── README.md ├── colored_rain/ │ ├── ColoredRain.java │ └── README.md ├── coloring_multiplication_tables/ │ ├── ColoringMultiplicationTables.java │ └── README.md ├── community_of_robots/ │ ├── CommunityOfRobots.java │ └── README.md ├── component/ │ ├── Component.java │ └── README.md ├── compression_binary_sequences/ │ ├── CompressionBinarySequences.java │ └── README.md ├── conditioner/ │ ├── Conditioner.java │ └── README.md ├── constant_kaprekar/ │ ├── ConstantKaprekar.java │ └── README.md ├── construction_of_roads/ │ ├── ConstructionOfRoads.java │ └── README.md ├── contest/ │ ├── Contest.java │ └── README.md ├── convex_hull/ │ ├── ConvexHull.java │ └── README.md ├── crane/ │ ├── Crane.java │ └── README.md ├── creator/ │ ├── Creator.java │ └── README.md ├── cross_zero/ │ ├── CrossZero.java │ └── README.md ├── cryptogram/ │ ├── Cryptogram.java │ └── README.md ├── cut/ │ ├── Cut.java │ └── README.md ├── cute_pattern/ │ ├── CutePattern.java │ └── README.md ├── dates/ │ ├── Dates.java │ └── README.md ├── decoding/ │ ├── Decoding.java │ └── README.md ├── deletion/ │ ├── Deletion.java │ └── README.md ├── delta/ │ ├── Delta.java │ └── README.md ├── dictionary/ │ ├── Dictionary.java │ └── READMe.md ├── different_numbers/ │ ├── DifferentNumbers.java │ └── README.md ├── digits/ │ ├── Digits.java │ └── README.md ├── digits_after_point/ │ ├── DigitsAfterPoint.java │ └── README.md ├── diplomas/ │ ├── Diplomas.java │ └── README.md ├── divider/ │ ├── Divider.java │ └── README.md ├── divider_two/ │ └── DividerTwo.java ├── divination/ │ ├── Divination.java │ └── README.md ├── division_two/ │ ├── DivisionTwo.java │ └── README.md ├── dots_on_dominoes/ │ ├── DotsOnDominoes.java │ └── README.md ├── double_numbers/ │ ├── DoubleNumbers.java │ └── README.md ├── economy/ │ ├── Economy.java │ └── README.md ├── election_of_priests/ │ ├── ElectionOfPriests.java │ └── README.md ├── elevator/ │ ├── Elevator.java │ └── README.md ├── eleven/ │ ├── Eleven.java │ └── README.md ├── encryption/ │ ├── Encryption.java │ └── README.md ├── eniya/ │ ├── Eniya.java │ └── README.md ├── even_odd_task/ │ ├── EvenOddTask.java │ └── README.md ├── event/ │ ├── Event.java │ └── README.md ├── evolution/ │ ├── Evolution.java │ └── README.md ├── exam/ │ ├── Exam.java │ └── README.md ├── factorial/ │ ├── Factorial.java │ └── README.md ├── fast_train/ │ ├── FastTrain.java │ └── README.md ├── fibonacci/ │ ├── Fibonacci.java │ └── README.md ├── fibonacci_again/ │ ├── FibonacciAgain.java │ └── README.md ├── fibonacci_sequence/ │ ├── FibonacciSequence.java │ └── README.md ├── fibonacci_two/ │ ├── FibonacciTwo.java │ └── README.md ├── field/ │ ├── Field.java │ └── README.md ├── field_miracles/ │ ├── FieldMiracles.java │ └── README.md ├── fire/ │ ├── Fire.java │ └── README.md ├── fishing_net/ │ ├── README.md │ └── fishingNet.java ├── floret/ │ ├── Floret.java │ └── README.md ├── football/ │ ├── Football.java │ └── README.md ├── frendly_numbers/ │ ├── FrendlyNumbers.java │ └── README.md ├── fun_game/ │ ├── FunGame.java │ └── README.md ├── funny_sequence/ │ ├── FunnySequence.java │ └── README.md ├── gambling_shrek/ │ ├── GamblingShrek.java │ └── README.md ├── game/ │ ├── Game.java │ └── README.md ├── game_meter/ │ ├── GameMeter.java │ └── README.md ├── game_theory/ │ ├── GameTheory.java │ └── README.md ├── gardener_artist/ │ ├── GardenerArtist.java │ └── README.md ├── gifts/ │ ├── Gifts.java │ └── README.md ├── gnome_entertainment/ │ ├── GnomeEntertainment.java │ └── README.md ├── goldbach_conjecture/ │ ├── GoldbachConjecture.java │ └── README.md ├── goldbach_conjecture_two/ │ ├── GoldbachConjectureTwo.java │ └── README.md ├── golden_sand/ │ ├── README.md │ └── goldenSand.java ├── gulliver/ │ ├── Gulliver.java │ └── README.md ├── hairy_business/ │ ├── HairyBusiness.java │ └── README.md ├── hamming_distance/ │ ├── HammingDistance.java │ └── README.md ├── heron/ │ ├── Heron.java │ └── README.md ├── hockey/ │ ├── Hockey.java │ └── README.md ├── home_school/ │ ├── HomeSchool.java │ └── README.md ├── homework/ │ ├── Homework.java │ └── README.md ├── honey/ │ ├── Honey.java │ └── README.md ├── horse/ │ ├── Horse.java │ └── README.md ├── horse_racing/ │ ├── HorseRacing.java │ └── README.md ├── hunter/ │ ├── Hunter.java │ └── README.md ├── idler/ │ ├── Idler.java │ └── README.md ├── in_bus/ │ ├── README.md │ └── inBus.java ├── java_vs_pcc/ │ ├── JavaVsPcc.java │ └── README.md ├── jumpy_journey/ │ ├── JumpyJourney.java │ └── README.md ├── k_numbers/ │ ├── KNumbers.java │ └── README.md ├── keyboard/ │ ├── Keyboard.java │ └── README.md ├── keyboard_two/ │ ├── KeyboardTwo.java │ └── README.md ├── known_everybody/ │ ├── KnownEverybody.java │ └── README.md ├── language_recognition/ │ ├── LanguageRecognition.java │ └── README.md ├── last_digit/ │ ├── LastDigit.java │ └── README.md ├── least_common_multiple/ │ ├── LeastCommonMultiple.java │ └── README.md ├── left_recursion/ │ ├── LeftRecursion.java │ └── README.md ├── letter/ │ ├── Letter.java │ └── README.md ├── lexicographic_order_numbers/ │ ├── LexicographicOrderNumbers.java │ └── README.md ├── lisaalisa/ │ ├── Lisaalisa.java │ └── README.md ├── list_of_items/ │ ├── ListOfItems.java │ └── README.md ├── live_journal/ │ ├── LiveJournal.java │ └── README.md ├── lucky_ticket/ │ ├── LuckyTicket.java │ └── README.md ├── lucky_ticket_two/ │ ├── LuckyTicketTwo.java │ └── README.md ├── manhattan_streets/ │ ├── ManhattanStreets.java │ └── README.md ├── maximum_three/ │ ├── MaximumThree.java │ └── README.md ├── military_base/ │ ├── MilitaryBase.java │ └── README.md ├── minimum_path_table/ │ ├── MinimumPathTable.java │ └── README.md ├── mockery/ │ ├── Mockery.java │ └── README.md ├── module_amount/ │ ├── ModuleAmount.java │ └── README.md ├── money_money_money/ │ ├── MoneyMoneyMoney.java │ └── README.md ├── more_less/ │ ├── MoreLess.java │ └── README.md ├── mouse/ │ ├── Mouse.java │ └── README.md ├── multi_digits/ │ ├── MultiDigits.java │ └── README.md ├── multiplication_of_numbers/ │ ├── MultiplicationOfNumbers.java │ └── README.md ├── multiplication_table/ │ ├── MultiplicationTable.java │ └── README.md ├── n_digit_numbers/ │ ├── NDigitNumbers.java │ └── README.md ├── natural_number_series/ │ ├── NaturalNumberSeries.java │ └── README.md ├── neerc/ │ ├── Neerc.java │ └── README.md ├── neznaika/ │ ├── Neznaika.java │ └── README.md ├── number_buses/ │ ├── NumberBuses.java │ └── README.md ├── number_e/ │ ├── NumberE.java │ └── README.md ├── number_of_smith/ │ ├── NumberOfSmith.java │ └── README.md ├── number_palindrome/ │ ├── NumberPalindrome.java │ └── README.md ├── number_participants_olympiad/ │ ├── NumberParticipantsOlympiad.java │ └── README.md ├── numbers/ │ ├── Numbers.java │ └── README.md ├── numbers_game/ │ ├── NumbersGame.java │ └── README.md ├── numbers_without_same_digit/ │ ├── NumbersWithoutSameDigit.java │ └── README.md ├── numerologist/ │ ├── Numerologist.java │ └── README.md ├── nutlets/ │ ├── Nutlets.java │ └── README.md ├── office/ │ ├── Office.java │ └── README.md ├── only_right_down/ │ ├── OnlyRightDown.java │ └── README.md ├── optimization_circle/ │ ├── OptimizationCircle.java │ └── README.md ├── oranges/ │ ├── Oranges.java │ └── README.md ├── oversteping/ │ ├── Oversteping.java │ └── README.md ├── palindrome/ │ ├── Palindrome.java │ └── README.md ├── palindromic_time/ │ ├── PalindromicTime.java │ └── README.md ├── parallelepiped/ │ ├── Parallelepiped.java │ └── README.md ├── percents/ │ ├── Percents.java │ └── README.md ├── permutation/ │ ├── Permutation.java │ └── README.md ├── phone/ │ ├── Phone.java │ └── README.md ├── photographic_negative/ │ ├── PhotographicNegative.java │ └── README.md ├── picking_blueberries/ │ ├── PickingBlueberries.java │ └── README.md ├── ping/ │ ├── Ping.java │ └── README.md ├── pizza/ │ ├── Pizza.java │ └── README.md ├── playing_dice/ │ ├── PlayingDice.java │ └── README.md ├── playing_with_matches/ │ ├── PlayingWithMatches.java │ └── README.md ├── playing_with_pawn/ │ ├── PlayingWithPawn.java │ └── README.md ├── playing_with_pebbles/ │ ├── PlayingWithPebbles.java │ └── README.md ├── poker/ │ ├── Poker.java │ └── README.md ├── pow_string/ │ ├── PowString.java │ └── README.md ├── power_numbers/ │ ├── PowerNumbers.java │ └── README.md ├── premium/ │ ├── Premium.java │ └── README.md ├── prime_factorization/ │ ├── PrimeFactorization.java │ └── README.md ├── prince_and_dragon/ │ ├── PrinceAndDragon.java │ └── README.md ├── professor/ │ ├── Professor.java │ └── README.md ├── program_template/ │ ├── ProgramTemplate.java │ └── README.md ├── programmer_day/ │ ├── ProgrammerDay.java │ └── README.md ├── puzzle_queens/ │ ├── PuzzleQueens.java │ └── README.md ├── quadratic_equation/ │ ├── QuadraticEquation.java │ └── README.md ├── queue/ │ ├── Queue.java │ └── README.md ├── rally/ │ ├── README.md │ └── Rrally.java ├── rect/ │ ├── README.md │ └── Rect.java ├── rectangle_two/ │ ├── README.md │ └── RectangleTwo.java ├── repair/ │ ├── README.md │ └── Repair.java ├── reverse_permutation/ │ ├── README.md │ └── ReversePermutation.java ├── riddle/ │ ├── README.md │ └── Riddle.java ├── ring/ │ ├── README.md │ └── Ring.java ├── road/ │ ├── README.md │ └── Road.java ├── robot_k79/ │ ├── README.md │ └── RobotK79.java ├── rook/ │ ├── README.md │ └── Rook.java ├── runeword/ │ ├── README.md │ └── Runeword.java ├── saddle_point/ │ ├── README.md │ └── SaddlePoint.java ├── salads/ │ ├── README.md │ └── Salads.java ├── salary/ │ ├── README.md │ └── Salary.java ├── same_numbers/ │ ├── README.md │ └── SameNumbers.java ├── sapper/ │ ├── README.md │ └── Sapper.java ├── school_algebra/ │ ├── README.md │ └── SchoolAlgebra.java ├── scoring/ │ ├── README.md │ └── Scoring.java ├── sea_battle_two/ │ ├── README.md │ └── SeaBattleTwo.java ├── season/ │ ├── README.md │ └── Season.java ├── sequence_conversion_two/ │ ├── README.md │ └── SequenceConversionTwo.java ├── sequence_two/ │ ├── README.md │ └── SequenceTwo.java ├── shelf/ │ ├── README.md │ └── Shelf.java ├── shift_permutation/ │ ├── README.md │ └── ShiftPermutation.java ├── shift_text/ │ ├── README.md │ └── ShiftText.java ├── shooter/ │ ├── README.md │ └── Shooter.java ├── shooting_championship/ │ ├── README.md │ └── ShootingChampionship.java ├── short_sequence/ │ ├── README.md │ └── ShortSequence.java ├── similar_arrays/ │ ├── README.md │ └── SimilarArrays.java ├── simple_again/ │ ├── README.md │ └── SimpleAgain.java ├── simple_calculation/ │ ├── README.md │ └── SimpleCalculation.java ├── simple_number/ │ ├── README.md │ └── SimpleNumber.java ├── simple_numbers_two/ │ ├── README.md │ └── SimpleNumbersTwo.java ├── simple_radical/ │ ├── README.md │ └── SimpleRadical.java ├── simple_series/ │ ├── README.md │ └── SimpleSeries.java ├── simple_sorting/ │ ├── README.md │ └── SimpleSorting.java ├── single_nod/ │ ├── README.md │ └── SingleNod.java ├── smallest_number_system/ │ ├── README.md │ └── SmallestNumberSystem.java ├── sorting_count/ │ ├── README.md │ └── SortingCount.java ├── spelling/ │ ├── README.md │ └── Spelling.java ├── split_parts/ │ ├── README.md │ └── SplitParts.java ├── srange_lottery/ │ ├── README.md │ └── SrangeLottery.java ├── stairs/ │ ├── README.md │ └── Stairs.java ├── state_machine/ │ ├── README.md │ └── stateMachine.java ├── statistics/ │ ├── README.md │ └── Statistics.java ├── step_happiness/ │ ├── README.md │ └── StepHappiness.java ├── strawberry/ │ ├── README.md │ └── Strawberry.java ├── string_book/ │ ├── README.md │ └── StringBook.java ├── subarray_array/ │ ├── README.md │ └── SubarrayArray.java ├── substrings_identical_letters/ │ ├── README.md │ └── SubstringsIdenticalLetters.java ├── sudoku/ │ ├── README.md │ └── Sudoku.java ├── sum/ │ ├── README.md │ └── Sum.java ├── sum_max_min/ │ ├── README.md │ └── SumMaxMin.java ├── sum_n_digit_numbers/ │ ├── README.md │ └── SumNDigitNumbers.java ├── symmetry/ │ ├── README.md │ └── Symmetry.java ├── task_of_josephus/ │ ├── README.md │ └── TaskOfJosephus.java ├── tax/ │ ├── README.md │ └── Tax.java ├── tea/ │ ├── README.md │ └── Tea.java ├── teleportation/ │ ├── README.md │ └── Teleportation.java ├── temporary_key/ │ ├── README.md │ └── TemporaryKey.java ├── thaw/ │ ├── README.md │ └── Thaw.java ├── thimble/ │ ├── README.md │ └── Thimble.java ├── three_fat_men/ │ ├── README.md │ └── threeFatMen.java ├── time_sort/ │ ├── README.md │ └── TimeSort.java ├── timer/ │ ├── README.md │ └── Timer.java ├── topcoder/ │ ├── README.md │ └── TopCoder.java ├── tourist/ │ ├── README.md │ └── Tourist.java ├── traffic_lights/ │ ├── README.md │ └── TrafficLights.java ├── traps/ │ ├── README.md │ └── Traps.java ├── treasure/ │ ├── README.md │ └── Treasure.java ├── turn/ │ ├── README.md │ └── Turn.java ├── twenty_five/ │ ├── README.md │ └── twentyFive.java ├── two_bandits/ │ ├── README.md │ └── TwoBandits.java ├── two_pow_n/ │ ├── README.md │ └── TwoPowN.java ├── two_ring/ │ ├── README.md │ └── TwoRing.java ├── two_sequences/ │ ├── README.md │ └── TwoSequences.java ├── two_simple_number/ │ ├── README.md │ └── TwoSimpleNumber.java ├── underground/ │ ├── README.md │ └── Underground.java ├── unit/ │ ├── README.md │ └── Unit.java ├── unix/ │ ├── README.md │ └── Unix.java ├── unpack_string/ │ ├── README.md │ └── UnpackString.java ├── usm_dialogs/ │ ├── README.md │ └── UsmDialogs.java ├── wagons/ │ ├── README.md │ └── Wagons.java ├── watermelon/ │ ├── README.md │ └── Watermelon.java ├── wedding/ │ ├── README.md │ └── Wedding.java ├── weighing/ │ ├── README.md │ └── Weighing.java ├── wholesale/ │ ├── README.md │ └── Wholesale.java ├── wire_transfer/ │ ├── README.md │ └── WireTransfer.java ├── word/ │ ├── README.md │ └── Word.java ├── worst_divider/ │ ├── README.md │ └── WorstDivider.java └── zero/ ├── README.md └── Zero.java ================================================ FILE CONTENTS ================================================ ================================================ FILE: Not_deaf_phone/NotDeafPhone.java ================================================ package Not_deaf_phone; import java.io.*; import java.util.*; public class NotDeafPhone { public static void main(String[] args) throws IOException { String str; FileReader fin = new FileReader("input.txt"); // Получение числа из файла Scanner sc = new Scanner(fin); str = sc.nextLine(); FileWriter countStepFinish = new FileWriter("output.txt");// Запись числа в файл countStepFinish.write(str); countStepFinish.close(); } } ================================================ FILE: Not_deaf_phone/README.md ================================================

Неглухой телефон (1%)

Время: 1 сек.
Память: 16 Мб
Сложность: 1%

Возможно, что Вы когда то играли в игру «Глухой телефон», либо слышали о ней. В этой игре участникам приходится передавать информацию друг другу различными способами: словесно, образно, бывает даже приходится писать левой рукой текст, который другой участник команды должен будет прочитать. Так же известно, что практически никогда передаваемая информация не доходит до конечного адресата. Обозначим за Fi(x) функцию, которая преобразует текст передаваемой информации x в ту, которую получит участник i+1 от участника i. Тогда последний n-й участник получит данные y, которые будут выражаться следующей формулой:

y = Fn-1(Fn-2(…F2(F1(x))))

Но Вам необходимо исключить какие-либо внешние факторы, которые могут исказить исходную информацию и Вы должны реализовать программу «неглухой телефон», которая сможет безошибочно доставлять исходные данные, т.е. в нашем случае функция Fi(x) = x для всех i от 1 до n-1.

Формат ввода

В единственной строке входного файла input.txt записано натуральное число от 1 до 100.

Формат вывода

В выходной файл output.txt нужно вывести в точности то же число, которое задано во входном файле.

Пример 1

Ввод Вывод
5 5
================================================ FILE: README.md ================================================

1000 задач на Java

Решение задач с сайта acmp.ru.

Задачи в порядке возрастания сложности:

  1. Неглухой телефон (1%)
  2. A+B (2%)
  3. Бисер (2%)
  4. Олимпиада (2%)
  5. Больше-меньше (3%)
  6. Орешки (3%)
  7. Эния (3%)
  8. Гулливер (4%)
  9. Два бандита (4%)
  10. Зарплата (4%)
  11. Игра (4%)
  12. Арифметика (5%)
  13. Баскетбол (5%)
  14. Сбор земляники (6%)
  15. Торт (6%)
  16. Журавлики (7%)
  17. Три толстяка (7%)
  18. Бинарные числа (8%)
  19. Монетки (8%)
  20. Пятью пять - двадцать пять! (8%)
  21. Мышка (9%)
  22. Разворот (9%)
  23. От перестановки что-то меняется... (9%)
  24. Внеземные гости (10%)
  25. Время года (10%)
  26. Золотой песок (10%)
  27. Прямоугольный параллелепипед (10%)
  28. Рыболовная сеть (10%)
  29. Спирт (10%)
  30. Четырехзначный палиндром (10%)
  31. Клавиатура (11%)
  32. Конечные автоматы (11%)
  33. Ремонт (11%)
  34. Будильник (12%)
  35. Длина отрезка (12%)
  36. Кондиционер (12%)
  37. Счастливый билет (12%)
  38. Телефон (12%)
  39. Треугольник - 3 (12%)
  40. Цветочки (12%)
  41. Гадание (13%)
  42. День программиста (13%)
  43. Орфография (13%)
  44. Строки в книге (13%)
  45. Автобусная экскурсия (14%)
  46. Арбузы (14%)
  47. Всем известно (14%)
  48. Кипячение чая (14%)
  49. Арифметическая прогрессия (15%)
  50. Время прибытия (15%)
  51. Головоломка про ферзей (15%)
  52. Игральные кубики (15%)
  53. Клетки (15%)
  54. Напёрстки (15%)
  55. НОД (15%), второй вариант
  56. Перепись (15%)
  57. Площадь треугольника (15%)
  58. Подмассив массива (15%)
  59. Статистика (15%)
  60. Цапли (15%)
  61. В одном шаге от счастья (16%)
  62. Единицы (16%)
  63. Нули (16%)
  64. Номера автобусов (16%)
  65. Метро (16%)
  66. Кругляши (16%)
  67. Поля (16%)
  68. Числа Фибоначчи (16%)
  69. Шахматное поле (16%)
  70. Кольцо (16%)
  71. Болты и гайки (17%)
  72. Оттепель (17%)
  73. Манхэттенские улицы (17%)
  74. Сбор черники (17%)
  75. Миша и негатив (17%)
  76. Фибоначчиева последовательность (17%)
  77. NEERC (17%)
  78. Две окружности (17%)
  79. Дороги (18%)
  80. Загадка (18%)
  81. Офис (18%)
  82. Соревнование картингистов (18%)
  83. Шахматная доска - 2 (18%)
  84. В автобусе (18%)
  85. НОК (19%)
  86. Сумма (19%)
  87. Сжатие бинарных последовательностей (19%)
  88. Симметрия (19%)
  89. Игра с ладьей (19%)
  90. Кастинг (19%)
  91. Коробки (19%)
  92. Крестики-нолики (19%)
  93. ACM World Finals (19%)
  94. Временной ключ (20%)
  95. Детали (20%)
  96. Кризисный бизнес (20%)
  97. Стрелки (20%)
  98. Пицца (20%)
  99. Число E (20%)
  100. Числа Фибоначчи - 2 (20%)
  101. Очередь (20%)
  102. Лифт (20%)
  103. Экзамены (20%)
  104. Левая рекурсия (20%)
  105. Симпатичный узор (20%)
  106. Налоги (20%)
  107. Табло (20%)
  108. Лентяй (21%)
  109. Дом - Школа - Дом (21%)
  110. Разбиение на части (21%)
  111. Лестница (21%)
  112. Хоккей (21%)
  113. Морской бой - 2 (21%)
  114. Последняя цифра A^B (21%)
  115. Делимость на 11 (22%)
  116. Али-Баба (22%)
  117. Лиса Алиса и кот Базилио (22%)
  118. Постоянная Капрекара (22%)
  119. Раскраска таблицы умножения (22%)
  120. Турист (22%)
  121. Карусель (22%)
  122. Принц и дракон (22%)
  123. Соседние клетки (22%)
  124. Футбол (22%)
  125. Сортировка времени (23%)
  126. Наименьшее и наибольшее числа из тех же цифр (23%)
  127. Вагоны (23%)
  128. Мёд (23%)
  129. Игра в числа (23%)
  130. Единичный НОД (23%)
  131. Шахматы (23%)
  132. Наихудший делитель (23%)
  133. Снова Фибоначчи (23%)
  134. Нумеролог (24%)
  135. Одежда (24%)
  136. Перестановка (24%)
  137. Палиндромное время (24%)
  138. Ловушки (24%)
  139. Костер (24%)
  140. Прыгучее путешествие (24%)
  141. Сдвиг перестановки (24%)
  142. Распаковка строки (25%)
  143. Рунные слова (25%)
  144. Алфавит (25%)
  145. Уравнение для 5 класса! (25%)
  146. Дружные числа (25%)
  147. Похожие массивы (25%)
  148. Таблица умножения (25%)
  149. Числа без одинаковых цифр (25%)
  150. Часы с боем (25%)
  151. Модуль суммы (25%)
  152. К-удивительные числа (25%)
  153. Окружности (25%)
  154. Несложная сортировка (25%)
  155. Бит-реверс (25%)
  156. Красивая стена (25%)
  157. Клавиатура - 2 (25%)
  158. Странная лотелея (25%)
  159. Премия (25%)
  160. Точки на костях домино (25%)
  161. Шахматный конь (25%)
  162. Несложное вычисление (25%)
  163. Азартный Шрэк (25%)
  164. TopCoder (25%)
  165. Светофорчики (25%)
  166. Обратная перестановка (25%)
  167. Анаграммы (26%)
  168. Профессор (26%)
  169. Счастливый билет - 2 (26%)
  170. Салаты (26%)
  171. Красивые числа - 2 (26%)
  172. Сумма максимума и минимума (26%)
  173. Наилучший делитель (26%)
  174. Монеты - 2 (26%)
  175. Выборы (26%)
  176. Забавная последовательность (26%)
  177. Быки и коровы (26%)
  178. Наименьшая система счисления (26%)
  179. Боги (26%)
  180. Апельсины (26%)
  181. Автоморфные числа (26%)
  182. Цифры после запятой (26%)
  183. Четно-нечетная задача (26%)
  184. Художник (26%)
  185. Цветной дождь (26%)
  186. Черно-белая графика (26%)
  187. Шахматная доска (26%)
  188. Факториалы!!! (26%)
  189. Дни рождения (27%)
  190. Домашнее задание (27%)
  191. Двоякие числа (27%)
  192. Простой ряд (27%)
  193. Разные цифры (27%)
  194. Разложение на простые множители (27%)
  195. Снова про простые числа (27%)
  196. Судоку (27%)
  197. Школьная алгебра (27%)
  198. Цифры (27%)
  199. Незнайка (27%)
  200. Подарки Деда Мороза (27%)
  201. Подсчет баллов (27%)
  202. Оптимизация по окружности (27%)
  203. Выпуклая оболочка (27%)
  204. Прямоугольник - 2 (27%)
  205. Оптовая покупка (27%)
  206. Охотник (27%)
  207. Расстояние Хэмминга (27%)
  208. Анаграммы-2 (28%)
  209. Антипалиндром (28%)
  210. Натуральный ряд чисел (28%)
  211. 2-Простое число (28%)
  212. Распознание языка (28%)
  213. Слово (28%)
  214. Вычеркивание (28%)
  215. Игра со спичками (28%)
  216. Квадратное уравнение (28%)
  217. Клад (28%)
  218. Общие цифры (28%)
  219. Выборы жрецов (28%)
  220. Короткая последовательность (28%)
  221. Проверка на симпатичность (28%)
  222. Произведение цифр - 2 (28%)
  223. Колокол (28%)
  224. Простые числа (28%)
  225. Простые числа - 2 (28%)
  226. Развлечения гномов (28%)
  227. Садовник-художник (28%)
  228. Сапер (28%)
  229. Расшифровка (28%)
  230. Седловые точки (28%)
  231. Теория игр (28%)
  232. Дипломы (28%)
  233. Издевательство (28%)
  234. Развлечения с измерителем (28%)
  235. Стрелок (28%)
  236. Взвешивание (28%)
  237. Экономия (28%)
  238. Замок (29%)
  239. Сортировка подсчетом (29%)
  240. Количество участников олимпиады (29%)
  241. Число - палиндром (29%)
  242. Unix (29%)
  243. Задача Иосифа Флавия (29%)
  244. Боулинг (29%)
  245. Преобразование последовательности - 2 (29%)
  246. Две последовательности (29%)
  247. Телеграфный перевод (29%)
  248. Jивой Jурнал (29%)
  249. Шифровка (29%)
  250. Гипотеза Гольдбаха (30%)
  251. 2^N (30%)
  252. Золото племени АББА (30%)
  253. Забавная игра (30%)
  254. Деление-2 (30%)
  255. Сумма - 2 (30%)
  256. Сумма n-значных чисел (30%)
  257. Часы (30%)
  258. Числа Смита (30%)
  259. Телепортация (30%)
  260. Шаблон программы (30%)
  261. Постулат Бертрана (30%)
  262. Робот К-79 (30%)
  263. Быстрый поезд (30%)
  264. Степень строки (30%)
  265. Сверхстепень (30%)
  266. Строительство школы (30%)
  267. Шахматная мастерская (30%)
  268. Лексикографический порядок чисел (31%)
  269. Поле чудес (31%)
  270. Письмо (31%)
  271. Мы с конем вдвоем по полю пойдем (31%)
  272. Мероприятие (31%)
  273. Словарь (31%)
  274. Полка (31%)
  275. Простой цифровой корень (31%)
  276. Степенные числа (31%)
  277. Сдвиг текста (31%)
  278. Диалоги по UCM (31%)
  279. Криптограмма (31%)
  280. Сообщество роботов (31%)
  281. Money, money, money (31%)
  282. Список предметов (31%)
  283. Игра с пешкой (31%)
  284. Таймер (31%)
  285. N-значные числа (32%)
  286. Обмен пакетами (32%)
  287. Свадьба (32%)
  288. Подстроки из одинаковых букв (32%)
  289. Прямоугольники (32%)
  290. Волосатый бизнес (32%)
  291. Минимальный путь в таблице (32%)
  292. Только вправо или вниз (32%)
  293. Торт - 2 (32%)
  294. База террористов (32%)
  295. Военная база (32%)
  296. День рождения - 2 (32%)
  297. Игра с камешками (32%)
  298. Последовательность - 2 (32%)
  299. Чемпионат по стрельбе (32%)
  300. Гипотеза Гольдбаха - 2 (32%)
  301. Скачки (32%)
  302. Эволюция (32%)
  303. Покер (33%)
  304. Максимальная тройка (33%)
  305. Постройка дорог (33%)
  306. Сундук Билли Бонса (33%)
  307. Проценты (33%)
  308. Java vs C++ (34%)
  309. Даты (34%)
  310. Произведение цифр (42%)

Задачи из других источников: перейти в папку с задачами.

================================================ FILE: _other_tasks_/README.md ================================================

Еще задачи на Java из разных источников

Решение различных задач без указания сложности.

  1. Обжора (источник)
  2. Тестовое задание в NAUMEN (источник)
  3. Прогулка (источник)
  4. Ручки Леры (источник)
  5. Робот-секретарь (Яндекс)
  6. Надежный счетчик (Яндекс)
  7. Рыцари и лжецы (Отборочный тур олимпиады "Я-Профессионал")
  8. F. Положительные делители (Отборочный тур олимпиады "Я-Профессионал")
  9. H. Курьеры (Сириус 2021)
  10. I. Баскетбольный матч (Сириус 2021)
  11. J. Цифровой протокол (Сириус 2021)
  12. A. Квнщики (УрФУ 2021)
  13. B. Га-га 3 (УрФУ 2021)
  14. D. Игрушки (УрФУ 2021)
  15. F. Прогулка по Новоуральску (УрФУ 2021)
  16. E. Книжный шкаф (УрФУ 2021)
  17. C. Микробиология (Отборочный тур RuCode 2022)
  18. E. Числовой палиндром (Отборочный тур RuCode 2022)
  19. B. Второй сверху (Отборочный тур RuCode 2022)
  20. A1. GCD (RuCode 2022, Div E)
  21. I1. Быстрое возведение в степень (RuCode 2022, Div E)
  22. J1. Обратное по простому модулю (RuCode 2022, Div E)
  23. K1. Большие простые числа (RuCode 2022, Div E)
  24. A3. Коллекционер (RuCode 2022, Div E)
  25. B3. Мультиграф (RuCode 2022, Div E)
  26. A4. Выход из лабиринта (RuCode 2022, Div E)
  27. A5. прибавить один (RuCode 2022, Div E)
  28. B5. Сравнение чисел (RuCode 2022, Div E)
  29. C5. Сумма чисел (RuCode 2022, Div E)
  30. D5. Разность чисел (RuCode 2022, Div E)
  31. E5. Умножение (RuCode 2022, Div E)
  32. A. Граф подстрок (День стажера, Яндекс, 2022)
================================================ FILE: _other_tasks_/a_glutton/Glutton.java ================================================ package _other_tasks_.a_glutton; import java.io.PrintWriter; import java.util.Scanner; public class Glutton { public static void main(String[] args){ Scanner in = new Scanner(System.in); PrintWriter out = new PrintWriter(System.out); int a = in.nextInt(); int b = in.nextInt(); int c = in.nextInt(); int d = in.nextInt(); int e = in.nextInt(); if (a == 1) { out.println("Vsevolod"); } else if (b == 1) { out.println("Kirill"); } else if (c == 1) { out.println("Dmitry"); } else if (d == 1) { out.println("Nikolay"); } else if (e == 1) { out.println("Viktor"); } else { out.println("Marina"); } out.flush(); } } ================================================ FILE: _other_tasks_/a_glutton/README.md ================================================

A. Обжора

Время: 1 сек.
Память: 64 Мб

Очень голодные Сева, Кирилл, Дима, Коля, Витя сидят в аудитории и ждут начала консультации по математике. К сожалению, на всех пятерых у них оказалась только одна печенька. Единогласно было решено, что делить печеньку на всех поровну — абсолютно неинтересная идея. Тогда ребята решили сыграть в «обжору».

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

Было решено ходить в таком порядке: Сева, Кирилл, Дима, Коля, Витя. После Вити снова ходит Сева.

Ребята решили поберечь мозги перед обсуждением сложных математических вопросов, поэтому они придумали простые стратегии: каждый из мальчиков выбрал некоторую фиксированную долю, которую он будет откусывать от оставшейся печеньки на своём ходу. Сева будет кусать 1/a часть, Кирилл — 1/b, Дима — 1/c, Коля — 1/d, Витя — 1/e.

Еще известно, что если через 100 ходов печенька не будет доедена, то в аудиторию зайдёт очень голодная Марина и тут же съест всё, что осталось.

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

Формат ввода

В первой строке вводятся 5 целых чисел через пробел: a, b, c, d, e (1 ≤ a, b, c, d, e ≤ 100) из условия задач.

Формат вывода

Выведите имя обжоры на английском языке. Ниже приведены переводы имён:

Примеры

Ввод Вывод
5 2 1 3 4 Dmitry
1 1 1 1 1 Vsevolod

Замечания

Пояснение к первому примеру:

На первом ходе Сева откусит 1/5 долю печеньки, останется 4/5 = 1 − 1 · 1/5. На втором ходе Кирилл откусит 1/2 долю, то есть останется 2/5 = 4/5 − 4/5 · 1/2. На третьем ходу Дима откусит 1/1 долю печеньки, то есть доест её, т. к. останется 0 = 2/5 − 2/5 · 1/1.

================================================ FILE: _other_tasks_/b_robot_secretary/README.md ================================================

B. Робот-секретарь

Время: 2 сек.
Память: 256 Мб

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

Клавиатура печатной машинки состоит из 26 клавиш английского алфавита, клавиши пробела и клавиши Shift, которая изменяет регистр следующей набранной буквы на противоположный текущему. Двойное же нажатие на клавишу Shift изменяет текущий регистр машинки. В начале работы регистр всегда нижний, то есть при наборе без клавиши Shift будут печататься строчные буквы. Пробел одинаково набирается в обоих регистрах.

Настя хочет понять, за какое минимальное количество нажатий можно набрать текст, чтобы сравнить это с результатами робота.

Формат ввода

Входные данные – строка s (1 ≤ |s| ≤ 100 000), состоящая из прописных и строчных букв английского алфавита, а также символа пробела.

Формат вывода

Выведите единственное число — минимальное количество нажатий, необходимое, чтобы напечатать данную строку./p>

Примеры

Ввод Вывод
Hello World 13
APPLE II 10
================================================ FILE: _other_tasks_/b_robot_secretary/RobotSecretary.java ================================================ package _other_tasks_.b_robot_secretary; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class RobotSecretary { private static boolean isSmallRegister(char symbol) { return String.valueOf(symbol).equals(String.valueOf(symbol).toLowerCase()); } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); char[] symbols = sc.nextLine().toCharArray(); boolean isSmallRegister = true; int count = 0; for (int i = 0; i < symbols.length; i++) { if (symbols[i] == ' ') { count++; } else if (i+1 < symbols.length) { if (isSmallRegister && !isSmallRegister(symbols[i]) && !isSmallRegister(symbols[i + 1]) || !isSmallRegister && isSmallRegister(symbols[i]) && isSmallRegister(symbols[i + 1])) { // переключить регистр count += 3; isSmallRegister = !isSmallRegister; } else if (isSmallRegister && !isSmallRegister((symbols[i])) || !isSmallRegister && isSmallRegister((symbols[i]))) { // не переключать регистр count += 2; } else { count++; } } else { if (isSmallRegister && isSmallRegister((symbols[i])) || !isSmallRegister && !isSmallRegister((symbols[i]))) { count++; } else { count += 2; } } } PrintWriter out = new PrintWriter(System.out); out.println(count); out.flush(); } } ================================================ FILE: _other_tasks_/b_test_task_in_naumen/README.md ================================================

B. Тестовое задание в NAUMEN

Время: 1 сек.
Память: 64 Мб

NAUMEN — серьёзная компания. Кого попало на работу не берут. Первокурсник Арсений не боится трудностей и готов сегодня же приступить к выполнению тестового задания. Однако есть одна проблема. Арсений, как и большинство первокурсников, программирует только на C\# (и ещё немножко на C++), а в NAUMEN принято писать код на Java. Арсений, конечно, обещает, что быстро сможет выучить новый язык программирования, к тому же Java и C\# очень похожи. Однако, на слово Арсению верить никто не готов, поэтому специально для него подготовили несложную тестовую задачу, которую он должен решить на Java.

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

Чтобы сделать жизнь Арсения ещё веселее, было решено добавить в задачу что-нибудь из курса алгебры. Так и родилась следующая задача:

Даны два вектора: n-мерный вектор A над пространством положительных целых чисел и m-мерный вектор B над пространством строк. Требуется найти их «скалярное произведение». Любители алгебры уже всё поняли и побежали скорее писать решение за Арсения, а для всех остальных мы всё-таки поясним.

n-мерный вектор над пространством целых чисел — это есть ни что иное, как массив чисел A длины n. Аналогично, m-мерный вектор над пространством строк — это массив строк B длины m. Произведением строки x и положительного целого числа y (обозначение x × y) называется строка x, повторённая y раз. «Скалярным произведением» векторов A и B называется вектор C, имеющий такую же длину как и вектор A. i-й элемент вектора C равен B[i % m]× A[i] (i % m обозначает остаток от деления i на m). Требуется найти результат «скалярного произведения» двух заданных векторов.

Арсений уже написал решение на Java, но прежде чем отправить его на проверку, он хочет убедиться, что в нём нет багов. Поэтому он просит вас написать ещё одно решение на любом языке, чтобы сравнить ответы. Помогите Арсению попасть в NAUMEN, решите тестовое задание!

Формат ввода

В первой строке вводится целое число n — длина вектора A (1 ≤ n ≤ 10).

В следующей строке через пробел вводятся n положительных целых чисел — элементы вектора A, перечисленные по порядку начиная с первого и заканчивая последним. Каждый элемент вектора A не превосходит 10.

В следующей строке вводится целое число m — длина вектора B (1 ≤ m ≤ 10).

В следующей строке через пробел вводятся m непустых строк — элементы вектора B, перечисленные по порядку начиная с первого и заканчивая последним. Длина каждой строки из вектора B не превосходит 10. Cтроки состоят из маленьких и больших латинских букв.

Формат вывода

Выведите ровно n строк через пробел — элементы вектора C, являющегося «скалярным произведением» векторов A и B.

Примеры

Ввод Вывод
3
1 1 1
3
I love Naumen		 I love Naumen
5
1 1 1 2 2
3
Good luck Arseny		 Good luck Arseny GoodGood luckluck
================================================ FILE: _other_tasks_/b_test_task_in_naumen/TestTaskInNaumen.java ================================================ package _other_tasks_.b_test_task_in_naumen; import java.io.PrintWriter; import java.util.Scanner; public class TestTaskInNaumen { public static void main(String[] args) { Scanner in = new Scanner(System.in); PrintWriter out = new PrintWriter(System.out); int n = Integer.parseInt(in.nextLine()); String[] vectorN = in.nextLine().split(" "); int m = Integer.parseInt(in.nextLine()); String[] vectorM = in.nextLine().split(" "); int index = 0; for (String number: vectorN) { int count = Integer.parseInt(number); for (int i = 0; i < count; i++) { out.print(vectorM[index]); } out.print(" "); index++; if (index >= vectorM.length) { index = 0; } } out.flush(); } } ================================================ FILE: _other_tasks_/big_add_one/BigAddOne.java ================================================ package _other_tasks_.big_add_one; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class BigAddOne { public static int[] normalize(int[] nums) { int correct = 0; for (int i = nums.length - 1; i >= 0; i--) { if (nums[i] == 0) { correct++; } else break; } int arrSize = nums.length - correct; if (arrSize == 0) { arrSize = 1; } int[] newNums = new int[arrSize]; System.arraycopy(nums, 0, newNums, 0, newNums.length); return newNums; } public static int[] addOne(int[] num) { ArrayList tmp = new ArrayList<>(); int carry = 1; for (int j : num) { int sum = carry + j; tmp.add(sum % 10); carry = sum / 10; } if (carry != 0) { tmp.add(carry); } int[] res = new int[tmp.size()]; for (int i = 0; i < tmp.size(); i++) { res[i] = tmp.get(i); } return res; } public static void main(String[] args) throws FileNotFoundException { Scanner sc = new Scanner(new FileReader("input.txt")); PrintWriter out = new PrintWriter(System.out); String[] a = sc.nextLine().split(""); int[] aArr = new int[a.length]; int j = a.length - 1; for (int i = 0; i < a.length; i++) { aArr[i] = Integer.parseInt(a[j]); j--; } int[] res = normalize(addOne(aArr)); StringBuilder resStr = new StringBuilder(); boolean start = true; for (int i = res.length - 1; i >= 0; i--) { if (start && res[i] == 0) { continue; } if (start && res[i] != 0) { start = false; } resStr.append(res[i]); } if (resStr.length() == 0) { resStr.append("0"); } out.println(resStr); out.flush(); } } ================================================ FILE: _other_tasks_/big_add_one/BigAddOneShort.java ================================================ package _other_tasks_.big_add_one; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class BigAddOneShort { public static void main(String[] args) throws FileNotFoundException { Scanner sc = new Scanner(new FileReader("input.txt")); PrintWriter out = new PrintWriter(System.out); BigInteger num = new BigInteger(sc.nextLine()); BigInteger res = num.add(BigInteger.ONE); out.println(res); out.flush(); } } ================================================ FILE: _other_tasks_/big_add_one/README.md ================================================

A5. прибавить один

Время: 1 сек.
Память: 64Mb

Напишите программу, которая прибавляет 1 к целому числу N длина числа N до 1000 знаков

Формат ввода

Дано чиcло N

Формат вывода

Выведите число N+1

Примеры

Ввод Вывод
1 2
5 6
================================================ FILE: _other_tasks_/big_comparing_numbers/BigComparingNumbers.java ================================================ package _other_tasks_.big_comparing_numbers; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.PrintWriter; import java.util.Scanner; public class BigComparingNumbers { public static int[] normalize(int[] nums) { int correct = 0; for (int i = nums.length - 1; i >= 0; i--) { if (nums[i] == 0) { correct++; } else break; } int arrSize = nums.length - correct; if (arrSize == 0) { arrSize = 1; } int[] newNums = new int[arrSize]; System.arraycopy(nums, 0, newNums, 0, newNums.length); return newNums; } public static boolean aSmaller (int[] a, int[] b) { if (a.length < b.length) { return true; } else if (a.length > b.length) { return false; } else { for (int i = a.length - 1; i >= 0; i--) { if (a[i] > b[i]) { return false; } if (a[i] < b[i]) { return true; } } return false; } } public static void main(String[] args) throws FileNotFoundException { Scanner sc = new Scanner(new FileReader("input.txt")); PrintWriter out = new PrintWriter(System.out); String[] a = sc.nextLine().split(""); String[] b = sc.nextLine().split(""); int[] aArr = new int[a.length]; int[] bArr = new int[b.length]; int j = a.length - 1; for (int i = 0; i < a.length; i++) { aArr[i] = Integer.parseInt(a[j]); j--; } j = b.length - 1; for (int i = 0; i < b.length; i++) { bArr[i] = Integer.parseInt(b[j]); j--; } boolean itentic = aArr.length == bArr.length; if (itentic) { int maxSize = Math.max(aArr.length, bArr.length); for (int i = 0; i < maxSize; i++) { if (aArr[i] != bArr[i]) { itentic = false; break; } } } boolean res = aSmaller(aArr, bArr); if (itentic) { out.println("="); } else if (res) { out.println("<"); } else { out.println(">"); } out.flush(); } } ================================================ FILE: _other_tasks_/big_comparing_numbers/BigComparingNumbersShort.java ================================================ package _other_tasks_.big_comparing_numbers; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class BigComparingNumbersShort { public static void main(String[] args) throws FileNotFoundException { Scanner sc = new Scanner(new FileReader("input.txt")); PrintWriter out = new PrintWriter(System.out); BigInteger a = new BigInteger(sc.nextLine()); BigInteger b = new BigInteger(sc.nextLine()); if (a.compareTo(b) > 0) { out.println(">"); } else if (a.compareTo(b) == 0) { out.println("="); } else { out.println("<"); } out.flush(); } } ================================================ FILE: _other_tasks_/big_comparing_numbers/README.md ================================================

B5. Сравнение чисел

Время: 1 сек.
Память: 64Mb

Напишите программу, которая сравнит два целых неотрицательных числа и выведет результат сравнения.

Формат ввода

Даны два целых неотрицательных числа, в записи каждого не более 200 цифр.

Формат вывода

Выведите знак <, если первое число меньше второго, знак >, если первое больше второго или знак =, если числа совпадают.

Примеры

Ввод Вывод
0
0		 =
63416241155558449158
63416241155558449157		 >
================================================ FILE: _other_tasks_/big_difference_numbers/BigDifferenceNumbers.java ================================================ package _other_tasks_.big_difference_numbers; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class BigDifferenceNumbers { public static int[] normalize(int[] nums) { int correct = 0; for (int i = nums.length - 1; i >= 0; i--) { if (nums[i] == 0) { correct++; } else break; } int arrSize = nums.length - correct; if (arrSize == 0) { arrSize = 1; } int[] newNums = new int[arrSize]; System.arraycopy(nums, 0, newNums, 0, newNums.length); return newNums; } public static boolean aSmaller (int[] a, int[] b) { if (a.length < b.length) { return true; } else if (a.length > b.length) { return false; } else { for (int i = a.length - 1; i >= 0; i--) { if (a[i] > b[i]) { return false; } if (a[i] < b[i]) { return true; } } return false; } } public static int[] minus(int[] a, int[] b) { ArrayList tmp = new ArrayList<>(); int carry = 0; for (int i = 0; i < b.length; i++) { int cur_diff = a[i] - b[i] - carry; if (cur_diff < 0) { cur_diff += 10; carry = 1; } else { carry = 0; } tmp.add(cur_diff); } for (int i = b.length; i < a.length; i++) { if (a[i] - carry < 0) { tmp.add(a[i] + 10 - carry); carry = 1; } else { tmp.add(a[i] - carry); carry = 0; } } int[] res = new int[tmp.size()]; for (int i = 0; i < tmp.size(); i++) { res[i] = tmp.get(i); } return normalize(res); } public static void main(String[] args) throws FileNotFoundException { Scanner sc = new Scanner(new FileReader("input.txt")); PrintWriter out = new PrintWriter(System.out); String[] a = sc.nextLine().split(""); String[] b = sc.nextLine().split(""); int[] aArr = new int[a.length]; int[] bArr = new int[b.length]; int j = a.length - 1; for (int i = 0; i < a.length; i++) { aArr[i] = Integer.parseInt(a[j]); j--; } j = b.length - 1; for (int i = 0; i < b.length; i++) { bArr[i] = Integer.parseInt(b[j]); j--; } int[] res = minus(aArr, bArr); StringBuilder resStr = new StringBuilder(); boolean start = true; for (int i = res.length - 1; i >= 0; i--) { if (start && res[i] == 0) { continue; } if (start && res[i] != 0) { start = false; } resStr.append(res[i]); } if (resStr.length() == 0) { resStr.append("0"); } out.println(resStr); out.flush(); } } ================================================ FILE: _other_tasks_/big_difference_numbers/BigDifferenceNumbersShort.java ================================================ package _other_tasks_.big_difference_numbers; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class BigDifferenceNumbersShort { public static void main(String[] args) throws FileNotFoundException { Scanner sc = new Scanner(new FileReader("input.txt")); PrintWriter out = new PrintWriter(System.out); BigInteger a = new BigInteger(sc.nextLine()); BigInteger b = new BigInteger(sc.nextLine()); out.println(a.subtract(b)); out.flush(); } } ================================================ FILE: _other_tasks_/big_difference_numbers/README.md ================================================

D5. Разность чисел

Время: 1 сек.
Память: 64Mb

Напишите программу, вычисляющую разность двух целых неотрицательных чисел. Длина каждого из чисел не превосходит 250.

Формат ввода

Даны два числа, каждое записано на отдельной строке. Гарантируется, что первое число не меньше второго.

Формат вывода

Выведите разность данных чисел.

Примеры

Ввод Вывод
987654
876543		 111111
100000
1		 99999
================================================ FILE: _other_tasks_/big_multiplication/BigMultiplication.java ================================================ package _other_tasks_.big_multiplication; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.PrintWriter; import java.util.Scanner; public class BigMultiplication { public static boolean aSmaller (int[] a, int[] b) { if (a.length < b.length) { return true; } else if (a.length > b.length) { return false; } else { for (int i = a.length - 1; i >= 0; i--) { if (a[i] > b[i]) { return false; } if (a[i] < b[i]) { return true; } } } return true; } public static int[] multi (int[] a, int[] b) { int[] res = new int[a.length * b.length + 1]; for (int i = 0; i < a.length; i++) { int carry = 0; for (int j = 0; j < b.length; j++) { int tmp = res[i + j] + a[i] * b[j] + carry; carry = tmp / 10; res[i + j] = tmp % 10; } int tmp = b.length; while (carry > 0) { res[i + tmp] = carry % 10; tmp++; carry /= 10; } } return res; } public static int[] divide (int[] a, int[] b) { int[] res = new int[a.length - b.length + 1]; for (int i = res.length - 1; i >= 0; i--) { while (aSmaller(multi(b, res), a)) { res[i]++; } res[i]--; } if (res[res.length - 1] == 0) { int[] resNew = new int[res.length - 1]; System.arraycopy(res, 0, resNew, 0, res.length - 1); return resNew; } return res; } public static void main(String[] args) throws FileNotFoundException { Scanner sc = new Scanner(new FileReader("input.txt")); PrintWriter out = new PrintWriter(System.out); String[] a = sc.nextLine().split(""); String[] b = sc.nextLine().split(""); int[] aArr = new int[a.length]; int[] bArr = new int[b.length]; int j = a.length - 1; for (int i = 0; i < a.length; i++) { aArr[i] = Integer.parseInt(a[j]); j--; } j = b.length - 1; for (int i = 0; i < b.length; i++) { bArr[i] = Integer.parseInt(b[j]); j--; } int[] res = multi(aArr, bArr); StringBuilder resStr = new StringBuilder(); boolean start = true; for (int i = res.length - 1; i >= 0; i--) { if (start && res[i] == 0) { continue; } if (start && res[i] != 0) { start = false; } resStr.append(res[i]); } if (resStr.length() == 0) { resStr.append("0"); } out.println(resStr); out.flush(); } } ================================================ FILE: _other_tasks_/big_multiplication/BigMultiplicationShort.java ================================================ package _other_tasks_.big_multiplication; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class BigMultiplicationShort { public static void main(String[] args) throws FileNotFoundException { Scanner sc = new Scanner(new FileReader("input.txt")); PrintWriter out = new PrintWriter(System.out); BigInteger a = new BigInteger(sc.nextLine()); BigInteger b = new BigInteger(sc.nextLine()); out.println(a.multiply(b)); out.flush(); } } ================================================ FILE: _other_tasks_/big_multiplication/README.md ================================================

E5. Умножение

Время: 1 сек.
Память: 64Mb

Напишите программу, которая вычисляет произведение двух целых неотрицательных чисел. Длина каждого числа не превышает 250 знаков.

Формат ввода

Даны два числа, каждое записано в отдельной строке.

Формат вывода

Выведите произведение чисел.

Примеры

Ввод Вывод
827364
34		 28130376
23
9999		 229977
================================================ FILE: _other_tasks_/big_sum_numbers/BigSumNumbers.java ================================================ package _other_tasks_.big_sum_numbers; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class BigSumNumbers { public static int[] normalize(int[] nums) { int correct = 0; for (int i = nums.length - 1; i >= 0; i--) { if (nums[i] == 0) { correct++; } else break; } int arrSize = nums.length - correct; if (arrSize == 0) { arrSize = 1; } int[] newNums = new int[arrSize]; System.arraycopy(nums, 0, newNums, 0, newNums.length); return newNums; } public static boolean aSmaller (int[] a, int[] b) { if (a.length < b.length) { return true; } else if (a.length > b.length) { return false; } else { for (int i = a.length - 1; i >= 0; i--) { if (a[i] > b[i]) { return false; } if (a[i] < b[i]) { return true; } } return false; } } public static int[] plus(int[] a, int[] b) { ArrayList tmp = new ArrayList<>(); int carry = 0; for (int i = 0; i < Math.min(a.length, b.length); i++) { int sum = carry + a[i] + b[i]; tmp.add(sum % 10); carry = sum / 10; } for (int i = Math.min(a.length, b.length); i < Math.max(a.length, b.length); i++) { if (a.length > b.length) { int sum = carry + a[i]; tmp.add(sum % 10); carry = sum / 10; } else { int sum = carry + b[i]; tmp.add(sum % 10); carry = sum / 10; } } if (carry != 0) { tmp.add(carry); } int[] res = new int[tmp.size()]; for (int i = 0; i < tmp.size(); i++) { res[i] = tmp.get(i); } return res; } public static void main(String[] args) throws FileNotFoundException { Scanner sc = new Scanner(new FileReader("input.txt")); PrintWriter out = new PrintWriter(System.out); String[] a = sc.nextLine().split(""); String[] b = sc.nextLine().split(""); int[] aArr = new int[a.length]; int[] bArr = new int[b.length]; int j = a.length - 1; for (int i = 0; i < a.length; i++) { aArr[i] = Integer.parseInt(a[j]); j--; } j = b.length - 1; for (int i = 0; i < b.length; i++) { bArr[i] = Integer.parseInt(b[j]); j--; } int[] res = plus(aArr, bArr); StringBuilder resStr = new StringBuilder(); boolean start = true; for (int i = res.length - 1; i >= 0; i--) { if (start && res[i] == 0) { continue; } if (start && res[i] != 0) { start = false; } resStr.append(res[i]); } if (resStr.length() == 0) { resStr.append("0"); } out.println(resStr); out.flush(); } } ================================================ FILE: _other_tasks_/big_sum_numbers/BigSumNumbersShort.java ================================================ package _other_tasks_.big_sum_numbers; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class BigSumNumbersShort { public static void main(String[] args) throws FileNotFoundException { Scanner sc = new Scanner(new FileReader("input.txt")); PrintWriter out = new PrintWriter(System.out); BigInteger a = new BigInteger(sc.nextLine()); BigInteger b = new BigInteger(sc.nextLine()); out.println(a.add(b)); out.flush(); } } ================================================ FILE: _other_tasks_/big_sum_numbers/README.md ================================================

C5. Сумма чисел

Время: 1 сек.
Память: 64Mb

Напишите программу, которая вычисляет сумму двух целых неотрицательных чисел. Длина каждого из чисел не превосходит 250.

Формат ввода

Даны два числа, каждое записано на отдельной строке.

Формат вывода

Выведите сумму данных чисел.

Примеры

Ввод Вывод
0
0		 0
99999
1		 100000
================================================ FILE: _other_tasks_/book/Book.java ================================================ package _other_tasks_.book; import java.io.PrintWriter; import java.util.Scanner; public class Book { public static void main(String[] args) { Scanner sc = new Scanner(System.in); PrintWriter out = new PrintWriter(System.out); int n, k, m1, m2; n = Integer.parseInt(sc.nextLine()); String[] line = sc.nextLine().split(" "); k = Integer.parseInt(line[0]); m1 = Integer.parseInt(line[1]); m2 = Integer.parseInt(line[2]); int count = 0; while (n > 0) { String[] book = sc.nextLine().split(" "); long h, k1; h = Long.parseLong(book[0]); for (int i = 2; i < book.length; i++) { long size = Long.parseLong(book[i]); if (size * m2 <= h * k && size * m1 >= h) { continue; } count++; } n--; } out.println(count); out.flush(); } } ================================================ FILE: _other_tasks_/book/README.md ================================================

E. Книжный шкаф

Время: 2 сек.
Память: 256 Мб

Андрей любит читать, поэтому он недавно устроился в библиотеку. Библиотека оказалось необычной: размер книги здесь напрямую связан с ростом человека, который её читает. Недавно в библиотеку завезли новый книжный шкаф. Он быстро заполнился, так как посетителей в библиотеке было довольно много. Андрей проявлял активность и внимательно следил за тем, как люди ставят и забирают книги из шкафа.
Тем временем шкаф оказался довольно необычным — полки в нём расположены на разных высотах. Первая полка расположена на высоте h1 от пола, вторая — на высоте h2, …, n-я полка расположена на высоте hn.
Достаточно изучив, как люди кладут и забирают книги, Андрей заметил, что человек с ростом height не может поставить свою книгу на полку высотой больше height, а также на полку высотой меньше height / k. Также он заметил, что у человека с ростом height размер книги явно не меньше height / m1 и не больше height / m2.
Теперь Андрей смотрит на шкаф, и ему кажется, что некоторые книги появились там волшебным образом — ни один человек не мог их туда поставить, исходя из его наблюдений. Помогите ему проверить это — посчитайте количество книг, которые не удовлетворяют наблюдениям.

Исходные данные

В первой строке дано число n — количество полок в шкафу (1 ≤ n ≤ 105).
Во второй строке даны три числа: k, m1 и m2 — коэффициенты, выведенные Андреем (1 ≤ k ≤ 100; 1 ≤ m2 ≤ m1 ≤ 100).
В следующих n строках дано описание полок: для i-й полки сначала дано число hi — её высота (1 ≤ h1 ≤ 107, hi−1 < hi ≤ 107 для всех i > 1). Далее дано число ki — количество книг на этой полке (1 ≤ ki ≤ 105). После этого даны ki чисел sizei,j — размеры книг на полке (1 ≤ sizei, j ≤ 107).
Гарантируется, что сумма всех ki не превосходит 105.

Результат

В единственной строке выведите количество книг, которые не удовлетворяют наблюдениям Андрея.

Пример

исходные данные результат 
3
2 1 1
1 2 1 2
2 2 1 4
4 2 3 4
 
2

Замечания

В примере всего две книги, не удовлетворяющие наблюдениям Андрея — книга размером 1 на полке высотой 2 и книга размером 3 на полке высотой 4.
================================================ FILE: _other_tasks_/c_walk/README.md ================================================

C. Прогулка

Время: 1 сек.
Память: 64 Мб

Когда человек не хочет что-то делать, у него найдётся 1000000 причин это не делать. Вот и сейчас, когда Сева с Женей зовут Кирилла гулять в парк, у него моментально появилась куча дел. Однако, после многочасовых переговоров (за время которых, к слову, можно было успеть прогуляться) Кирилл согласился, но с некоторыми оговорками. Во-первых, врач наказывал ему не подниматься слишком высоко над уровнем моря (что это за врач, и с чем связан такой совет, никто не знает). Во-вторых, он был согласен гулять только по квадратам (так как у них аура лучше, чем у любой другой фигуры). Женя и Сева растерялись и даже испугались, что не найдут подходящего для прогулки места, поэтому обратились к вам, чтобы узнать, сколько таких областей существует.

Опишем требования Кирилла более формально:

  • Парк представляет из себя матрицу размеров n × m. Каждый участок матрицы описывается числом Ai,j — высота соответствующего участка.
  • Кирилл согласится на прогулку только по подквадрату парка. (Подквадратом парка будем считать любую квадратную подматрицу матрицы A)
  • Кирилл согласится гулять по выбранному подквадрату только при условии, что суммарная высота данного квадрата меньше S. (Суммарная высота подквадрата — это сумма элементов матрицы A на соответствующем подквадрате).

Формат ввода

В первой строке вводятся 3 целых числа через пробел n, m  — размеры парка, S — ограничение на подквадраты (1 ≤ n, m ≤ 30, 1 ≤ S ≤ 109). В каждой из следующих n строк вводятся m чисел через пробел Ai,j (0 ≤ Ai, j ≤ 107).

Формат вывода

В единственной строке выведите количество участков парка, по которым согласится гулять Кирилл.

Примеры

Ввод Вывод
2 3 4
1 2 3
4 5 6		 3
2 3 11
1 2 3
4 5 6		 6
================================================ FILE: _other_tasks_/c_walk/Walk.java ================================================ package _other_tasks_.c_walk; import java.io.PrintWriter; import java.util.Scanner; public class Walk { public static void main(String[] args) { Scanner in = new Scanner(System.in); PrintWriter out = new PrintWriter(System.out); String[] info = in.nextLine().split(" "); int n = Integer.parseInt(info[0]); int m = Integer.parseInt(info[1]); long s = Long.parseLong(info[2]); int count = 0; long[][] matrix = new long[n][m]; for (int i = 0; i < n; i++) { String[] line = in.nextLine().split(" "); for (int j = 0; j < line.length; j++) { long number = Long.parseLong(line[j]); // проверка каждого элемента if (number < s) { count++; } matrix[i][j] = number; } } int min = Math.min(n, m); int countCell = 2; int rowStart = 0; int columnStart = 0; boolean exit = false; // проверка квадратов while (countCell <= min) { long sumTmp = -1; for (int i = rowStart; i < rowStart+countCell; i++) { for (int j = columnStart; j < columnStart+countCell; j++) { if (rowStart+countCell <= n && columnStart+countCell <= m) { long number = matrix[i][j]; if (number >= s) { exit = true; break; } if (sumTmp == -1) { sumTmp = number; } else { sumTmp += number; } if (sumTmp > s) { // выйти, если условие невозможно exit = true; break; } } } if (exit) { break; } } if (!exit && sumTmp > -1 && sumTmp < s) { count++; } rowStart++; // сдвиг вправо exit = false; if (rowStart > n) { // сдвиг вниз rowStart = 0; columnStart++; } if (columnStart > m) { // увеличение размера квадрата rowStart = 0; columnStart = 0; countCell++; } } out.println(count); out.flush(); } } ================================================ FILE: _other_tasks_/champion/Champion.java ================================================ package _other_tasks_.champion; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; ////////// неверно public class Champion { public static void main(String[] args) { ArrayList nums = new ArrayList<>(); Scanner sc = new Scanner(System.in); PrintWriter out = new PrintWriter(System.out); sc.nextLine(); String[] data = sc.nextLine().split(" "); long k = 0; for (String s: data) { nums.add(Long.parseLong(s) + k); k++; } if (nums.size() == 1) { out.println(1); } else { long len = 0; long max = 0; for (int i = 0; i < nums.size(); i++) { if (i == 0) { continue; } if (nums.get(i - 1) < nums.get(i)) { if (i == 1 || len == 0) { len++; } len++; } else { if (max < len) { max = len; } len = 0; } } if (max == 0 || len > max) { out.println(len); } else { out.println(max); } } out.flush(); } } ================================================ FILE: _other_tasks_/collector/Collector.java ================================================ package _other_tasks_.collector; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.StringTokenizer; public class Collector { public static void main(String[] args) throws IOException { short markUniq = 0; short collectionSize = 15000; byte[] data = new byte[collectionSize]; BufferedReader br = new BufferedReader(new FileReader("collection.in")); short index = 0; for (String line; (line = br.readLine()) != null; ) { if (index == 1) { StringTokenizer st = new StringTokenizer(line, " "); while(st.hasMoreTokens()){ short num = Short.parseShort(st.nextToken()); if (data[num-1] == 0) { data[num-1] = 1; markUniq++; } if (markUniq == collectionSize) { break; } } } index++; } PrintWriter out = new PrintWriter(System.out); out.println(collectionSize - markUniq); out.flush(); } } ================================================ FILE: _other_tasks_/collector/README.md ================================================

A3. Коллекционер

Время: 1 сек.
Память: 256Mb

В Байтландии за всю её историю было выпущено 15000 различных почтовых марок. Известный коллекционер почтовых марок планирует собрать полную коллекцию марок Байтландии. Какое-то количество марок (возможно, с дубликатами) у него есть на данным момент). По заданному списку марок, имеющихся в наличии, вычислить, какое минимальное количество марок коллекционер должен докупить, чтобы коллекция стала полной.

Формат ввода

Входной файл состоит из двух строк. В первой строке задано одно целое число n (1 ≤ n ≤ 3 000 000) — количество имеющихся на данный момент у коллекционера экземпляров байтландских марок. Во второй строке заданы n целых чисел, каждое из которых лежит в интервале [1, 15000] — номер марки, представленной соответствующим экземпляром.

Формат вывода

Одно число — минимальное количество марок, которое коллекционер должен докупить, чтобы коллекция стала полной.

Примеры

Ввод Вывод
8
3 6 2 2 4 6 3 7		 14995
================================================ FILE: _other_tasks_/d_leras_pens/LerasPens.java ================================================ package _other_tasks_.d_leras_pens; import java.io.PrintWriter; import java.util.Scanner; public class LerasPens { public static void main(String[] args) { Scanner in = new Scanner(System.in); PrintWriter out = new PrintWriter(System.out); String[] info = in.nextLine().split(" "); int n = Integer.parseInt(info[0]); int k = Integer.parseInt(info[1]); int forgot = 0; int kStart = k; for (int i = 0; i < n; i++) { String[] student = in.nextLine().split(" "); int a = Integer.parseInt(student[0]); int b = Integer.parseInt(student[1]); if (i == 0) { forgot = b; k -= forgot; } else { if (forgot == 0) { forgot = b; k -= forgot; } else if (forgot > a) { k += a; forgot = kStart - k; if (b > forgot) { int c = b - forgot; k -= c; } } else { k += forgot; k -= b; } } forgot = kStart - k; } out.println(k); out.flush(); } } ================================================ FILE: _other_tasks_/d_leras_pens/README.md ================================================

D. Ручки Леры

Время: 1 сек.
Память: 64 Мб

Как известно, студенты делятся на 2 типа: студенты 1-го типа носят канцелярские принадлежности на пары, а студенты 2-го типа одалживают их у первого. В свою очередь студенты 2-го типа делятся на ещё на 2 подтипа: те, кто возвращает ручку хозяину, и те, кто забывают её вернуть.

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

Лера относится к студентам 1-го типа. Ей бы очень хотелось, чтобы в конце учебного дня ручек у нее осталось как можно больше. Завтра понедельник, у неё n пар, Лера возьмёт с собой k ручек. Перед парой i к Лере подойдёт ai + bi студентов 2-го типа, ai из которых вернут ручку сразу после пары, а bi забудут.

Каждому студенту девушка будет помогать одним из двух способов: либо даст ручку от себя, либо попросит забрать её у какого-нибудь студента, одолжившего ручку ранее, но не вернувшего её.

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

Помогите Лере узнать, сколько максимум ручек будут у неё в конце учебного дня при оптимальной стратегии.

Формат ввода

В первой строке вводятся 2 целых числа через пробел: n (1 ≤ n ≤ 100) и k (1 ≤ k ≤ 1000). В каждой из следующих n строк через пробел вводятся по 2 целых числа ai и bi (0 ≤ ai, bi ≤ k, ai + bi ≤ k).

Формат вывода

В единственной строке выведите максимальное количество ручек, которое может остаться у Леры в конце учебного дня.

Примеры

Ввод Вывод
2 4
1 2
1 1		 3

Замечания

Пояснение к примеру:

Перед первой парой к Лере подойдёт 3 студента. Обозначим их номерами 1, 2, 3 (из них 2, 3 забудут вернуть ручку). Перед 2-й парой Лере вернётся ручка от 1-го студента, и подойдут студенты 4, 5 (5 забудет вернуть ручку). Она может отправить 4-го студента ко 2-му, а 5-го к 3-му. Таким образом на 2-й паре ручки будут у студентов с номерами 4, 5 (А у студентов 2, 3 их больше не будет). После 2-й пары 4-й студент вернёт ручку, а 5-й нет. Тогда в конце дня у Леры будут все ручки, кроме той, что осталась у 5-го студента.

================================================ FILE: _other_tasks_/d_reliable_tag/README.md ================================================

D. Надежный счетчик

Время: 2 сек.
Память: 256 Мб

Для подсчета количества запусков программы в офлайн-режиме сделали счетчик:

  • Показание счетчика в каждый момент времени – это отсортированная по неубыванию последовательность n чисел a 1 ≤ a 2 ≤ … ≤ an.
  • При каждом запуске программы состояние счетчика изменяется: a 1 заменяется суммой k минимальных элементов последовательности, т. е. ∑ki = 1 ai, и последовательность сортируется.

Зная начальное состояние счетчика и количество операций изменения счетчика r, найдите итоговую последовательность, задающую состояние счетчика.

Гарантируется, что во всех тестах значения элементов последовательности не выходят за пределы диапазона [−1012..1012].

Формат ввода

В первой строке записаны три целых числа n, k, r (1 ≤ n, k, r ≤ 200000, k ≤ n) — длина последовательности элементов счетчика, количество участвующих в изменении счетчика элементов последовательности, количество операций изменения счетчика. Во второй строке записаны n целых чисел ai (−1000000 ≤ ai ≤ 1000000) — начальные элементы последовательности, задающей состояние счетчика. Последовательность отсортирована в порядке неубывания элементов.

Формат вывода

Выведите n чисел — элементы последовательности, задающей состояние счетчика, после r изменений. Выводите числа, разделяя их пробелами, в неубывающем порядке.

Примеры

Ввод Вывод
2 2 5
1 1		 8 13
5 3 4
0 0 0 1 2		 0 0 0 1 2
10 3 100
1 2 3 4 5 6 7 8 9 10		 604466 686144 781715 890453 1010587 1140842 1282129 1438574 1617218 1826247
================================================ FILE: _other_tasks_/d_reliable_tag/ReliableTag.java ================================================ package _other_tasks_.d_reliable_tag; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.*; public class ReliableTag { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] line1 = sc.nextLine().split(" "); String[] line2 = sc.nextLine().split(" "); ArrayList array = new ArrayList<>(); for (String number: line2) { array.add(Long.parseLong(number)); } int n = Integer.parseInt(line1[0]); int k = Integer.parseInt(line1[1]); int r = Integer.parseInt(line1[2]); for (int i = 0; i < r; i++) { long a1 = 0; for (int j = 0; j < k; j++) { a1 += array.get(j); } array.remove(0); if (array.size() == 0 || array.size() == 1) { array.add(a1); Collections.sort(array); } else { for (int j = 0; j < array.size(); j++) { // вставить элемент в лист в порядке возрастания if (j+1 < array.size() && (a1 >= array.get(j) && a1 < array.get(j+1))) { ArrayList slice = new ArrayList(array.subList(j+1, array.size())); array.removeAll(slice); array.add(a1); array.addAll(slice); break; } } if (array.size() < n) { array.add(a1); } } } PrintWriter out = new PrintWriter(System.out); for (long number: array) { out.print(number + " "); } out.flush(); } } ================================================ FILE: _other_tasks_/e_knights_and_knaves/KnightsAndKnaves.java ================================================ package _other_tasks_.e_knights_and_knaves; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class KnightsAndKnaves { public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); Scanner sc = new Scanner(new FileReader("input.txt")); sc.nextLine(); String[] items = sc.nextLine().split(" "); ArrayList k = new ArrayList<>(); boolean success = false; for (String item : items) { k.add(Integer.parseInt(item)); } k.sort(Collections.reverseOrder()); for (int i = 0; i < k.size(); i++) { if (k.get(i) > i && (i+1 == k.size() || i+1 < k.size() && k.get(i+1) <= i)) { success = true; out.println(i+1); } } if (!success && k.get(k.size()-1) >= k.size()) { success = true; out.println(k.size()); } if (!success) { out.println("-1"); } out.flush(); } } ================================================ FILE: _other_tasks_/e_knights_and_knaves/README.md ================================================

E. Рыцари и лжецы

Время: 1 сек.
Память: 64 Мб

На острове живут n человек. Каждый из них либо рыцарь, либо лжец. Все рыцари всегда говорят правду, все лжецы всегда лгут. Каждый человек сделал по одному утверждению. i-тый островитянин (1 ≤ i ≤ n) сказал: "Среди всех людей на острове не более ki рыцарей".

По заданным утверждениям островитян найдите любое возможное количество рыцарей на острове или определите, что такая ситуация невозможна.

Формат ввода

Первая строка входных данных содержит одно целое число n (1 ≤ i ≤ 1000) — количество жителей острова.

Во второй строке задаются n целых чисел ki (1 ≤ ki ≤ n), разделенных пробелом.

Формат вывода

Если описанная ситуация невозможна, то выведите −1. Иначе выведите одно целое число — количество рыцарей, живущих на острове. Если есть несколько возможных ответов, разрешается вывести любой из них.

Примеры

Ввод Вывод
2
2 2		 2
4
0 1 2 3		 2
================================================ FILE: _other_tasks_/exit_from_maze/ExitFromMaze.java ================================================ package _other_tasks_.exit_from_maze; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.ArrayDeque; public class ExitFromMaze { public static void main(String[] args) throws IOException { BufferedReader sc = new BufferedReader(new FileReader("input.txt")); int index = 0, n = 0, m = 0; int[] menCoord = new int[2]; int[] houseCoord = new int[2]; int[][] labirint = new int[0][0]; for (String line; (line = sc.readLine()) != null; ) { String[] str = line.split(" "); if (index == 0) { n = Integer.parseInt(str[0]); m = Integer.parseInt(str[1]); labirint = new int[n][m]; } else if (index == n + 1) { menCoord[0] = Integer.parseInt(str[1])-1; menCoord[1] = Integer.parseInt(str[0])-1; } else if (index == n + 2) { houseCoord[0] = Integer.parseInt(str[1])-1; houseCoord[1] = Integer.parseInt(str[0])-1; } else { for (int i = 0; i < str.length; i++) { short num = Short.parseShort(str[i]); if (num == 1) { labirint[index-1][i] = -1; } } } index++; } labirint[menCoord[0]][menCoord[1]] = 1; ArrayDeque queue = new ArrayDeque<>(); queue.addLast(menCoord); while (!queue.isEmpty()) { int[] point = queue.getFirst(); queue.removeFirst(); if (point[0] == houseCoord[0] && point[1] == houseCoord[1]) { System.out.println(labirint[point[0]][point[1]] - 1); return; } if (point[0] - 1 >= 0 && labirint[point[0] - 1][point[1]] == 0) { // вверх labirint[point[0] - 1][point[1]] = labirint[point[0]][point[1]] + 1; int[] tmp = new int[2]; tmp[0] = point[0] - 1; tmp[1] = point[1]; queue.addLast(tmp); } if (point[1] + 1 < m && labirint[point[0]][point[1] + 1] == 0) { // вправо labirint[point[0]][point[1] + 1] = labirint[point[0]][point[1]] + 1; int[] tmp = new int[2]; tmp[0] = point[0]; tmp[1] = point[1] + 1; queue.addLast(tmp); } if (point[0] + 1 < n && labirint[point[0] + 1][point[1]] == 0) { // вниз labirint[point[0] + 1][point[1]] = labirint[point[0]][point[1]] + 1; int[] tmp = new int[2]; tmp[0] = point[0] + 1; tmp[1] = point[1]; queue.addLast(tmp); } if (point[1] - 1 >= 0 && labirint[point[0]][point[1] - 1] == 0) { // влево labirint[point[0]][point[1] - 1] = labirint[point[0]][point[1]] + 1; int[] tmp = new int[2]; tmp[0] = point[0]; tmp[1] = point[1] - 1; queue.addLast(tmp); } } System.out.println(-1); } } ================================================ FILE: _other_tasks_/exit_from_maze/README.md ================================================

A4. Выход из лабиринта

Время: 2 сек.
Память: 64Mb

Во время торнадо в Костромской области было повалено большое количество деревьев. Однажды утром, спустя пару дней после торнадо, мальчик Илья вышел прогуляться и увидел, что поваленные деревья образовали настоящий лабиринт. Вася очень обрадовался, стал гулять и играть в лабиринте. Внезапно ему позвонил преподаватель и поинтересовался, почему он давно не видел Илью. Чтобы не получить дырку в бэйджик за самовольный выход за территорию лагеря, Илья, конечно же, хотел попасть в домик как можно скорее, но и побродить по лабиринту ему тоже очень хотелось. Помогите ему узнать, как быстро он сможет добраться до домика.

Формат ввода

В первой строке входного файла заданы целые положительные числа N и M (1 ≤ N, M ≤ 1000). В следующих N строках заданы по M символов, описывающих лабиринт. На позициях, по которым Илья может перемещаться, записан символ «0», а на позициях, которые перегорожены деревьями, записан символ «1». После описания лабиринта следуют целые числа x1, y1, x2, y2 — координаты (то есть соответствующие номера столбцов и строк) Ильи и его домика соответственно (1 ≤ x1, x2 ≤ M, 1 ≤ y1, y2 ≤ N).

Формат вывода

В выходной файл выведите единственное число — длину кратчайшего пути от точки (x1, y1) до точки (x2, y2), если Илья может добраться до дому по лабиринту, и «-1» в противном случае.

Примеры

Ввод Вывод
4 6
1 0 1 1 1 0
0 0 1 0 0 0
1 0 1 1 0 0
0 0 0 0 0 0
2 1 5 3		 7
4 6
1 0 1 1 1 0
0 0 1 0 0 0
1 0 1 1 0 0
0 0 0 1 0 0
2 1
5 3		 -1
================================================ FILE: _other_tasks_/f_positive_divisors/PositiveDivisors.java ================================================ package _other_tasks_.f_positive_divisors; import java.io.FileReader; import java.io.IOException; import java.util.HashMap; import java.util.Map; import java.util.Scanner; public class PositiveDivisors { private static int dev(int num) { int count = 0; for (int i = 2; i < Math.sqrt(num); i += 1) { if (num%i == 0){ count++; } } return count; } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] line = sc.nextLine().split(" "); int l = Integer.parseInt(line[0]); int r = Integer.parseInt(line[1]); Map map = new HashMap<>(); for (int i = l; i <= r; i++) { map.put(i, dev(i)); } map.entrySet() .stream() .sorted(Map.Entry.comparingByKey()) .sorted(Map.Entry.comparingByValue()).forEach(i -> System.out.print (i.getKey() + " ")); } } ================================================ FILE: _other_tasks_/f_positive_divisors/README.md ================================================

F. Положительные делители

Время: 1 сек.
Память: 256 Мб

Рассмотрим числа от L до R. Требуется отсортировать их по возрастанию количества целых положительных делителей. При равном количестве делителей числа должны быть отсортированы по возрастанию.

Формат ввода

На ввод подаётся два числа L и R (1 ≤ L ≤ R ≤ 300 000).

Формат вывода

Выведите числа от L до R в описанном в условии порядке.

Примеры

Ввод Вывод
10 20 11 13 17 19 10 14 15 16 12 18 20
================================================ FILE: _other_tasks_/g_couriers_implementation/CouriersImplementation.java ================================================ package _other_tasks_.g_couriers_implementation; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class CouriersImplementation { public static void main(String[] args) throws IOException { ArrayList> orders = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()) { String[] data = sc.nextLine().split(" "); if (data.length == 1) { continue; } String[] firstTime = data[0].split(":"); String[] secondTime = data[1].split(":"); ArrayList time = new ArrayList<>(); time.add(Integer.parseInt(firstTime[0]) * 60 * 60 + Integer.parseInt(firstTime[1]) * 60 + Integer.parseInt(firstTime[2])); time.add(Integer.parseInt(secondTime[0]) * 60 * 60 + Integer.parseInt(secondTime[1]) * 60 + Integer.parseInt(secondTime[2])); orders.add(time); } orders.sort((a, b) -> { if(a.get(0).compareTo(b.get(0)) == 0) { return a.get(1).compareTo(b.get(1)); } else return a.get(0).compareTo(b.get(0)); }); int usedCouriers = 0; int[] availableAt = new int[orders.size()]; for (int orderId = 0; orderId < orders.size(); orderId++) { int availableCourier = -1; for (int courierId = 0; courierId < orders.size(); courierId++) { if (availableAt[courierId] <= orders.get(orderId).get(0)) { availableCourier = courierId; break; } } if (availableAt[availableCourier] == 0) { usedCouriers += 1; } availableAt[availableCourier] = orders.get(orderId).get(1); } PrintWriter out = new PrintWriter(System.out); out.println(usedCouriers); out.flush(); } } ================================================ FILE: _other_tasks_/g_couriers_implementation/README.md ================================================

G. Курьеры

Время: 1 сек.
Память: 64 Мб

Даны m заказов на доставку. Каждый заказа описывается двумя моментами времени: start и finish (в формате HH:MM:SS). Как только курьер начинает выполнение заказа, курьер не может выполнять никакой другой заказ в интервале между start и finish. Определите минимальное количество курьеров, которые потребуются для выполнения всех m заказов.

Формат ввода

Первая строка содержит целое число m (1 <= m <= 1000). В каждой из следующих m строк содержится по два момента времени starti и finishi в формате HH:MM:SS (00 <= HH < 24, 00 <= MM < 60, 00 <= SS < 60).

Формат вывода

Выведите одно целое число, минимальное количество курьеров.

Примеры

Ввод Вывод
4
08:00:00 11:00:00
09:00:00 10:00:00
10:00:00 11:10:00
10:59:59 13:00:00		 3
1
08:00:00 09:00:00		 1
4
08:00:00 13:00:00
09:00:00 13:00:00
10:00:00 13:00:00
10:59:59 13:00:00		 4
10
08:00:00 11:00:00
08:00:00 11:00:00
08:00:00 11:00:00
08:00:00 11:00:00
08:00:00 11:00:00
12:00:00 12:00:01
12:00:00 23:59:59
12:00:00 13:00:01
13:00:00 13:00:01
13:00:00 13:00:01		 5
================================================ FILE: _other_tasks_/g_couriers_implementation/variant_two.py ================================================ # Оптимизируйте (если потребуется) ваше решение предыдущей задачи. Решение будет запущено на тестах с большими ограничениями: 1 <= m <= 250 000. fin = open("input.txt", 'r') n = int(fin.readline()) orders = [] for index in range(n): (a, b) = fin.readline().split() firstTime = a.split(":") secondTime = b.split(":") orders.append([int(firstTime[0])*3600+ int(firstTime[1])*60 + int(firstTime[2]), 's']) orders.append([int(secondTime[0])*3600+ int(secondTime[1])*60 + int(secondTime[2]), 'f']) fin.close() orders.sort(key=lambda x: (x[0], x[1])) usedCouriersMax = 0 usedCouriers = 0 for orderId in range(0, len(orders)): if usedCouriers > usedCouriersMax: usedCouriersMax = usedCouriers if orders[orderId][1] == 's': usedCouriers += 1 if usedCouriers > usedCouriersMax: usedCouriersMax = usedCouriers if orders[orderId][1] == 'f': usedCouriers -= 1 print(usedCouriersMax) ================================================ FILE: _other_tasks_/gcd/Gcd.java ================================================ package _other_tasks_.gcd; // https://official.contest.yandex.ru/rucode5.0/contest/35546/problems/?success=67521304#7/2016_07_22/HvuFCYTXtU import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class Gcd { static int gcd(int a, int b) { if (a == 0 || b == 0) { return a + b; } if (a > b) { return gcd(a % b, b); } else { return gcd(a, b % a); } } public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); int a = Integer.parseInt(sc.nextLine()); int b = Integer.parseInt(sc.nextLine()); int result = gcd(a, b); PrintWriter out = new PrintWriter(System.out); out.println(result); out.flush(); } } ================================================ FILE: _other_tasks_/gcd/README.md ================================================

A1. GCD

Время: 1 сек.
Память: 256Mb

Заданы два целых положительных числа a и b. Найти их наибольший общий делитель.

Формат ввода

В первой строке входа задано число a, во второй - число b (1 ≤ a,b ≤ 109).

Формат вывода

Одно число — наибольший общий делитель введённых чисел.

Примеры

Ввод Вывод
26
44		 2
================================================ FILE: _other_tasks_/i_basketball_game/BasketballGame.java ================================================ package _other_tasks_.i_basketball_game; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class BasketballGame { public static void main(String[] args) throws IOException { long firstTeam = 0; long secondTeam = 0; Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()) { String[] goal = sc.nextLine().split(" "); if (goal.length == 2) { int team = Integer.parseInt(goal[0]); int distance = Integer.parseInt(goal[1]); int points = distance == -1 ? 1 : distance <= 6 ? 2 : 3; if (team == 1) { firstTeam += points; } else secondTeam += points; } } PrintWriter out = new PrintWriter(System.out); out.println(firstTeam + ":" + secondTeam); out.flush(); } } ================================================ FILE: _other_tasks_/i_basketball_game/README.md ================================================

I. Баскетбольный матч

Время: 1 сек.
Память: 512 Мб

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

Правила начисления очков в баскетболе таковы:

  • за заброшенный со штрафного броска мяч команда получает 1 очко;
  • за заброшенный с близкой дистанции мяч команда получает 2 очка;
  • за заброшенный с дальней дистанции мяч команда получает 3 очка.

Если расстояние до корзины во время броска было не более 6 метров, то дистанция считается близкой, в противном случае — дальней. Конечно, это несколько упрощённые правила игры в баскетбол.

Формат ввода

В первой строке записано целое число n — количество заброшенных мячей (1 <= n <= 1000). В следующих n строках содержатся сведения о заброшенных мячах. Каждая строка содержит два целых числа ti и di (1 <= ti <= 2, -1 <= di <= 20). Если di >= 0, то это означает, что игрок из команды ti забросил мяч с расстояния di метров до корзины. Если di = -1, то это означает, что игрок из команды ti забросил мяч со штрафного броска.

Формат вывода

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

Примеры

Ввод Вывод
3
1 2
2 5
1 10		 5:2
4
1 2
1 -1
1 20
1 20		 9:0
10
1 -1
1 -1
2 -1
2 -1
1 1
1 5
2 6
2 7
1 11
1 12		 12:7
================================================ FILE: _other_tasks_/intern_day/InternDay.java ================================================ package _other_tasks_.intern_day; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.*; public class InternDay { public static void main(String[] args) throws IOException { Map edges = new HashMap<>(); Set vertexes = new HashSet<>(); Scanner sc = new Scanner(new FileReader("input.txt")); sc.nextLine(); while (sc.hasNextLine()) { String line = sc.nextLine(); int lenLine = 3; int lenLineNext = lenLine + 1; for (int i = 0; i < line.length(); i++) { if (i + lenLineNext > line.length()) { break; } String oneVertex = line.substring(i, i + lenLine); String twoVertex = line.substring(i + 1, i + lenLineNext); vertexes.add(oneVertex); vertexes.add(twoVertex); String edge = oneVertex + " " + twoVertex; if (!edges.containsKey(edge)) { edges.put(edge, 1); } else { int lineCount = edges.get(edge); edges.put(edge, lineCount + 1); } } } PrintWriter out = new PrintWriter(System.out); out.println(vertexes.size()); out.println(edges.size()); for (Map.Entry entry : edges.entrySet()) { out.println(entry.getKey() + " " + entry.getValue()); } out.flush(); } } ================================================ FILE: _other_tasks_/intern_day/README.md ================================================

A. Граф подстрок

Время: 6 сек.
Память: 512 Мб

В свой первый рабочий день стажер Слава решил как следует изучить офис. Бродя по коридорам, Слава начал смотреть на английские названия переговорок. Вскоре он заметил, что названия переговорок имеют некий дисбаланс в буквосочетаниях - неужели в Яндексе изобрели какой-то свой диалект английского языка? Славу очень заинтересовала эта тема, поэтому он решил построить модель буквосочетаний и изучить его.

Первым делом данную модель необходимо построить. Слава выбрал формат графа:

  • название переговорки S = s1s2…sn−1sn образует n−2 буквосочетания длины 3: w1=s1s2s3, w2=s2s3s4, w3=s3s4s5 …wn−2=sn−2sn−1sn;
  • если для какого-то из буквосочетаний wi еще нет вершины в графе, то она создается;
  • для каждой пары буквосочетаний (wi,wi+1) добавляется ориентированное ребро веса 1, или увеличивается вес существующего ребра на 1.

Таким образом получается граф G с v вершинами и e ориентированными ребрами. Между некоторыми вершинами может быть несколько дуг (от a к b и от b к a).

Помогите Славе по заданному набору названий переговорок найти количество вершин в получившемся графе и вывести ориентированные ребра между вершинами.

Формат ввода

В первой строке записано одно целое число T (1 ≤ T ≤ 40000) — количество переговорок, которые встретил Слава по пути к рабочему месту.

В каждой из T следующих строк записано одно название переговорки Si (4 ≤ |Si| ≤ 30). Все названия состоят из строчных букв английского алфавита.

Формат вывода

В первой строке выведите количество вершин v в графе G.

Во второй строке выведите количество пар вершин e, между которыми есть ориентированные ребра.

В каждой из следующих e строк выведите слово ws, соответствующее началу ребра, затем слово wf, соответствующее концу ребра, и вес ориентированного ребра из вершины ws в wf.

Ребра вы можете перечислить в произвольном порядке.

Примеры

Ввод Вывод
2
aaaaaaaaaaaaa
aaabbbaaabbba		 6
7
aaa aaa 10
aaa aab 2
aab abb 2
abb bbb 2
bbb bba 2
bba baa 1
baa aaa 1
2
abab
baba		 2
2
aba bab 1
bab aba 1
1
qwertyqwertyqwertyqwertyqwerty		 6
6
qwe wer 5
wer ert 5
ert rty 5
rty tyq 4
tyq yqw 4
yqw qwe 4
================================================ FILE: _other_tasks_/inverse_simple_module/InverseSimpleModule.java ================================================ package _other_tasks_.inverse_simple_module; import java.io.*; public class InverseSimpleModule { private static long p = (long) (1e9 + 9); private static long func(long x, long n) { if (n == 0) { return 1; } if (n % 2 == 0) { return func(x * x % p, n / 2) % p; } else { return x * func(x, n - 1) % p; } } public static void main(String[] args) throws IOException { BufferedReader sc = new BufferedReader(new FileReader("input.txt")); PrintWriter out = new PrintWriter(System.out); long a; byte index = 0; for (String line; (line = sc.readLine()) != null; ) { if (index == 1) { a = Long.parseLong(line); out.println(func(a, p - 2)); } if (index == 0) { index = 1; } } out.flush(); } } ================================================ FILE: _other_tasks_/inverse_simple_module/README.md ================================================

J1. Обратное по простому модулю

Время: 1 сек.
Память: 256Mb

В данной задаче Вам необходимо найти для натурального числа a такое натуральное число x, не большее 109+9, что a*x - 1 делится на 109 + 9.

Формат ввода

В первой строке записано число T, 1 ≤ T ≤ 105 - количество тестовых примеров. В каждой из следующих T строк записано натуральное число a, 1 ≤ a < 109 + 9.

Формат вывода

Для каждого числа a выведите в отдельной строке одно число - ответ на задачу. Ответ не должен превышать 109+9.

Примеры

Ввод Вывод
4
1
2
1000000007
1000000008		 1
500000005
500000004
1000000008
================================================ FILE: _other_tasks_/j_digital_protocol/DigitalProtocol.java ================================================ package _other_tasks_.j_digital_protocol; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class DigitalProtocol { public static void main(String[] args) throws IOException { String dataStr = new Scanner(new FileReader("input.txt")).nextLine(); BigInteger one = BigInteger.ZERO, two = BigInteger.ZERO, sum = BigInteger.ZERO; boolean exit = false; for (int i = 1; i < dataStr.length(); i++) { for (int j = i+1; j < dataStr.length(); j++) { String oneStr = dataStr.substring(0, i); String twoStr = dataStr.substring(i, j); String sumStr = dataStr.substring(j); if (twoStr.length() > 1 && dataStr.charAt(0) == '0') { continue; } one = new BigInteger(oneStr); two = new BigInteger(twoStr); sum = new BigInteger(sumStr); if (one.add(two).compareTo(sum) == 0) { exit = true; break; } } if (exit) break; } PrintWriter out = new PrintWriter(System.out); out.println(one + "+" + two + "=" + sum); out.flush(); } } ================================================ FILE: _other_tasks_/j_digital_protocol/README.md ================================================

J. Цифровой протокол

Время: 1 сек.
Память: 512 Мб

Петя придумал странный протокол передачи данных. Суть его в том, что, передавая верное сообщение S , в поток данных ещё добавляются миллионы байт лишней информации. Предполагается, что злоумышленник голову сломает, пока найдёт нужную часть сообщения. Инновационно? Конечно!

Для передачи секретного сообщения используется ключ — строка из цифр ABC, где - A, B, C - некоторые целые положительные числа, удовлетворяющие соотношению A + B = C.

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

Более формально, дано сообщение вида ABC, которое может быть представлено в виде математического тождества вида A + B = C, где A, B, C - некоторые целые положительные числа. Найдите это тождество.

Формат ввода

В единственной строке записано сообщение вида ABC, состоящее из цифр от 0 до 9. Длина строки не менее трёх символов и не превосходит ста символов.

Формат вывода

Выведите сообщение вида A + B = C. Таким образом, ответ должен отличаться от входной строки ровно на два вставленных символа — на один символ + и один символ =. Ведущие нули в десятичной записи чисел A, B и C не допускаются. Если существует несколько решений, выведите любое из них. Гарантируется, что по крайней мере одно решение существует.

Примеры

Ввод Вывод
123123246 123+123=246
999108 9+99=108
11111122 11+111=122
================================================ FILE: _other_tasks_/kvn/Kvn.java ================================================ package _other_tasks_.kvn; import java.io.PrintWriter; import java.util.Scanner; public class Kvn { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String[] line1 = sc.nextLine().split(" "); String[] line2 = sc.nextLine().split(" "); int play = 120; int obzor = 20; int obzorObzor = 3; long max = obzorObzor * Integer.parseInt(line1[0]) + obzor * Integer.parseInt(line1[1]) + play * Integer.parseInt(line1[2]); long mel = obzorObzor * Integer.parseInt(line2[0]) + obzor * Integer.parseInt(line2[1]) + play * Integer.parseInt(line2[2]); PrintWriter out = new PrintWriter(System.out); if (mel > max) { out.println("Mel"); } else if (max > mel) { out.println("Max"); } else { out.println("Draw"); } out.flush(); } } ================================================ FILE: _other_tasks_/kvn/README.md ================================================

A. Квнщики

Время: 2 сек.
Память: 256 Мб

Макс и Мел — любители юмористической передачи «КВН». Они оба смотрели все лучшие игры этого тысячелетия и могут перечислить всех членов команд, поэтому редкий их диалог не заканчивается спором, справедливо ли дали чемпионство Раисам.
Одним прекрасным сентябрьским утром Макс и Мел решили выяснить, кто же из них больше времени уделяет своему хобби. Макс подсчитал, что за последний год он посмотрел f1 игр «КВН», e1 обзоров на игры «КВН» и t1 обзоров на обзор игр «КВН» — да, и такие существуют! Мел же посмотрел f2 игр, e2 обзоров на игры и t2 обзоров на обзор игр. Каждая игра идёт два часа, обзор — 20 минут, а обзор на обзор идёт 3 минуты. Помогите им разрешить спор и определить, кто же за последний год посмотрел больше минут видео.

Исходные данные

В первой строке входного файла даны 3 целых числа: t1, e1, f1 — количество обзоров на обзоры, обзоров и игр, которые посмотрел Макс (0 ≤ t1, e1, f1 ≤ 1000).
Во второй строке входного файла даны 3 целых числа: t2, e2, f2 — количество количество обзоров на обзоры, обзоров и игр, которые посмотрел Мел (0 ≤ t2, e2, f2 ≤ 1000).

Результат

Если Макс суммарно провёл больше времени за просмотром «КВН», чем Мел, то выведите Max. В противном случае выведите Мel.
Если же они оба суммарно просмотрели одинаковое количество минут видео, выведите Draw.

Примеры

исходные данные результат 
15 1 3
1 3 3

Max
 
20 3 0
0 0 1

Draw
 
1 2 3
3 2 1
 
Max
================================================ FILE: _other_tasks_/large_prime_numbers/LargePrimeNumbers.java ================================================ package _other_tasks_.large_prime_numbers; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class LargePrimeNumbers { public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); Scanner sc = new Scanner(new FileReader("input.txt")); String[] line = sc.nextLine().split(" "); long m = Long.parseLong(line[0]); long n = Long.parseLong(line[1]); int max = (int) (1e6 + 1); byte[] prime = new byte[max]; byte[] ans = new byte[max]; prime[0] = 1; prime[1] = 1; for (int i = 2; i < max; ++i) { if (prime[i] == 0) { int tmp = (int) ((i - (m % i)) % i); if (m + tmp > i && tmp < max) { ans[tmp] = 1; } if (i + tmp < max && m + tmp + i > i) { ans[i + tmp] = 1; } for (int j = 2 * i; j < max; j += i) { prime[j] = 1; if (m <= j && j - m < max) { int index = (int)(j - m); ans[index] = 1; } if (j + tmp < max) { ans[j + tmp] = 1; } } } } for (int i = 0; i <= n - m; i++) { if (ans[i] == 0 && m + i >= 2) { long num = m + i; out.print(num + " "); } } out.flush(); } } ================================================ FILE: _other_tasks_/large_prime_numbers/README.md ================================================

K1. Большие простые числа

Время: 1 сек.
Память: 64Mb

Найдите все простые в диапазоне [A..B].

Формат ввода

Даны 1 ≤ A ≤ B ≤ 1012. Дополнительно известно ∣B − A∣ ≤ 106.

Формат вывода

В строку все простые числа из диапазона в порядке возрастания.

Примеры

Ввод Вывод
60 80 61 67 71 73 79
================================================ FILE: _other_tasks_/microbiology/Microbiology.java ================================================ package _other_tasks_.microbiology; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class Microbiology { public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String[] data = sc.nextLine().split(" "); long n = Long.parseLong(data[0]); long m = Long.parseLong(data[1]); long div = 1; long e = n; while (e > 0) { if (e % 2 == 1) { div *= n; } n *= n; e >>= 1; long r = div / m; if (r > 0) { div %= m; } n %= m; } PrintWriter out = new PrintWriter(System.out); out.println(div); out.flush(); } } ================================================ FILE: _other_tasks_/microbiology/README.md ================================================

C. Микробиология

Время: 1 сек.
Память: 512 Мб

В начале эксперимента по изучению деления бактерий в чашке Петри была одна бактерия. К концу каждого дня количество бактерий увеличивалось в N раз (то есть к концу первого дня, например, там было N бактерий). В конце N-го дня биологи разделили получившиеся бактерии на колонии по M бактерий и забрали в другие лаборатории. Сколько бактерий осталось после этого в чашке Петри?

Формат ввода

Входной файл содержит через пробел числа N и M (1 ≤ M, N ≤ 109).

Формат вывода

Выведите одно число — ответ к задаче.

Примеры

Ввод Вывод
3 1001 27
10 123456 64000
================================================ FILE: _other_tasks_/multigraph/Multigraph.java ================================================ package _other_tasks_.multigraph; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.HashSet; import java.util.Set; public class Multigraph { public static void main(String[] args) throws IOException { Set set = new HashSet<>(); int nodeCount = 0; BufferedReader br = new BufferedReader(new FileReader("multigraph.in")); short index = 0; for (String line; (line = br.readLine()) != null;) { String[] st = line.split(" "); if (st.length != 2) { continue; } int first = Integer.parseInt(st[0]); int second = Integer.parseInt(st[1]); if (index == 1) { if (first < second) { set.add(first+ " " + second); continue; } if (first > second) { set.add(second+ " " + first); } } if (index == 0) { nodeCount = first; index = 1; } } PrintWriter out = new PrintWriter(System.out); out.println(nodeCount + " " + set.size()); for (String line : set) { out.println(line); } out.flush(); } } ================================================ FILE: _other_tasks_/multigraph/README.md ================================================

B3. Мультиграф

Время: 1 сек.
Память: 64Mb

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

Формат ввода

На первой строке число вершин n и число рёбер m (1 ≤ n, m ≤ 100 000). Следующие m строк содержат пары чисел от 1 до n – рёбра графа.

Формат вывода

Новый граф в таком же формате. Рёбра можно выводить в произвольном формате.

Примеры

Ввод Вывод
3 5
1 1
1 3
2 1
1 2
2 3		 3 3
1 2
1 3
2 3
================================================ FILE: _other_tasks_/numbers/Numbers.java ================================================ package _other_tasks_.numbers; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class Numbers { public static void main(String[] args) { Scanner sc = new Scanner(System.in); PrintWriter out = new PrintWriter(System.out); String first = sc.nextLine().replaceAll("zero", "0").replaceAll("one", "1"); String second = sc.nextLine().replaceAll("zero", "0").replaceAll("one", "1"); BigInteger firstLong = new BigInteger(first); BigInteger secondLong = new BigInteger(second); if (firstLong.compareTo(secondLong) > 0) { out.println(">"); } else if (secondLong.compareTo(firstLong) > 0) { out.println("<"); } else { out.println("="); } out.flush(); } } ================================================ FILE: _other_tasks_/numbers/README.md ================================================

A. НольОдин

Время: 1 сек.
Память: 1Gb

A. НольОдин

Ограничение времени 1 секунда
Ограничение памяти 1Gb
Ввод стандартный ввод или input.txt
Вывод стандартный вывод или output.txt

Полное решение будет оценено в 2 балла.

Сравните два числа в двоичной системе счисления. Числа представлены последовательностью слов без пробелов, обозначающих цифры (0 — zero, 1 — one).

Формат ввода

Первая строка содержит запись первого числаs1 (3≤|s1|≤1000).

Вторая строка содержит запись второго числа s23≤|s2|≤1000).

Числа не содержат лидирующих нулей.

Формат вывода

Выведите символ > (ASCII 62), если первое число больше второго, символ < (ASCII 60), если второе число больше первого, иначе выведите символ = (ASCII 61) .

Пример 1

Ввод Вывод 
oneone
onezerozero

<

Пример 2

Ввод Вывод 
zero
zero

=

Пример 3

Ввод Вывод 
onezero
oneone

<

Пример 4

Ввод Вывод 
oneonezerozero
onezeroonezero

>

Пример 5

Ввод Вывод 
one
zero

>

Пример 6

Ввод Вывод 
one
one

=
================================================ FILE: _other_tasks_/numeric_palindrome/NumericPalindrome.java ================================================ package _other_tasks_.numeric_palindrome; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Comparator; import java.util.Scanner; public class NumericPalindrome { public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); PrintWriter out = new PrintWriter(System.out); Scanner sc = new Scanner(file); sc.nextLine(); String nums = sc.nextLine(); String[] chArr = nums.split(""); ArrayList numArr = new ArrayList<>(); for (String ch: chArr) { numArr.add(Integer.parseInt(ch)); } numArr.sort(Comparator.reverseOrder()); int maxMidNumber = 0; ArrayList numPrint = new ArrayList<>(); if (numArr.size() == 1) { maxMidNumber = numArr.get(0); } for (int i = 1; i < numArr.size(); i++) { if (numArr.get(i-1) > maxMidNumber && !numArr.get(i).equals(numArr.get(i - 1))) { maxMidNumber = numArr.get(i-1); } if (numArr.get(i).equals(numArr.get(i - 1))) { numPrint.add(numArr.get(i)); if (i+1 < numArr.size()) { i++; } } } if (numArr.size() > 1) { int last = numArr.get(numArr.size() - 1); int prevLast = numArr.get(numArr.size() - 2); if (numArr.size() % 2 == 1 && last == prevLast && maxMidNumber < last || last != prevLast && maxMidNumber < last) { maxMidNumber = last; } } for (Integer integer : numPrint) { out.print(integer); } if (maxMidNumber > 0) { out.print(maxMidNumber); } for (int i = numPrint.size()-1; i >= 0 ; i--) { out.print(numPrint.get(i)); } out.println(); out.flush(); } } ================================================ FILE: _other_tasks_/numeric_palindrome/README.md ================================================

E. Числовой палиндром

Время: 1 сек.
Память: 512 Мб

Числовой палиндром — целое положительное число, десятичная запись которого одинаково читается в обоих направлениях. Например, 9 и 12321 являются числовыми палиндромами, а 3434 и 1211 — нет.

На вход программы поступает набор цифр от 1 до 9. Разрешается переставлять и удалять цифры. Требуется из данных цифр составить числовой палиндром, задающий наибольшее число.

Формат ввода

В первой строке входных данных содержится целое число N (0 < N ≤ 105). Во второй строке задается последовательность из N цифр от 1 до 9.

Формат вывода

Выведите одно целое число — максимальный числовой палиндром, составляемый из данного набора цифр.

Примеры

Ввод Вывод
4
1123		 131
================================================ FILE: _other_tasks_/play/Play.java ================================================ package _other_tasks_.play; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class Play { public static void main(String[] args) { Scanner sc = new Scanner(System.in); PrintWriter out = new PrintWriter(System.out); sc.nextLine(); String[] line = sc.nextLine().split(" "); ArrayList arr = new ArrayList<>(); for (int i = 0; i < line.length; i++) { if (Long.parseLong(line[i]) % 2 != (i+1) % 2) { arr.add(i+1); } } if (arr.size() == 2 && arr.get(0)%2 != arr.get(1)%2) { out.println(arr.get(0) + " " + arr.get(1)); } else if (arr.size() == 0 && line.length > 2) { out.println("1 3"); } else { out.println("-1 -1"); } out.flush(); } } ================================================ FILE: _other_tasks_/play/README.md ================================================

D. Игрушки

Время: 2 сек.
Память: 256 Мб

У Вити есть полка, на которой в ряд выставлены n игрушек. На каждой игрушке написано некоторое число. На позиции номер i стоит игрушка с числом ai. Иначе говоря, игрушки образуют массив a.
В пятницу Витя сделает перестановку: две игрушки, находящиеся на позициях i и j (i ≠j), он поменяет местами. Витя обожает порядок, поэтому он хочет, чтобы после перестановки на чётных позициях стояли чётные числа, а на нечётных — нечётные.
От вас требуется выяснить, можно ли из массива a получить массив, который удовлетворяет заданному условию, сделав ровно один обмен двух элементов, стоящих на различных позициях.
Массив a индексируется с единицы.

Исходные данные

В первой строке находится одно натуральное число n (2 ≤ n ≤ 1000).
В следующей строке находятся n натуральных чисел ai — числа, записанные на игрушках (1 ≤ ai ≤ 109).

Результат

В единственной строке выведите i и j — номера элементов, которые нужно поменять местами, чтобы выполнить условие (1 ≤ i, j ≤ n, i ≠j). Если ответов несколько, выведите любой из них.
Если не существует способа поменять два элемента местами, выведите -1 -1.

Примеры

исходные данные результат 
2
1 2
 
-1 -1
 
3
1 2 3
 
1 3
 
4
2 1 4 6
 
-1 -1
================================================ FILE: _other_tasks_/rapid_exponentiation/README.md ================================================

I1. Быстрое возведение в степень

Время: 1 сек.
Память: 64Mb

Возводить в степень можно гораздо быстрее, чем за n умножений! Для этого нужно воспользоваться следующими рекуррентными соотношениями:

an=(a2)n/2 при четном n,

an=a*an−1 при нечетном n.

Реализуйте алгоритм быстрого возведения в степень. Если вы все сделаете правильно, то сложность вашего алгоритма будет O(logn).

Формат ввода

Вводится действительное число a и целое число n.

Формат вывода

Выведите ответ на задачу.

Примеры

Ввод Вывод
2
1		 2
2
2		 4
2
3		 8

Примечания

(!!!) Нельзя использовать стандартное возведение в степень. (!!!)

================================================ FILE: _other_tasks_/rapid_exponentiation/RapidExponentiation.java ================================================ package _other_tasks_.rapid_exponentiation; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.PrintWriter; import java.util.Scanner; public class RapidExponentiation { public static double multi(double x, long n) { if (n == 0) { return 1; } if (n % 2 == 0) { return multi(x * x, n / 2); } else { return x * multi(x, n - 1); } } public static void main(String[] args) throws FileNotFoundException { Scanner sc = new Scanner(new FileReader("input.txt")); PrintWriter out = new PrintWriter(System.out); double a = Double.parseDouble(sc.nextLine()); long n = Long.parseLong(sc.nextLine()); double res = multi(a, n); out.println(res); out.flush(); } } ================================================ FILE: _other_tasks_/search/README.md ================================================

F. Прогулка по Новоуральску

Время: 2 сек.
Память: 256 Мб

Кирилл и Саша решили прогуляться по Новоуральску. Новоуральск похож на другие города по общему устройству  — он представляет из себя совокупность домов, соединённых улицами. Причём для каждой пары домов есть не более одной улицы, соединяющей их. Петель, соединяющих дом с самим собой, в Новоуральске нет. Также известно, что если по улице можно добраться от дома A до дома B, то и от дома B до дома A можно добраться по этой же улице.
Сейчас Кирилл и Саша решили составить список маршрутов, которые бы посещали каждый дом ровно один раз. То есть, если в городе n домов, то в маршруте будет ровно n различных чисел — номеров домов, в которых между любыми двумя соседними будет существовать улица, по которой можно пройти. Кирилл и Саша считают два маршрута разными, если дома в них идут в разном порядке.
Список оказался довольно большим. К тому же, Кирилл и Саша не уверены, что он правильный. Чтобы провести проверку, ребята хотели бы узнать количество путей, подходящих под описание. Без вас им точно не обойтись!

Исходные данные

В первой строке входного файла дано натуральное число n — количество домов (1 ≤ n ≤ 1000). Далее следуют n строк. Каждая i-я строка задана в следующем формате: первое число в строке k — число соседних (то есть связанных улицей) домов для i-го дома, далее перечислены k различных чисел — номера соседних с i-м домов.

Результат

Выведите одно число — количество вышеописанных маршрутов. Поскольку данное число может быть довольно большим, выведите его по модулю 2.

Пример

исходные данные результат 
5
3 2 3 5
3 1 3 4
4 1 2 4 5
3 2 3 5
3 1 3 4
 
0
================================================ FILE: _other_tasks_/search/Search.java ================================================ package _other_tasks_.search; import java.io.PrintWriter; import java.util.Scanner; public class Search { public static void main(String[] args) { Scanner sc = new Scanner(System.in); PrintWriter out = new PrintWriter(System.out); int n = sc.nextInt(); if (n == 1) { out.println(1); } else { out.println(0); } out.flush(); } } ================================================ FILE: _other_tasks_/second_above/README.md ================================================

B. Второй сверху

Время: 1 сек.
Память: 512 Мб

Аналого-цифровой преобразователь получает сигналы и кодирует их в виде целых положительных чисел, после чего последовательно передаёт в систему для обработки. Конец блока сигналов кодируется числом 0. Ваша задача — определить значение второго по величине элемента в первом блоке сигналов.

Формат ввода

На вход подаётся последовательность сигналов — целые неотрицательные числа, не превосходящие 109. Гарантируется, что в последовательности есть хотя бы одно число 0, а общее количество сигналов не превосходит 104.

Формат вывода

Выведите ответ на задачу.

Примеры

Ввод Вывод
1
7
9
0		 7
================================================ FILE: _other_tasks_/second_above/SecondAbove.java ================================================ package _other_tasks_.second_above; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Comparator; import java.util.Scanner; public class SecondAbove { public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); ArrayList data = new ArrayList<>(); while (sc.hasNextLine()) { int num = Integer.parseInt(sc.nextLine()); if (num != 0) { data.add(num); } else { data.sort(Comparator.reverseOrder()); PrintWriter out = new PrintWriter(System.out); out.println(data.get(1)); out.flush(); } } } } ================================================ FILE: _other_tasks_/tower/README.md ================================================

B. Га-га 3

Время: 2 сек.
Память: 256 Мб

Саша  — очень избалованный гусь.
Недавно он нашёл кубики, на которых написаны числа. Саша пытался с ними поиграть, но вскоре ему стало скучно, поэтому он стал строить из них высокую башню. Сейчас в его башне n кубиков, на каждом из которых написано некоторое натуральное число ai.
Саше, как и всем остальным гусям, стало интересно, чему равно значение степенной башни a1a2a3 …an. Так как Саша — гусь, больших чисел он в голове удержать не может, поэтому хочет узнать результат по модулю 3. Помогите Саше.
Напомним, что операция возведения в степень правоассоциативна.

Исходные данные

В первой строке находится натуральное число n (1 ≤ n ≤ 105). В следующей строке находятся n натуральных чисел ai (1 ≤ ai ≤ 109).

Результат

Выведите результат выражения a1a2a3 …an mod 3.

Примеры

исходные данные результат 
3
1 2 3
 
1
 
3
2 3 2

2

Замечания

Во втором примере 232 = 512 mod 3 = 2.
================================================ FILE: _other_tasks_/tower/Tower.java ================================================ package _other_tasks_.tower; import java.io.PrintWriter; import java.util.Scanner; public class Tower { public static void main(String[] args) { Scanner sc = new Scanner(System.in); PrintWriter out = new PrintWriter(System.out); sc.nextLine(); String[] line = sc.nextLine().split(" "); long a1 = Long.parseLong(line[0]); if (a1 % 3 == 0) { out.println(0); } else if (a1 % 3 == 1) { out.println(1); } else if (line.length == 1) { out.println(2); } else { long a2 = Long.parseLong(line[1]); if (a2 % 2 == 0) { out.println(1); } else { out.println(2); } } out.flush(); } } ================================================ FILE: a_plus_b/README.md ================================================

A+B (2%)

Время: 1 сек.
Память: 16 Мб
Сложность: 2%

Требуется сложить два целых числа А и В.

Формат ввода

В единственной строке входного файла input.txt записаны два натуральных числа через пробел. Значения чисел не превышают 109.

Формат вывода

В единственную строку выходного файла output.txt нужно вывести одно целое число — сумму чисел А и В.

Пример 1

Ввод Вывод
2 3 5
================================================ FILE: a_plus_b/Summ.java ================================================ package a_plus_b; import java.io.*; import java.util.*; public class Summ { public static void main(String[] args) throws IOException { ArrayList numeric = new ArrayList<>(); int s = 0; String str; FileReader fin = new FileReader("input.txt"); // Получение чисел из файла Scanner sc = new Scanner(fin); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while(st.hasMoreTokens()){ int a = Integer.valueOf(st.nextToken()); numeric.add(a); } for (Integer aNumeric : numeric) { s += aNumeric; } FileWriter countStepFinish = new FileWriter("output.txt");// Запись числа в файл countStepFinish.write(String.valueOf(s)); countStepFinish.close(); } } ================================================ FILE: a_yandex/Main.java ================================================ package a_yandex; import java.util.*; import java.io.*; public class Main { private static ArrayList dataLine = new ArrayList<>(); private static ArrayList dataOne = new ArrayList<>(); private static ArrayList dataTwo = new ArrayList<>(); private static ArrayList summData = new ArrayList<>(); private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ dataLine.add(sc.nextLine()); } for(int i = 0; i < dataLine.size(); i++){ if(i == 1){ StringTokenizer st = new StringTokenizer(dataLine.get(i), " "); while (st.hasMoreTokens()){ dataOne.add(Integer.valueOf(st.nextToken())); } } if(i == 3){ StringTokenizer st = new StringTokenizer(dataLine.get(i), " "); while (st.hasMoreTokens()){ dataTwo.add(Integer.valueOf(st.nextToken())); } } } } public static void main(String[] argv) throws IOException{ getData(); if(dataOne.size() != dataTwo.size()){ if(dataOne.size() > dataTwo.size()){ for(int i = dataTwo.size(); i < dataOne.size(); i++){ dataTwo.add(0, 0); } }else{ for(int i = dataOne.size(); i < dataTwo.size(); i++){ dataOne.add(0, 0); } } } for(int i = 0; i < dataOne.size(); i++){ summData.add(dataOne.get(i) + dataTwo.get(i)); } StringBuilder summResult = new StringBuilder(); for(Integer line : summData){ summResult.append(line).append(" "); } int pow; if(summData.size() - 1 >= 0){ pow = summData.size() - 1; }else{ pow = 0; } String result = pow + "\n" + summResult; System.out.println(result); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: abba_gold/AbbaGold.java ================================================ package abba_gold; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class AbbaGold { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] numbers = sc.nextLine().split(" "); BigInteger a = new BigInteger(numbers[0]); BigInteger b = new BigInteger(numbers[1]); BigInteger c = new BigInteger(numbers[2]); BigInteger result = a.max(b).max(c); PrintWriter out = new PrintWriter(System.out); out.println(result); out.flush(); } } ================================================ FILE: abba_gold/README.md ================================================

Золото племени АББА (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Главный вождь племени Абба не умеет считать. В обмен на одну из его земель вождь другого племени предложил ему выбрать одну из трех куч с золотыми монетами. Но вождю племени Абба хочется получить наибольшее количество золотых монет. Помогите вождю сделать правильный выбор!

Формат ввода

В первой строке входного файла input.txt записаны три натуральных числа через пробел. Каждое из чисел не превышает 10100. Числа записаны без ведущих нулей.

Формат вывода

В выходной файл output.txt нужно вывести одно целое число — максимальное количество монет, которые может взять вождь.

Примеры

Ввод Вывод
5 7 3 7
987531 234 86364 987531
189285 283 4958439238923098349024 4958439238923098349024
================================================ FILE: acm_world_finals/AcmWorldFnals.java ================================================ package acm_world_finals; import java.util.*; import java.io.*; public class AcmWorldFnals { public static void main(String[] argv) throws IOException{ ArrayList data = new ArrayList<>(); // Все данные ArrayList names = new ArrayList<>(); // Имена участников FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ data.add(sc.nextLine()); } for(int i = 0; i < data.size(); i++){ if(i != 0){ names.add(data.get(i)); } } Collections.sort(names); System.out.println(data); String result = data.get(0) + ": " + String.join(", ", names); // Имена перечислить через запятую PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: acm_world_finals/README.md ================================================

ACM World Finals (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

Некоторые из вас, наверно, знают, что ежегодно проводится чемпионат мира по программированию среди студентов (http://acm.baylor.edu). В финал этого соревнования проходят около 80 команд со всего мира.

Каждая команда состоит из трех человек и имеет название. Напишите программу, которая по краткому названию команды и фамилиям ее участников, строит полное название команды.

Полное название команды состоит из краткого названия команды и списка фамилий ее участников. Фамилии участников в списке должны быть упорядочены по алфавиту и отделены друг от друга запятыми. Название команды от фамилий участников должно быть отделено двоеточием. После каждого знака препинания должен стоять ровно один пробел.

Формат ввода

Входной файл input.txt содержит ровно 4 строки. Первая из строк содержит название команды. Каждая из следующих трех строк содержит фамилию одного из членов команды. Длины строк от 1 до 50 символов.

Формат вывода

Выходной файл output.txt должен содержать ровно одну строку, содержащую полное название команды.

Примеры

Ввод Вывод
Dream Team
Knuth
Dijkstra
Cormen		 Dream Team: Cormen, Dijkstra, Knuth
Ivanovs Team
Ivanov
Ivanov
Ivanov		 Ivanovs Team: Ivanov, Ivanov, Ivanov
Team
a
aa
aaa		 Team: a, aa, aaa
Team
a
A
B		 Team: A, B, a
================================================ FILE: adjacent_cells/AdjacentCells.java ================================================ package adjacent_cells; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class AdjacentCells { private static ArrayList out = new ArrayList<>(); private static int fieldSize = 8; private static int[][] chessboard = new int[fieldSize][fieldSize]; private static void findNeighbors(int cellNumber){ boolean stop = false; for(int i = 0; i < fieldSize; i++){ for(int j = 0; j < fieldSize; j++){ if(chessboard[i][j] == cellNumber){ if(i-1 >= 0){ out.add(chessboard[i-1][j]); } if(i+1 < fieldSize){ out.add(chessboard[i+1][j]); } if(j-1 >= 0){ out.add(chessboard[i][j-1]); } if(j+1 < fieldSize){ out.add(chessboard[i][j+1]); } stop = true; break; } } if(stop) break; } } public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); int cellNumber = sc.nextInt(); int count = 1; for(int i = 0; i < fieldSize; i++){ for(int j = 0; j < fieldSize; j++){ chessboard[i][j] = count; count++; } } findNeighbors(cellNumber); Collections.sort(out); StringBuilder result = new StringBuilder(); for(int number : out){ result.append(number).append(" "); } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result).trim()); fileOut.close(); } } ================================================ FILE: adjacent_cells/README.md ================================================

Соседние клетки (22%)

Время: 1 сек.
Память: 16 Мб
Сложность: 22%

Клетки шахматной доски пронумерованы числами от 1 до 64 по строкам слева направо и снизу вверх. Напишите программу, которая по заданному номеру клетки определяет номера всех клеток, имеющих с ней общую сторону.

Формат ввода

Входной файл input.txt содержит одно целое число от 1 до 64.

Формат вывода

В выходной файл output.txt выведите через пробел в порядке возрастания номера всех клеток, имеющих с заданной общую сторону.

Примеры

Ввод Вывод
2 1 3 10
64 56 63
================================================ FILE: adjustment/Adjustment.java ================================================ package adjustment; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class Adjustment { public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String data = sc.nextLine(); char[] ch = data.toCharArray(); int xPosition = 0; int a = 0, b = 0, c = 0; boolean plus = true; for(int i = 0; i < ch.length; i++){ switch (i){ case (0): if(String.valueOf(ch[i]).equals("x")){ xPosition = 1; }else { a = ch[i] - '0'; } break; case (1): if(String.valueOf(ch[i]).equals("-")){ plus = false; } break; case(2): if(String.valueOf(ch[i]).equals("x")){ xPosition = 2; }else { b = ch[i] - '0'; } break; case (4): if(String.valueOf(ch[i]).equals("x")){ xPosition = 3; }else { c = ch[i] - '0'; } } } int result = (xPosition == 3 && plus) ? a + b : (xPosition == 3) ? a - b : (xPosition == 2 && plus) ? c - a : (xPosition == 2) ? a - c : (xPosition == 1 && plus) ? c - b : b - c; FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: adjustment/README.md ================================================

Уравнение для 5 класса! (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Уравнение для пятиклассников представляет собой строку длиной 5 символов. Второй символ строки является либо знаком '+' (плюс) либо '-' (минус), четвёртый символ — знак '=' (равно). Из первого, третьего и пятого символов ровно два являются цифрами из диапазона от 0 до 9, и один — буквой x, обозначающей неизвестное.

Требуется написать программу, которая позволит решить данное уравнение относительно x.

Формат ввода

Входной файл input.txt состоит из одной строки, в которой записано уравнение.

Формат вывода

В выходной файл output.txt выведите целое число — значение x.

Примеры

Ввод Вывод
x+5=7 2
3-x=9 -6
================================================ FILE: alarm/Alarm.java ================================================ package alarm; import java.io.*; import java.util.*; public class Alarm { public static void main(String[] args) throws IOException { ArrayList time = new ArrayList<>(); int result; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ time.add(Integer.valueOf(st.nextToken())); // Записать все элементы в коллекцию } result = (time.get(1) > time.get(0)) ? time.get(1) - time.get(0) : 12 + time.get(1) - time.get(0); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: alarm/README.md ================================================

Будильник (12%)

Время: 1 сек.
Память: 16 Мб
Сложность: 12%

Известный исследователь Чарльз Ф. Мантц, устав от долгого путешествия через джунгли, лег спать в 10 часов вечера, но предварительно он завел будильник на 12 часов следующего дня. Но проспать 14 часов ему не удалось – будильник зазвонил через 2 часа. Исследователь забыл, что на будильнике, имеющем 12-тичасовой циферблат, можно задать время до звонка только менее 12 часов.

Напишите программу, которая определяет, сколько часов успеет проспать исследователь, прежде чем будильник его разбудит.

Формат ввода

В единственной строке входного файла input.txt записаны два целых числа S и T (1 ≤ S, T ≤ 12; S ≠ T), разделенные одним пробелом - час, когда исследователь лег спать, и час, на который он установил будильник.

Формат вывода

В единственную строку выходного файла output.txt нужно вывести одно целое число – через сколько часов зазвонит будильник.

Примеры

Ввод Вывод
10 12 2
================================================ FILE: alcohol/Alcohol.java ================================================ package alcohol; import java.io.*; import java.util.*; public class Alcohol { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); long count = 0; long c, h, o; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while(st.hasMoreTokens()){ data.add (Long.valueOf(st.nextToken())); } c = data.get(0) / 2; h = data.get(1) / 6; o = data.get(2); if(c > 0 && h > 0 && o > 0){ count = (c < h && c < o) ? c : (h < c && h < o) ? h : o; } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(count)); fileOut.close(); } } ================================================ FILE: alcohol/README.md ================================================

Спирт (10%)

Время: 1 сек.
Память: 16 Мб
Сложность: 10%

Каждому школьнику из курса органической химии известна формула молекулы этилового спирта – C2H5(OH). Откуда видно, что молекула спирта состоит из двух атомов углерода (C), шести атомов водорода (H) и одного атома кислорода (O).

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

Формат ввода

Первая строка входного файла input.txt содержит 3 натуральных числа: C, Н и O – количество атомов углерода, водорода и кислорода соответственно. Все числа разделены пробелом и не превосходят 1018.

Формат вывода

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

Примеры

Ввод Вывод
2 6 1 1
10 5 12 0
18 35 3 3
================================================ FILE: alibaba/Alibaba.java ================================================ package alibaba; import java.util.*; import java.io.*; public class Alibaba { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } } public static void main(String[] argv) throws IOException{ getData(); ArrayList resultArr = new ArrayList<>(); int result = 0; int max = data.get(1); for(int i = 0; i < data.size(); i++){ if(i != 0 && i != 1 && data.get(i) > 0){ resultArr.add(data.get(i)); } } resultArr.sort(Collections.reverseOrder()); for(int i = 0; i < max; i++){ if(i < resultArr.size()){ result += resultArr.get(i); } } PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(result)); pw.close(); } } ================================================ FILE: alibaba/README.md ================================================

Али-Баба (22%)

Время: 1 сек.
Память: 16 Мб
Сложность: 22%

Али-Баба стоял у входа в пещеру. «Сим-Сим, открой дверь!» – сказал он. И дверь распахнулась. Али-Баба зашел внутрь и обомлел – пещера была усыпана сокровищами. Золото, драгоценности, дорогое оружие и посуда, пещера буквально сверкала!

Но Али-Баба радовался недолго. Поразмыслив, он понял, что может унести с собой не более M предметов, в то время как в пещере находится целых N предметов. Али-Баба внимательно рассмотрел каждый предмет и оценил его стоимость. К своему удивлению Али-Баба обнаружил в пещере также бесполезные, и даже вредные вещи, ценность которых сомнительна. Естественно, что Али-Баба хочет взять с собой такие предметы, чтобы их суммарная ценность была максимальна. Помогите ему найти эту сумму.

Формат ввода

В первой строке входного файла input.txt находятся два числа, разделенные пробелом: N – количество предметов в пещере (1 ≤ N ≤ 1000), M – максимальное количество предметов, которые Али-Баба может унести с собой (0 ≤ M ≤ N). Во второй строке располагаются N целых чисел, разделенных пробелами. Каждое такое число Ci означает стоимость i-го сокровища (1 ≤ i ≤ N, -1000 ≤ Ci ≤ 1000).

Формат вывода

В выходной файл output.txt выведите единственное целое число – максимальную суммарную стоимость сокровищ, которые Али-Баба может унести из пещеры.

Примеры

Ввод Вывод
4 2
2 3 1 4		 7
4 2
0 3 -1 -2		 3
================================================ FILE: alien/Alien.java ================================================ package alien; import java.io.*; import java.util.*; public class Alien { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); String out; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while(st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } out = (data.get(0)*2 >= data.get(1)*2 + data.get(2)*2) ? "YES" : "NO"; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(out); fileOut.close(); } } ================================================ FILE: alien/README.md ================================================

Внеземные гости (10%)

Время: 1 сек.
Память: 16 Мб
Сложность: 10%

Недавно на поле фермера Джона были обнаружены следы приземления летающих тарелок. Об этом даже писала газета Mew Yorc Courier.

Поле фермера Джона имеет форму круга радиусом r1. По сообщениям журналистов были обнаружены два следа от летающих тарелок, имевшие форму кругов. Один из них имел радиус r2, второй - радиус r3. Также сообщается, что они находились внутри поля фермера Джона и не пересекались, ни один из них не лежал внутри другого. При этом, они, возможно, касались друг друга и/или границы поля.

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

Формат ввода

Входной файл input.txt содержит три целых положительных числа - r1, r2, r3 (1 ≤ r1, r2, r3 ≤ 109).

Формат вывода

В выходной файл output.txt выведите слово YES, если информация, опубликованная в газете, может соответствовать правде, и слово NO - иначе.

Примеры

Ввод Вывод
10 10 10 NO
10 3 4 YES
================================================ FILE: alphabet/Alphabet.java ================================================ package alphabet; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; import java.util.stream.Collectors; public class Alphabet { public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String data = sc.nextLine(); char[] words = new char[26]; int index = 0; for(char i = 'A';i<='Z';i++){ words[index] = i; index++; } Map children = new HashMap<>(); char[] ch = data.toCharArray(); for(int i = 0; i < ch.length; i++){ children.put(i+1, ch[i]); } List> listChildrenSort = children.entrySet().stream() .sorted((v1, v2) -> v1.getValue().compareTo(v2.getValue())) .collect(Collectors.toList()); StringBuilder numbers = new StringBuilder(); boolean isPossible = true; for(int i = 0; i < words.length; i++){ if(words[i] > listChildrenSort.get(i).getValue()){ isPossible = false; break; }else { numbers.append(String.valueOf(listChildrenSort.get(i).getKey())); numbers.append(" "); } } String result = !isPossible ? "NO" : "YES" + "\n" + String.valueOf(numbers).trim(); FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: alphabet/README.md ================================================

Алфавит (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

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

Первый ребенок в ряду громко называет первую букву алфавита – A. Второй должен назвать B, третий – C и так далее. По счастливому стечению обстоятельств всего в группе 26 детей и столько же сколько и букв в английском алфавите.

Если каждый ребенок без ошибки назовет свою букву, то группа отпразднует знание английского алфавита и ребята по этому случаю съедят большой торт. Однако, пока что группе не удается правильно назвать все 26 букв и каждое утро то один, то другой называет свою букву неправильно и игра на этом заканчивается.

Ребята учат буквы подряд и каждый из них знает первые несколько букв алфавита и не может назвать остальные. Поэтому возможность выиграть напрямую зависит от их расстановки. К примеру, если последним в ряду окажется ребенок, знающий английский алфавит только до буквы D, то букву Z он назвать не сможет и группа не выиграет независимо от того, насколько хорошо выучили алфавит остальные ребята.

Галя считает, что группа в целом уже достаточно хорошо знает алфавит и хочет помочь своим ребятам выиграть. Для этого ей нужно всего лишь расставить их так, чтобы первый ребенок в ряду знал алфавит хотя бы до буквы A, второй хотя бы до буквы B и так далее, последний в ряду должен знать все буквы.

Помогите Гале решить: в каком порядке расставить ребят, чтобы они смогли выиграть или выясните, что это пока невозможно.

Формат ввода

Входной файл input.txt содержит строку, состоящую из 26 букв английского алфавита, записанных слитно; i-я из этих букв говорит о том, до какой буквы знает алфавит i-й ребенок.

Формат вывода

В первой строке выходного файла output.txt выведите YES, если воспитательнице удастся выстроить своих детей в ряд так, чтобы они выиграли и NO, если им для этого еще надо поучиться. Если расстановка возможна, во второй строке выведите перестановку из 26 чисел от 1 до 26 через пробел – порядок детей в ряду. Если решений несколько, можно вывести любое.

Примеры

Ввод Вывод
ABCDEFGHIJKLMNOPQRSTUVWXYZ YES
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
BCARTYXYZZYZZYXYXYZZYZZYXV YES
3 1 2 4 5 26 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 25 24 23
AAZZZZZZZZZZZZZZZZZZZZZZZZ NO
================================================ FILE: amount_two/AmountTwo.java ================================================ package amount_two; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.*; public class AmountTwo { public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); Scanner sc = new Scanner(new FileReader("input.txt")); int number = sc.nextInt(); if (number < 4) { out.println(0); } else { int count = 0; for (int a = 1; a < number/2; a++) { for (int b = a; b < number/2; b++) { if (a + b < number - 1) { for (int c = b; c < number/2; c++) { int d = number - (a + b + c); if (d >= c) { count++; } } } } } out.println(count); } out.flush(); } } ================================================ FILE: amount_two/README.md ================================================

Сумма - 2 (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Задано натуральное число x. Найдите число способов представить его в виде суммы четырех натуральных чисел: x = a + b + c + d, где a ≤ b ≤ c ≤ d.

Формат ввода

Входной файл input.txt содержит целое число x (1 ≤ x ≤ 1500).

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
3 0
5 1
================================================ FILE: anagram_two/AnagramTwo.java ================================================ package anagram_two; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; import java.util.StringTokenizer; public class AnagramTwo { public static void main(String[] args) throws IOException { String result = "YES"; ArrayList one = new ArrayList<>(); ArrayList two = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); String oneWord = st.nextToken(); String twoWord = st.nextToken(); char[] oneSymbols = oneWord.toCharArray(); char[] twoSymbols = twoWord.toCharArray(); for(char i : oneSymbols){ one.add(i); } for(char j : twoSymbols){ two.add(j); } Collections.sort(one); Collections.sort(two); if(!one.equals(two)){ result = "NO"; }else { for(int i = 0; i < oneSymbols.length; i++){ if(oneSymbols[i] == twoSymbols[i]){ result = "NO"; break; } } } FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: anagram_two/README.md ================================================

Анаграмма-2 (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Катя и Таня играли в слова. Одна из девочек называла слово на английском языке, вторая должна найти анаграмму. Анаграмма – это слово, полученное из другого слова путем перестановки всех без исключения букв первого слова.

Написать программу, которая проверит, правильно ли девочки создают анаграммы.

Формат ввода

Входной файл input.txt содержит два слова на английском языке в нижнем регистре, разделенные пробелом. Каждое слово содержит от 1 до 20 символов.

Формат вывода

В выходной файл output.txt выведите «YES», если анаграмма подобрана правильно, иначе выведите «NO».

Примеры

Ввод Вывод
post stop YES
post pots NO
aabb aabb NO
================================================ FILE: anagrams/Anagrams.java ================================================ package anagrams; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class Anagrams { private static boolean isAnagrams(String firstString, String secondString){ ArrayList firstArr = new ArrayList<>(); ArrayList secondArr = new ArrayList<>(); char[] firstCh = firstString.toCharArray(); char[] secondCh = secondString.toCharArray(); for(char ch : firstCh){ firstArr.add(ch); } for(char ch : secondCh){ secondArr.add(ch); } Collections.sort(firstArr); Collections.sort(secondArr); return firstArr.equals(secondArr); } public static void main(String[] args) throws IOException { String firstString = ""; String secondString = ""; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ firstString = sc.nextLine(); secondString = sc.nextLine(); } String result = isAnagrams(firstString, secondString) ? "YES" : "NO"; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: anagrams/README.md ================================================

Анаграммы (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Cтрока S1 называется анаграммой строки S2, если она получается из S2 перестановкой символов. Даны строки S1 и S2. Напишите программу, которая проверяет, является ли S1 анаграммой S2.

Формат ввода

Первая строка входного файла input.txt содержит строку S1, вторая - S2. Обе строки состоят только из прописных букв английского алфавита. Строки не пусты и имеют длину не больше 100000 символов.

Формат вывода

В выходной файл output.txt выведите YES, если S1 является анаграммой S2, и NO - в противном случае.

Примеры

Ввод Вывод
ABAA
ABBA		 NO
ABBA
BABA		 YES
================================================ FILE: anti_palindrome/AntiPalindrome.java ================================================ package anti_palindrome; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.HashSet; import java.util.Scanner; import java.util.Set; public class AntiPalindrome { public static void main(String[] args) throws IOException { Set symbols = new HashSet<>(); Scanner sc = new Scanner(new FileReader("input.txt")); String str = sc.nextLine(); char[] ch = str.toCharArray(); boolean palindrome = true; int j = 0; for (int i = str.length()-1; i >= 0; i--){ if(ch[j] != ch[i]){ palindrome = false; } symbols.add(ch[i]); j++; } String result = (symbols.size() == 1) ? "NO SOLUTION" : (!palindrome) ? str : str.substring(0, str.length()-1); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: anti_palindrome/README.md ================================================

Антипалиндром (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Палиндромом называют строку, читающуюся одинаково с обеих сторон. Задана строка s. Найдите ее наибольшую по длине подстроку, не являющуюся палиндромом.

Формат ввода

Входной файл input.txt содержит строку s. Она состоит только из строчных букв английского алфавита, не пуста, а ее длина не превышает 100 000 символов.

Формат вывода

В выходной файл output.txt выведите ответ на задачу. Если все подстроки s являются палиндромами, выведите в выходной файл NO SOLUTION.

Примеры

Ввод Вывод
abba abb
abc abc
aaaaa NO SOLUTION
================================================ FILE: area_triangle/README.md ================================================

Площадь треугольника (15%)

Время: 1 сек.
Память: 16 Мб
Сложность: 15%

По целочисленным координатам вершин треугольника (x1,y1), (x2,y2) и (x3,y3) требуется вычислить его площадь.

Формат ввода

Входной файл input.txt содержит 6 целых чисел x1,y1,x2,y2,x3,y3 – координаты вершин треугольника. Все числа не превышают 106 по абсолютной величине.

Формат вывода

В выходной файл output.txt выведите точное значение площади заданного треугольника.

Примеры

Ввод Вывод
2 1 2 4 6 1 6
0 0 0 3 3 0 4.5
================================================ FILE: area_triangle/areaTriangle.java ================================================ package area_triangle; import java.io.*; import java.math.BigDecimal; import java.util.*; import static java.math.BigDecimal.ROUND_HALF_UP; public class areaTriangle { public static void main(String[] args) throws IOException { ArrayList point = new ArrayList<>(); double a, b, c, p; String str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ point.add(Double.valueOf(st.nextToken())); } } // Находим длины сторон треугольника a = Math.sqrt(Math.pow(point.get(3) - point.get(1), 2) + Math.pow(point.get(2) - point.get(0), 2)); b = Math.sqrt(Math.pow(point.get(5) - point.get(3), 2) + Math.pow(point.get(4) - point.get(2), 2)); c = Math.sqrt(Math.pow(point.get(5) - point.get(1), 2) + Math.pow(point.get(4) - point.get(0), 2)); // Находим p для формулы Герона p = (a + b + c) /2; // Вычисляем площадь по формуле Герона, округляем до 2(!) знаков после запятой, используем тип BigDecimal для больших чисел BigDecimal result = new BigDecimal(Math.sqrt(p * (p -a) * (p - b) * (p - c))).setScale(2,ROUND_HALF_UP); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: arithmetic/Arithmetic.java ================================================ package arithmetic; import java.util.*; import java.io.*; public class Arithmetic { public static void main(String[] args) throws IOException { ArrayList number = new ArrayList<>(); String summ; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); // 1 цифра StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ number.add(Integer.valueOf(st.nextToken())); } summ = (number.get(0) * number.get(1) == number.get(2)) ? "YES" : "NO"; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(summ); fileOut.close(); } } ================================================ FILE: arithmetic/README.md ================================================

Арифметика (5%)

Время: 1 сек.
Память: 16 Мб
Сложность: 5%

В прошлом году Вася пошел в школу и научился считать. В этом году он изучил таблицу умножения и теперь умеет перемножать любые числа от 1 до 10 без ошибок. Друг Петя рассказал ему про системы счисления, отличные от десятичной. В частности, про двоичную, восьмеричную и даже шестнадцатеричную. Теперь Вася без труда (но уже с помощью листка и ручки) может перемножать числа от 1 до 10 и в этих системах, используя перевод из нестандартной системы в десятичную и обратно из десятичной. Например, если Васе нужно перемножить числа 101 и 1001 в двоичной системе, то он сначала эти числа переводит в десятичное представление следующим образом:

(101)2=1*22+0*21+1*20=4+0+1=5

(1001)2=1*23+0*22+0*21+1*20=8+0+0+1=9

После чего перемножение чисел 5 и 9 Вася с легкостью производит в десятичной системе счисления в уме и получает число 45. Далее производится перевод из десятичной системы счисления в двоичную. Для этого Вася делит число 45 на 2 (порядок системы счисления), запоминая остатки от деления, до тех пор пока в результате не останется число 0.

Ответ составляется из полученных остатков от деления путем их записи в обратном порядке. Таким образом Вася получает результат: (101)2 * (1001)2 = (101101)2. Но теперь Вася изучает таблицу умножения чисел от 1 до 100 в десятичной системе счисления, а поскольку запомнить такую таблицу очень сложно, то Васе придется очень долго ее зубрить. Составьте для Васи программу, которая поможет ему проверять свои знания.

Формат ввода

Во входном файле input.txt записаны три натуральных числа A, B и C через пробел. Числа A и B ≤ 102, а C ≤ 106.

Формат вывода

В выходной файл нужно вывести YES в том случае, если A*B=C и вывести NO в противном случае.

Пример 1

Ввод Вывод
8 54 432 YES
8 54 432 NO
================================================ FILE: arithmetic_progression/ArithmeticProgression.java ================================================ package arithmetic_progression; import java.io.*; import java.util.*; public class ArithmeticProgression { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); // Входные данные int step; // Шаг програессии int result; // Результат вычислений FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } step = data.get(1) - data.get(0); // Вычисление шага result = data.get(0) + (data.get(2) - 1) * step; // Вычисление n-члена прогрессии FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: arithmetic_progression/README.md ================================================

Арифметическая прогрессия (15%)

Время: 1 сек.
Память: 16 Мб
Сложность: 15%

Заданы первый и второй элементы арифметической прогрессии. Требуется написать программу, которая вычислит элемент прогрессии по ее номеру.

Формат ввода

Входной файл input.txt содержит три целых числа, разделенных пробелами – первый элемент прогрессии A1 (1 ≤ A1 ≤ 1000), второй элемент прогрессии A2 (1 ≤ A2 ≤ 1000), и номер требуемого элемента N (1 ≤ N ≤ 1000).

Формат вывода

Выходной файл output.txt должен содержать одно целое число - N-й элемент арифметической прогрессии.

Примеры

Ввод Вывод
1 5 3 9
================================================ FILE: arrange/Arrange.java ================================================ package arrange; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; import java.util.StringTokenizer; public class Arrange { public static void main(String[] args) throws IOException { ArrayList firstName = new ArrayList<>(); ArrayList secondName = new ArrayList<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); int ind = 0; while (st.hasMoreTokens()){ String str = st.nextToken(); char[] ch = str.toCharArray(); for (char symbol : ch) { if (ind == 0) { firstName.add(String.valueOf(symbol).toLowerCase()); } else { secondName.add(String.valueOf(symbol).toLowerCase()); } } ind++; } Collections.sort(firstName); Collections.sort(secondName); String result = firstName.equals(secondName) ? "Yes" : "No"; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: arrange/README.md ================================================

Перестановка (24%)

Время: 1 сек.
Память: 16 Мб
Сложность: 24%

Если Вы читали Гарри Поттера, то знаете, что повелитель зла, Лорд Волдеморт создал свое имя путем перестановки букв в своем настоящем имени. Так из имени «Tom Marvolo Riddle» он получил «I am Lord Voldemort».

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

Формат ввода

В первой строке входного файла input.txt записаны два слова, разделенные единственным в строке пробелом. Слова содержат только символы английского алфавита. Длина слов больше 0 и не превышает 50 символов.

Формат вывода

В выходной файл output.txt выведите «Yes», если возможно получить из одного имени другое, и «No» в противном случае.

Примеры

Ввод Вывод
TomMarvoloRiddle IamLordVoldemort Yes
stop pots Yes
abbc bac No
================================================ FILE: arrival_time/ArrivalTime.java ================================================ package arrival_time; import java.io.*; import java.util.*; public class ArrivalTime { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); // Входные данные построчно ArrayList time = new ArrayList<>(); // Все время int hourLimit = 24; int minuteLimit = 60; int hour = 0, minute; String result; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ data.add(sc.nextLine()); } StringTokenizer stringOne = new StringTokenizer(data.get(0), ":"); // Добавить 1 строку в коллекцию while (stringOne.hasMoreTokens()){ time.add(stringOne.nextToken()); } StringTokenizer stringTwo = new StringTokenizer(data.get(1), " "); // Добаивть вторую строку в коллекцию while (stringTwo.hasMoreTokens()){ time.add(stringTwo.nextToken()); } if(Integer.valueOf(time.get(1)) + Integer.valueOf(time.get(3)) < minuteLimit){ // Расчет минут minute = Integer.valueOf(time.get(1)) + Integer.valueOf(time.get(3)); }else{ minute = (Integer.valueOf(time.get(1)) + Integer.valueOf(time.get(3))) % minuteLimit; // Перевод минут в часы hour = 1; } if(hour + Integer.valueOf(time.get(0)) + Integer.valueOf(time.get(2)) < hourLimit){ // Расчет часов hour = hour + Integer.valueOf(time.get(0)) + Integer.valueOf(time.get(2)); }else{ hour = (hour + Integer.valueOf(time.get(0)) + Integer.valueOf(time.get(2))) % 24; // Перевод часов (если больше суток) } System.out.println(minute); result = hour < 10 && minute < 10 ? "0" + hour + ":0" + minute : hour < 10 ? "0" + hour + ":" + minute : minute < 10 ? hour + ":0" + minute : hour + ":" + minute; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: arrival_time/README.md ================================================

Время прибытия (15%)

Время: 1 сек.
Память: 16 Мб
Сложность: 15%

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

Формат ввода

Входной файл input.txt содержит две строки. В первой строке задано время отправления, а во второй строке – время в пути. Время отправления задается в формате «HH:MM», где HH время в часах, которое принимает значение от 00 до 23, ММ – время в минутах, которое принимает значение от 00 до 59. Время в пути задается двумя неотрицательными целыми числами – количество часов и количество минут. Числа разделяются одним пробелом. Количество часов не превышает 120, минут – 59.

Формат вывода

Выходной файл output.txt должен содержать одну строку – время прибытия поезда на конечную станцию. Формат вывода этого времени совпадает с форматом ввода времени отправления.

Примеры

Ввод Вывод
00:00
10 10		 10:10
01:02
4 6		 05:08
11:00
22 0		 09:00
================================================ FILE: arrows/Arrows.java ================================================ package arrows; import java.util.*; import java.io.*; import java.util.regex.*; public class Arrows { private static int count = 0; private static void arrowCount() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); // Формируем строку из файла Matcher one = Pattern.compile("(?=(>>-->)|(<--<<))").matcher(str); // Проверяем наличие всех стрелок регулярным выражением while (one.find()){ // Считаем количество стрелок count++; } } public static void main(String[] argv) throws IOException{ arrowCount(); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(count)); pw.close(); } } ================================================ FILE: arrows/README.md ================================================

Стрелки (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

Задана последовательность, состоящая только из символов ‘>’, ‘<’ и ‘-‘. Требуется найти количество стрел, которые спрятаны в этой последовательности. Стрелы – это подстроки вида ‘>>-->’ и ‘<--<<’.

Формат ввода

В первой строке входного файла input.txt записана строка, состоящая из символов ‘>’, ‘<’ и ‘-‘ (без пробелов). Строка состоит не более, чем из 250 символов.

Формат вывода

В единственную строку выходного файла output.txt нужно вывести искомое количество стрелок.

Примеры

Ввод Вывод
<<<<>>--><--<<--<<>>>--><<<<< 4
================================================ FILE: artist/Artist.java ================================================ package artist; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; import java.util.StringTokenizer; public class Artist { public static void main(String[] args) throws IOException { int height = 0, width = 0; int[][] canvas = new int[0][]; ArrayList points = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); int index = 0; while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ if(index == 0){ width = Integer.valueOf(st.nextToken()); height = Integer.valueOf(st.nextToken()); canvas = new int[width][height]; }else if(index> 1){ int x1 = Integer.valueOf(st.nextToken()), y1 = Integer.valueOf(st.nextToken()), x2 = Integer.valueOf(st.nextToken()), y2 = Integer.valueOf(st.nextToken()); points.add(new int[]{x1, y1, x2, y2}); }else { st.nextToken(); } } index++; } int painted = 0; for (int[] point : points) { int x1 = point[0]; int y1 = point[1]; int x2 = point[2]; int y2 = point[3]; for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { if ((x >= x1 && x < x2) && (y >= y1 && y < y2)) { if(canvas[x][y] != 1){ painted++; canvas[x][y] = 1; } } else { if (canvas[x][y] != 1) { canvas[x][y] = 0; } } } } } int result = width * height - painted; FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: artist/README.md ================================================

Художник (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Известный художник решил написать новый шедевр. После многих дней усердной работы он захотел исследовать свое творение. Художник вспомнил, что картина писалась следующим образом: сначала был взят белый холст, имеющий форму прямоугольника шириной w и высотой h. Затем художник нарисовал на этом холсте n прямоугольников со сторонами, параллельными сторонам холста и вершинами, расположенными в целочисленных координатах. Помогите художнику определить площадь незакрашенной части холста.

Формат ввода

Первая строка входного файла input.txt содержит два натуральных числа w и h (1 ≤ w, h ≤ 100). Во второй строке записано целое число n (0 ≤ n ≤ 5000) – количество прямоугольников. Следующие n строк содержат информацию о всех прямоугольниках. Каждая строка описывает один прямоугольник в виде четырех чисел x1, y1, x2, y2 , где (x1, y1) и (x2, y2) – координаты левого верхнего и правого нижнего угла прямоугольника соответственно.

Формат вывода

Выведите в выходной файл output.txt одно целое число – площадь незакрашенной части холста.

Примеры

Ввод Вывод
5 5
2
1 1 3 3
2 2 4 4		 18
6 7
3
0 0 5 5
1 1 4 4
2 2 3 3		 17
================================================ FILE: automorphic_numbers/AutomorphicNumbers.java ================================================ package automorphic_numbers; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; import java.util.StringTokenizer; public class AutomorphicNumbers { private static boolean check(long a){ int symbolCount = String.valueOf(a).length(); long square = (long) Math.pow(a, 2); int divider = 1; for(int i = 0; i < symbolCount; i++){ divider *= 10; } return square % divider == a; } public static void main(String[] args) throws IOException { long start = 0, finish = 0; Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ start = Long.valueOf(st.nextToken()); finish = Long.valueOf(st.nextToken()); } StringBuilder result = new StringBuilder(); for(long i = start; i <= finish; i++){ boolean check = check(i); if(check){ result.append(i).append(" "); } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result).trim()); out.close(); } } ================================================ FILE: automorphic_numbers/README.md ================================================

Автоморфные числа (26%)

Время: 2 сек.
Память: 16 Мб
Сложность: 26%

Число называется автоморфным если оно совпадает с последними цифрами своего квадрата. Например, число 25 автоморфно, так как 252=625. Напишите программу определения всех автомофных чисел на заданном промежутке [a, b].

Формат ввода

Входной файл input.txt содержит два натуральных числа a и b (a ≤ b ≤ 106).

Формат вывода

В выходной файл output.txt выведите через пробел в порядке возрастания все автоморфные числа заданного промежутка.

Примеры

Ввод Вывод
1 10 1 5 6
================================================ FILE: ballot/Ballot.java ================================================ package ballot; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; import java.util.StringTokenizer; public class Ballot { public static void main(String[] args) throws IOException { ArrayList groups = new ArrayList<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ groups.add(Integer.valueOf(st.nextToken())); } } int groupCount = groups.get(0); groups.remove(0); Collections.sort(groups); int numberVoicesWin = 0; for(int i = 0; i < groupCount/2+1; i++){ numberVoicesWin += (groups.get(i) / 2 + 1); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(numberVoicesWin)); out.close(); } } ================================================ FILE: ballot/README.md ================================================

Выборы (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

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

Суть реформы состояла в следующем: с момента введения ее в действие все избиратели острова делились на K групп (необязательно равных по численности). Голосование по любому вопросу теперь следовало проводить отдельно в каждой группе, причем считалось, что группа высказывается "за", если "за" голосует более половины людей в этой группе, а в противном случае считалось, что группа высказывается "против". После проведения голосования в группах подсчитывалось количество групп, высказавшихся "за" и "против", и вопрос решался положительно в том и только том случае, когда групп, высказавшихся "за", оказывалось более половины общего количества групп.

Эта система вначале была с радостью принята жителями острова. Когда первые восторги рассеялись, очевидны стали, однако, некоторые недостатки новой системы. Оказалось, что сторонники партии, предложившей систему, смогли оказать некоторое влияние на формирование групп избирателей. Благодаря этому, они получили возможность проводить некоторые решения, не обладая при этом реальным большинством голосов.

Пусть, например, на острове были сформированы три группы избирателей, численностью в 5, 5 и 7 человек соответственно. Тогда партии достаточно иметь по три сторонника в каждой из первых двух групп, и она сможет провести решение всего 6-ю голосами "за", вместо 9-и, необходимых при общем голосовании.

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

Формат ввода

Входной файл input.txt состоит из двух строк. В первой строке записано натуральное число K < 1001 - количество групп избирателей. Во второй строке через пробел записаны K натуральных чисел, которые задают количество избирателей в группах. Население острова не превосходит 30000 человек.

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
3
5 5 7		 6
5
4 2 1 3 7		 5
================================================ FILE: base_of_terrorists/BaseOfTerrorists.java ================================================ package base_of_terrorists; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class BaseOfTerrorists { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] baseInfo = sc.nextLine().split(" "); int n = Integer.parseInt(baseInfo[0]); int m = Integer.parseInt(baseInfo[1]); char[][] base = new char[n][m]; int lineIndex = 0; while (n > 0) { String line = sc.nextLine(); base[lineIndex] = line.toCharArray(); lineIndex++; n--; } String[] mapInfo = sc.nextLine().split(" "); n = Integer.parseInt(mapInfo[0]); m = Integer.parseInt(mapInfo[1]); char[][] map = new char[n][m]; lineIndex = 0; while (sc.hasNextLine()) { map[lineIndex] = sc.nextLine().toCharArray(); lineIndex++; } int result = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (map[i][j] == base[0][0] || map[i][j] == '#') { boolean exit = false; for (int k = 0; k < base.length; k++) { for (int l = 0; l < base[k].length; l++) { if (i+k >= n || j+l >= m) { exit = true; break; } else if (base[k][l] != map[i+k][j+l] && map[i+k][j+l] != '#') { exit = true; break; } } if (exit) break; } if (!exit) result++; } } } PrintWriter out = new PrintWriter(System.out); out.println(result); out.flush(); } } ================================================ FILE: base_of_terrorists/README.md ================================================

База террористов (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

Спецслужбы получили информацию о том, что в труднодоступной части Муравийской пустыни расположена хорошо замаскированная база террористов. В руки спецслужб попал и план этой базы, которая с большой высоты выглядит как группа скальных обломков, весьма часто встречающихся среди Муравийских песков. Президент отдал приказ уничтожить базу крылатыми ракетами. Ваша задача - по карте пустыни, полученной со спутника и плану базы определить количество возможных положений базы террористов. Помните, что террористы могли привезти на территорию базы камни!

Формат ввода

В первой cтроке файла INPUT.TXT записаны числа Nb и Mb (1 ≤ Nb, Mb ≤ 20). В следующих Nb строках записан план базы. Каждая из этих строк содержит по Mb символов "#" (ASCII 35 ) или "." (ASCII 46). Символ "#" обозначает фрагмент базы, а символ "." - песок. В следующей строке записаны числа Nd и Md (1 ≤ Nd, Md ≤ 100). И остаток файла содержит карту участка пустыни на котором, предположительно, находится база террористов - Nd строк по Md символов "#" или "." в каждой.

Формат вывода

Запишите в файл OUTPUT.TXT количество возможных положений базы террористов.

Примеры

Ввод Вывод
2 2
#.
##
3 5
#.#.#
#####
.###.		 4
1 3
#..
3 6
##..##
.#.#.#
#.#...		 6
3 3
#..
#.#
#..
5 36
#......#........................#...
#.#....#.#...#.........#............
#......#.#...##....#...##......###..
.......#.....#...#.#...##........#.#
...................#.....#.......#..		 4
================================================ FILE: basketball/Basketball.java ================================================ package basketball; import java.util.*; import java.io.*; public class Basketball { public static void main(String[] args) throws IOException { ArrayList line = new ArrayList<>(); ArrayList score = new ArrayList<>(); int a = 0, b = 0; String winner; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); while (sc.hasNextLine()){ str = sc.nextLine(); line.add(str); } for(String i : line){ // Записать все очки в одну коллекцию StringTokenizer st = new StringTokenizer(i, " "); while(st.hasMoreTokens()){ score.add(Integer.valueOf(st.nextToken())); } } for(int j = 0; j < score.size(); j++){ // Подсчет количества очков для каждой из команд if((j+1)%2 == 1){ a += score.get(j); }else{ b += score.get(j); } } winner = (a > b) ? "1" : // Какая команда победила (b > a) ? "2" : "DRAW"; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(winner); fileOut.close(); } } ================================================ FILE: basketball/README.md ================================================

Баскетбол (5%)

Время: 1 сек.
Память: 16 Мб
Сложность: 5%

Известны результаты каждой из 4х четвертей баскетбольной встречи. Нужно определить победителя матча. Побеждает команда, набравшая больше очков в течение всего матча.

Формат ввода

Входной файл input.txt содержит 4 строки, в каждой строке находится два целых числа a и b – итоговый счет в соответствующей четверти. а – количество набранных очков за четверть первой командой, b – количество очков, набранных за четверть второй командой. (0 ≤ a,b ≤ 100).

Формат вывода

В выходной файл output.txt выведите номер выигравшей команды, в случае ничьей следует вывести «DRAW».

Пример 1

Ввод Вывод
26 17
13 15
19 11
14 16 		1
14 15
17 18
20 20
15 17 		2
15 16
18 17
10 12
14 12 		DRAW
================================================ FILE: beads/Beads.java ================================================ package beads; import java.io.*; import java.util.Scanner; public class Beads { public static void main(String[] args) throws IOException { int numeric; String str; FileReader fin = new FileReader("input.txt"); // Получение числа из файла Scanner sc = new Scanner(fin); str = sc.nextLine(); numeric = Integer.valueOf(str) + 1; FileWriter countStepFinish = new FileWriter("output.txt");// Запись числа в файл countStepFinish.write(String.valueOf(numeric)); countStepFinish.close(); } } ================================================ FILE: beads/README.md ================================================

Бисер (2%)

Время: 1 сек.
Память: 16 Мб
Сложность: 2%

В шкатулке хранится разноцветный бисер (или бусины). Все бусины имеют одинаковую форму, размер и вес. Бусины могут быть одного из N различных цветов. В шкатулке много бусин каждого цвета.

Требуется определить минимальное число бусин, которые можно не глядя вытащить из шкатулки так, чтобы среди них гарантированно были две бусины одного цвета.

Формат ввода

Входной файл input.txt содержит одно натуральное число N - количество цветов бусин (1 ≤ N ≤ 109).

Формат вывода

В выходной файл output.txt выведите ответ на поставленную задачу.

Пример 1

Ввод Вывод
3 4
================================================ FILE: beautiful_numbers/BeautifulNumbers.java ================================================ package beautiful_numbers; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class BeautifulNumbers { private static boolean check(int number){ String strNumber = String.valueOf(number); int sum = 0; char[] ch = strNumber.toCharArray(); for(char elem : ch){ int chNumber = elem - '0'; sum += chNumber; } return sum % strNumber.length() == 0; } public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); int number = sc.nextInt(); int count = 0; int numberChecked = 0; while (count != number){ numberChecked++; if(check(numberChecked)){ count++; } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(numberChecked)); out.close(); } } ================================================ FILE: beautiful_numbers/README.md ================================================

Красивые числа - 2 (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Будем называть число красивым, если сумма его цифр в десятичной системе счисления делится на количество цифр в нем (в десятичной системе счисления).

Необходимо найти N-ое в порядке возрастания красивое число.

Формат ввода

Входной файл input.txt содержит целое число N. (1 ≤ N ≤ 100 000)

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
1 15
15 20
================================================ FILE: beautiful_wall/BeautifulWall.java ================================================ package beautiful_wall; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class BeautifulWall { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); long tilingCount = sc.nextLong(); long best = tilingCount; StringBuilder bestStr = new StringBuilder(); for(int i = 0; i <= tilingCount/(Math.sqrt(tilingCount)); i++){ for(int j = 0; j <= tilingCount/2+1; j++){ if(i * j <= tilingCount){ long div = tilingCount - (i * j); long square = Math.abs(i - j); long beautifulVal = div + square; if(best > beautifulVal){ best = beautifulVal; bestStr = new StringBuilder(); bestStr.append(i).append(" ").append(j); } }else break; } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(bestStr)); out.close(); } } ================================================ FILE: beautiful_wall/README.md ================================================

Красивая стена (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Однажды великий художник Гигабайт подарил королю Байтландии одно из своих лучших полотен. Король, впечатленный произведением Гигабайта, в знак благодарности подарил ему K плиток из очень ценной разновидности мрамора размером 10×10 сантиметров каждая.

Художник решил украсить этими плитками одну из стен своего дома. Он задумал выложить из них прямоугольник высотой H плиток и шириной W плиток. Художник понимает, что число вариантов для выбора H и W достаточно велико. Из всех возможных вариантов он хочет выбрать самый красивый. Ваша задача – помочь ему с выбором!

Для определения степени красоты художник решил учитывать два параметра:

Насколько выбранный прямоугольник будет близок к квадрату. Значение этого параметра равно модулю разности чисел H и W(т.е. |H-W|).

Сколько плиток останется невостребованными после украшения стены. Значение этого параметра равно разности чисел K и H×W(т.е. K-H×W, где K ≥ H×W ).

Степень красоты вычисляется как сумма значений двух описанных выше параметров. Например, имея 11 плиток, можно выбрать прямоугольник 3×3, степень красоты равна 0+2 = 2. Также можно выбрать прямоугольник 2×5, тогда степень красоты равна 3+1 = 4. Считается, что чем меньше степень красоты, тем красивее прямоугольник.

Ваша задача – написать программу, которая по заданному числу K находит размеры самого красивого прямоугольника.

Формат ввода

Единственная строка входного файла input.txt содержит одно целое число K – количество подаренных королем плиток (1 ≤ K ≤ 106).

Формат вывода

Единственная строка выходного файла output.txt должна содержать натуральные числа H и W соответственно, которые определяют размеры самого красивого прямоугольника. Числа должны быть разделены одиночным пробелом. Если решений несколько, выведите любое из них.

Примеры

Ввод Вывод
11 3 3
2 1 2
20 4 5
================================================ FILE: bell/Bell.java ================================================ package bell; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class Bell { public static void main(String[] args) throws IOException { StringBuilder result = new StringBuilder(); ArrayList data = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()){ String[] symbols = sc.nextLine().split(" "); for(String i : symbols){ data.add(Integer.valueOf(i)); } } data.remove(0); Collections.sort(data); for(int i = 0; i < data.size(); i++){ if(i % 2 == 0){ result.append(data.get(i)).append(" "); } } for(int i = data.size()-1; i > 0; i--){ if(i % 2 == 1){ result.append(data.get(i)).append(" "); } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result).trim()); out.close(); } } ================================================ FILE: bell/README.md ================================================

Колокол (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Требуется написать программу, которая в массиве из n целых чисел наименьший элемент поместит на первое место, наименьший из оставшихся – на последнее, следующий по величине – на второе место, следующий – на предпоследнее и так далее – до середины массива.

Формат ввода

Во входном файле input.txt записано в первой строке число n (1 ≤ n ≤ 30000). Во второй строке записаны через пробел элементы массива, числа по абсолютной величине не большие 32767.

Формат вывода

В единственную строку выходного файла output.txt нужно вывести элементы полученного массива, разделенные одним пробелом.

Примеры

Ввод Вывод
5
1 2 3 4 5		 1 3 5 4 2
================================================ FILE: bertrand_postulate/BertrandPostulate.java ================================================ package bertrand_postulate; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class BertrandPostulate { /** * @param number Число * @return true если число простое, false - иначе * */ private static boolean simple(int number) { double sqrt = Math.sqrt(number); if(number == 1 || number == 2) return true; if(number % 2 == 0) return false; for(int i = 3; i <= sqrt; i += 2){ if(number % i == 0) return false; } return true; } public static void main(String[] args) throws IOException { int countSimpleNumber = 0; int n = new Scanner(new FileReader("input.txt")).nextInt(); for (int i = n+1; i < 2*n; i++) { if (simple(i)) { countSimpleNumber++; } } PrintWriter out = new PrintWriter(System.out); out.println(countSimpleNumber); out.flush(); } } ================================================ FILE: bertrand_postulate/README.md ================================================

Постулат Бертрана (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Постулат Бертрана (теорема Бертрана-Чебышева, теорема Чебышева) гласит, что для любого n > 1 найдется простое число p в интервале n < p < 2n. Такая гипотеза была выдвинута в 1845 году французским математиком Джозефем Бертраном (проверившим ее до n=3000000) и доказана в 1850 году Пафнутием Чебышевым. Раманужан в 1920 году нашел более простое доказательство, а Эрдеш в 1932 – еще более простое.

Ваша задача состоит в том, чтобы решить несколько более общую задачу – а именно по числу n найти количество простых чисел p из интервала n < p < 2n.

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

Формат ввода

Входной файл input.txt содержит целое число n (2 ≤ n ≤ 50000).

Формат вывода

В выходной файл output.txt выведите одно число – ответ на задачу.

Примеры

Ввод Вывод
2 1
239 39
3000 253
================================================ FILE: best_divider/BestDivider.java ================================================ package best_divider; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; import java.util.stream.Collectors; public class BestDivider { private static int sum(int number){ int sum = 0; while (number != 0){ sum += (number % 10); number /= 10; } return sum; } public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner scan = new Scanner(file); int number = scan.nextInt(); Map dividers = new TreeMap<>(Collections.reverseOrder()); for(int i = 1; i <= number; i++){ if(number % i == 0){ dividers.put(i, sum(i)); } } List> dividerSortValue = dividers.entrySet().stream() .sorted((v1, v2) -> v1.getValue().compareTo(v2.getValue())) .collect(Collectors.toList()); String result = String.valueOf(dividerSortValue.get(dividerSortValue.size()-1).getKey()); FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: best_divider/README.md ================================================

Наилучший делитель (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Будем говорить, что число a лучше числа b, если сумма цифр a больше суммы цифр числа b, а в случае равенства сумм их цифр, если число a меньше числа b. Например, число 124 лучше числа 123, так как у первого из них сумма цифр равна семи, а у второго – шести. Также, число 3 лучше числа 111, так как у них равны суммы цифр, но первое из них меньше.

Дано число n. Найдите такой его делитель (само число n и единица считаются делителями числа n), который лучше любого другого делителя числа n.

Формат ввода

Первая строка входного файла содержит целое число n (1 ≤ n ≤ 105).

Формат вывода

В выходной файл выведите ответ на задачу.

Примеры

Ввод Вывод
10 5
239 239
================================================ FILE: binary_numbers/BinaryNumbers.java ================================================ package binary_numbers; import java.io.*; import java.util.*; public class BinaryNumbers { public static void main(String[] args) throws IOException { String out = "YES"; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); int strInt = Integer.valueOf(str); if(strInt <= 0){ out = "NO"; }else{ while(strInt > 1){ if(strInt%2 == 0){ // Проверка четности остатка strInt = strInt / 2; // Следующее число }else{ out = "NO"; break; } } } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(out); fileOut.close(); } } ================================================ FILE: binary_numbers/README.md ================================================

Бинарные числа (8%)

Время: 1 сек.
Память: 16 Мб
Сложность: 8%

Говорят, что плохой программист – это тот, кто считает, что в одном килобайте 1000 байт, а хороший программист – это тот, кто полагает, что в одном километре 1024 метра.

Многим эта шутка понятна, так как все знают, что в процессах, связанных с информатикой и компьютерной техникой, фигурирует множество значений, выражаемых степенью двойки, то есть чисел вида 2K, где K – некоторое неотрицательное целое число. Назовем такие числа бинарными. Это такие числа как 2, 4, 8, 16, 32 и т.д. Действительно, когда речь идет о размере памяти или о разрешении экрана монитора, то мы часто наталкиваемся на бинарные числа. Все это связано с принципом хранения информации в памяти ЭВМ.

Задано целое число N. Требуется определить, является ли оно бинарным.

Формат ввода

Входной файл input.txt содержит единственное целое число N, не превосходящее 10000 по абсолютной величине.

Формат вывода

В выходной файл output.txt выведите YES, если заданное число является бинарным, и NO в противном случае.

Примеры

Ввод Вывод
1024 YES
23 NO
================================================ FILE: birthday/Birthday.java ================================================ package birthday; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.*; public class Birthday { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String petya = null; String vasya = null; while (sc.hasNextLine()){ petya = sc.nextLine(); vasya = sc.nextLine(); } SimpleDateFormat format = new SimpleDateFormat("dd.MM.yy"); format.setTimeZone(TimeZone.getTimeZone("UTC")); Date datePetya = null; Date dateVasya = null; try{ datePetya = format.parse(petya); dateVasya = format.parse(vasya); } catch (ParseException e) { e.printStackTrace(); } assert datePetya != null; assert dateVasya != null; long difference = dateVasya.getTime() - datePetya.getTime(); int days = (int) (difference / (24 * 60 * 60 * 1000)); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(days)); out.close(); } } ================================================ FILE: birthday/README.md ================================================

Дни рождения (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Два одноклассника Петя и Вася родились не ранее 1993 и не позднее 1994 года, причем, Петя старше Васи.

Напишите программу, которая по заданным дням рождения определяет: на сколько дней Петя старше Васи.

Заметим, что 1993 и 1994 года не являются високосными, т.е. в феврале в них ровно 28 дней.

Формат ввода

Входной файл input.txt содержит дату рождения Пети в первой строке и дату рождения Васи во второй. Даты заданы в формате «ДД.ММ.ГГ», например, строка 06.02.93 означает дату рождения 6 февраля 1993 года.

Формат вывода

В выходной файл output.txt выведите единственное число – искомое количество дней.

Примеры

Ввод Вывод
01.01.93
02.01.93		 1
05.02.94
05.03.94		 28
================================================ FILE: birthday_two/BirthdayTwo.java ================================================ package birthday_two; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class BirthdayTwo { private static boolean yearIsLeap(int year) { return year%400 == 0 || year%4 == 0 && year%100 != 0; } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] birth = sc.nextLine().split(" "); String[] today = sc.nextLine().split(" "); int birthDay = Integer.parseInt(birth[0]); int birthMonth = Integer.parseInt(birth[1]); int todayDay = Integer.parseInt(today[0]); int todayMonth = Integer.parseInt(today[1]); int todayYear = Integer.parseInt(today[2]); int result = 0; if (todayMonth != birthMonth || todayDay != birthDay) { ArrayList monthWith31Days = new ArrayList<>(Arrays.asList(1, 3, 5, 7, 8, 10, 12)); ArrayList monthWith30Days = new ArrayList<>(Arrays.asList(4, 6, 9, 11)); while (todayMonth != birthMonth || todayDay != birthDay) { todayDay++; result++; if (monthWith31Days.contains(todayMonth) && todayDay == 32) { todayDay = 1; todayMonth++; } else if (monthWith30Days.contains(todayMonth) && todayDay == 31) { todayDay = 1; todayMonth++; } else if (todayMonth == 2) { if (yearIsLeap(todayYear) && todayDay == 30) { todayDay = 1; todayMonth++; } else if (!yearIsLeap(todayYear) && todayDay == 29) { todayDay = 1; todayMonth++; } } if (todayMonth == 13) { todayMonth = 1; todayYear++; } } } PrintWriter out = new PrintWriter(System.out); out.println(result); out.flush(); } } ================================================ FILE: birthday_two/README.md ================================================

День рождения - 2 (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

Заданы день и месяц рождения, а также текущие день, месяц и год. Определить, сколько дней осталось до дня рождения.

Примечание. Високосные годы - это те, номер которых делится на 400, а также те, номер которых делится на 4, но не делится на 100.

Формат ввода

В первой строке входного файла INPUT.TXT находятся, разделённые пробелами, день и месяц рождения, во второй - разделённые пробелами текущие день, месяц и год. Ограничения: год от 1920 до 3000, месяц от 1 до 12, день от 1 до числа дней в месяце.

Формат вывода

В выходной файл OUTPUT.TXT выведите число дней, оставшихся до дня рождения.

Примеры

Ввод Вывод
19 04
19 04 2002		 0
05 05
19 04 2002		 16
29 02
28 02 2001		 1096
================================================ FILE: bit_reverse/BitReverse.java ================================================ package bit_reverse; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.math.BigInteger; import java.util.Scanner; public class BitReverse { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); long data = sc.nextInt(); String dataSystemTwo = new BigInteger(String.valueOf(data)).toString(2); char[] ch = dataSystemTwo.toCharArray(); StringBuilder revers = new StringBuilder(); for(int i = ch.length-1; i >= 0; i--){ revers.append(String.valueOf(ch[i])); } String reversNumber = revers.length() > 0 ? String.valueOf(revers) : "0"; BigInteger reversSystemTen = new BigInteger(reversNumber, 2); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(reversSystemTen)); out.close(); } } ================================================ FILE: bit_reverse/README.md ================================================

Бит-реверс (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Целое положительное число m записывается в двоичной системе счисления, разряды (в этой записи) переставляются в обратном порядке и число переводится в десятичную систему счисления. Получившееся число принимается за значение функции B(m).

Требуется написать программу, которая для заданного m вычислит B(m).

Формат ввода

Входной файл input.txt содержит натуральное число m (m ≤ 109).

Формат вывода

В выходной файл output.txt выведите значение B(m).

Примеры

Ввод Вывод
4 1
6 3
================================================ FILE: black_white_graphics/BlackWhiteGraphics.java ================================================ package black_white_graphics; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class BlackWhiteGraphics { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int row = 0, column = 0, index = -1; ArrayList firstImg = new ArrayList<>(); ArrayList secondImg = new ArrayList<>(); Map operation = new HashMap<>(); while (sc.hasNextLine()){ if(index == -1){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); column = Integer.valueOf(st.nextToken()); row = Integer.valueOf(st.nextToken()); }else if(index >= 0 && index < row){ firstImg.add(sc.nextLine()); }else if(index >= row && index < row*2){ secondImg.add(sc.nextLine()); }else { char[] ch = sc.nextLine().toCharArray(); operation.put("00", ch[0] - '0'); operation.put("01", ch[1] - '0'); operation.put("10", ch[2] - '0'); operation.put("11", ch[3] - '0'); } index++; } StringBuilder result = new StringBuilder(); for(int i = 0; i < row; i++){ char[] first = firstImg.get(i).toCharArray(); char[] second = secondImg.get(i).toCharArray(); for(int j = 0; j < column; j++){ int x = first[j] - '0'; int y = second[j] - '0'; if(x == 0 && y == 0){ result.append(operation.get("00")); }else if(x == 0 && y == 1){ result.append(operation.get("01")); }else if(x == 1 && y == 0){ result.append(operation.get("10")); }else { result.append(operation.get("11")); } } result.append("\n"); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result).trim()); out.close(); } } ================================================ FILE: black_white_graphics/README.md ================================================

Черно-белая графика (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Одна из базовых задач компьютерной графики – обработка черно-белых изображений. Изображения можно представить в виде прямоугольников шириной w и высотой h, разбитых на w×h единичных квадратов, каждый из которых имеет либо белый, либо черный цвет. Такие единичные квадраты называются пикселами. В памяти компьютера сами изображения хранятся в виде прямоугольных таблиц, содержащих нули и единицы.

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

Требуется написать программу, которая вычислит результат попиксельного применения заданной логической операции к двум черно-белым изображениям одинакового размера.

Формат ввода

Первая строка входного файла input.txt содержит два целых числа w и h (1 ≤ w, h ≤ 100). Последующие h строк описывают первое изображение и каждая из этих строк содержит w символов, каждый из которых равен нулю или единице. Далее следует описание второго изображения в аналогичном формате. Последняя строка входного файла содержит описание логической операции в виде четырех чисел, каждое из которых – ноль или единица. Первое из них есть результат применения логической операции в случае, если оба аргумента – нули, второе – результат в случае, если первый аргумент – ноль, второй – единица, третье – результат в случае, если первый аргумент – единица, второй – ноль, а четвертый – в случае, если оба аргумента – единицы.

Формат вывода

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

Примеры

Ввод Вывод
5 3
01000
11110
01000
10110
00010
10110
0110		 11110
11100
11110
================================================ FILE: board/Board.java ================================================ package board; import java.util.*; import java.io.*; public class Board { private static ArrayList dataAll = new ArrayList<>(); private static ArrayList advColor = new ArrayList<>(); private static ArrayList descColor = new ArrayList<>(); private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ dataAll.add(st.nextToken()); } } int height = Integer.valueOf(dataAll.get(0)); // Количество строк for(int i = 0; i < dataAll.size(); i++){ if(i != 0 && i != 1){ // Если не параметры табло if(i < 2+height){ // Разбираем строки с цветом рекламы char[] ch = dataAll.get(i).toCharArray(); for(Character line : ch){ advColor.add(String.valueOf(line)); } }else{ descColor.add(dataAll.get(i)); // Данные о цветопередаче табло } } } } public static void main(String[] argv) throws IOException{ getData(); boolean isAdvOk = true; // Рекламу показать можно for(int i = 0; i < advColor.size(); i++){ switch (advColor.get(i)) { // Проверка условий, когда рекламу показать нельзя case ("G") : if(!descColor.get(i).equals("2") && !descColor.get(i).equals("3") && !descColor.get(i).equals("6") && !descColor.get(i).equals("7")){ isAdvOk = false; } break; case ("R") : if(!descColor.get(i).equals("4") && !descColor.get(i).equals("5") && !descColor.get(i).equals("6") && !descColor.get(i).equals("7")){ isAdvOk = false; } break; case ("B") : if(!descColor.get(i).equals("1") && !descColor.get(i).equals("3") && !descColor.get(i).equals("5") && !descColor.get(i).equals("7")){ isAdvOk = false; } break; } } String result = (!isAdvOk) ? "NO" : "YES"; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: board/README.md ================================================

Табло (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

На хоккейном стадионе в одном большом городе расположено большое прямоугольное табло. Оно имеет n строк и m столбцов (то есть состоит из n x m ячеек). Во время хоккейного матча это табло служит для отображения счета и времени, прошедшего с начала тайма, а в перерывах на нем показывают различную рекламу.

В связи с этим возникла задача проверки возможности показа на этом табло определенной рекламной заставки. Заставка также, как и табло, имеет размер n строк на m столбцов. Каждая из ячеек заставки окрашена в один из четырех цветов - трех основных: красный - R, зеленый - G, синий - B и черный - .(точка).

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

  • 0 - ячейка может отображать только черный цвет;
  • 1 - ячейка может отображать только черный и синий цвета;
  • 2 - ячейка может отображать только черный и зеленый цвета;
  • 3 - ячейка может отображать только черный, зеленый и синий цвета;
  • 4 - ячейка может отображать только черный и красный цвета;
  • 5 - ячейка может отображать только черный, красный и синий цвета;
  • 6 - ячейка может отображать только черный, красный и зеленый цвета;
  • 7 - ячейка может отображать только черный, красный, зеленый и синий цвета.

Напишите программу, которая по описанию табло и заставки определяет: возможно ли на табло отобразить эту заставку.

Формат ввода

Первая строка входного файла input.txt содержит целые числа n и m (1 ≤ n, m ≤ 100). Далее идут n строк по m символов каждая - описание заставки. Каждый из символов описания заставки принадлежит множеству {R, G, B, .} . Их значения описаны выше.

После этого идет описание табло. Оно содержит n строк по m чисел, разделенных пробелами. Значения чисел описаны выше.

Формат вывода

В выходной файл output.txt выведите YES, если на табло возможно отобразить заставку и NO - в противном случае.

Примеры

Ввод Вывод
3 3
.GB
R.B
RG.
0 1 2
3 4 5
6 7 0		 NO
2 3
RGB
.G.
7 7 7
7 7 7		 YES
================================================ FILE: bolts_nuts/BoltsNuts.java ================================================ package bolts_nuts; import java.util.*; import java.io.*; public class BoltsNuts { private static ArrayList data = new ArrayList<>(); private static ArrayList bolt = new ArrayList<>(); private static ArrayList nuts = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ data.add(sc.nextLine()); } StringTokenizer stBolts = new StringTokenizer(data.get(0), " "); while (stBolts.hasMoreTokens()){ bolt.add(Double.valueOf(stBolts.nextToken())); } StringTokenizer stNuts = new StringTokenizer(data.get(1), " "); while (stNuts.hasMoreTokens()){ nuts.add(Double.valueOf(stNuts.nextToken())); } } public static void main(String[] argv) throws IOException{ getData(); double subtotal = bolt.get(0) * (bolt.get(1) / 100) * bolt.get(2) + nuts.get(0) * (nuts.get(1) / 100) * nuts.get(2); double boltSave = bolt.get(0) - bolt.get(0) * (bolt.get(1) / 100); double nutsSave = nuts.get(0) - nuts.get(0) * (nuts.get(1) / 100); double diffrentDetail = (boltSave > nutsSave) ? (boltSave - nutsSave) * bolt.get(2) : (boltSave < nutsSave) ? (nutsSave - boltSave) * nuts.get(2) : 0; double result = subtotal + diffrentDetail; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf((int)result)); pw.close(); } } ================================================ FILE: bolts_nuts/README.md ================================================

Болты и гайки(17%)

Время: 1 сек.
Память: 16 Мб
Сложность: 17%

Вновь созданная фирма купила заброшенные склады на окраине города. Новому заведующему складами поручили произвести учёт в короткие сроки. Всё шло хорошо, пока случайно не рассыпали контейнеры с болтами и гайками на каждом складе, после чего собрали их в общие (для болтов и гаек) контейнеры, потеряв при этом несколько деталей.

Помогите оценить нанесённый ущерб на каждом складе, приняв во внимание, что, помимо потерянных деталей, болт (или гайка) считается непригодным, если он не имеет соответствующей гайки (или болта).

Формат ввода

Во входном файле input.txt описано текущее положение на складе. В первой строке через пробел записаны три целых числа: k1, l1, m1 – начальное число болтов (100 ≤ k1 ≤ 30000, k1 кратно 100), процент потерянных деталей (0 ≤ l1 ≤ 100) и стоимость одного болта (1 ≤ m1 ≤ 100) соответственно. Во второй строке через пробел записаны также три целых числа: k2, l2, m2 – начальное число гаек (100 ≤ k2 ≤ 30000, k2 кратно 100), процент потерянных деталей (0 ≤ l2 ≤ 100) и стоимость одной гайки (1 ≤ m2 ≤ 100) соответственно.

Формат вывода

В выходной output.txt выведите одно целое число – размер ущерба.

Примеры

Ввод Вывод
1000 10 100
1200 20 90		 37000
5000 15 23
4000 17 22		 53600
================================================ FILE: bowling/Bowling.java ================================================ package bowling; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class Bowling { public static void main(String[] args) throws IOException { ArrayList hits = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()) { String[] input = sc.nextLine().split(" "); for (String hit: input) { hits.add(Integer.parseInt(hit)); } } hits.remove(0); // удалить количество бросков int points = 0; // количество очков int attemptCount = 1; // номер попытки boolean firstShot = true; for (int index = 0; index < hits.size(); index++) { if (firstShot && hits.get(index) == 10 && attemptCount <= 9) { points += 10; if (index + 1 < hits.size()) { points += hits.get(index + 1); } if (index + 2 < hits.size()) { points += hits.get(index + 2); } firstShot = false; } else if (!firstShot && hits.get(index) + hits.get(index - 1) == 10 && attemptCount <= 9) { points += hits.get(index); if (index + 1 < hits.size()) { points += hits.get(index + 1); } } else { points += hits.get(index); } if (!firstShot) { attemptCount++; } firstShot = !firstShot; } PrintWriter out = new PrintWriter(System.out); out.println(points); out.flush(); } } ================================================ FILE: bowling/README.md ================================================

Боулинг (29%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 29%

Цель при игре в боулинг – сбить шаром максимальное количество кеглей. Партия в этой игре состоит из 10 туров. Задача игрока – сбить все 10 кеглей в каждом туре. Для этого игрок может совершить 2 броска шара, за исключением:

  • если 10 кеглей сбиты первым броском, то второй бросок не совершается;
  • если 10 кеглей сбиты первым броском в десятом туре, то игроку предоставляются два призовых броска, а если двумя бросками – один.

Количество очков в каждом туре равно количеству сбитых кеглей, кроме двух бросков, называемых «Strike» и «Spare».

Strike: игрок сбивает 10 кеглей первым броском, очки в этом туре начисляются из расчета – 10 + сумма очков за два последующих броска.

Spare: игрок сбивает 10 кеглей двумя бросками, очки в этом туре начисляются из расчета – 10 + сумма очков за один последующий бросок.

Результат партии складывается из результатов всех 10 туров.

Требуется написать программу, которая определит количество набранных игроком очков.

Формат ввода

Входной файл input.txt содержит в первой строке одно натуральное число, определяющее количество совершенных бросков. Вторая строка содержит натуральные числа (разделенные пробелом), обозначающие количество сбитых кеглей за каждый совершенный бросок.

Формат вывода

Выходной файл output.txt должен содержать одно целое число – количество набранных игроком очков.

Примеры

Ввод Вывод
12
10 10 10 10 10 10 10 10 10 10 10 10		 300
20
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0		 0
15
10 10 10 8 2 10 3 4 8 2 4 5 10 4 5		 173
================================================ FILE: boxes/Boxes.java ================================================ package boxes; import java.util.*; import java.io.*; public class Boxes { private static ArrayList data = new ArrayList<>(); private static ArrayList boxFirst = new ArrayList<>(); private static ArrayList boxSecond = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } for(int i = 0; i < data.size(); i++){ if(i < 3){ boxFirst.add(data.get(i)); }else{ boxSecond.add(data.get(i)); } } Collections.sort(boxFirst); Collections.sort(boxSecond); } public static void main(String[] argv) throws IOException{ getData(); String result = (boxFirst.equals(boxSecond)) ? "Boxes are equal" : (boxFirst.get(0) >= boxSecond.get(0) && boxFirst.get(1) >= boxSecond.get(1) && boxFirst.get(2) >= boxSecond.get(2)) ? "The first box is larger than the second one" : (boxSecond.get(0) >= boxFirst.get(0) && boxSecond.get(1) >= boxFirst.get(1) && boxSecond.get(2) >= boxFirst.get(2)) ? "The first box is smaller than the second one" : "Boxes are incomparable"; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: boxes/README.md ================================================

Коробки (19%)

Время: 1 сек.
Память: 16 Мб
Сложность: 19%

На столе лежат коробка размера A1 × B1 × C1 и коробка размера A2 × B2 × C2. Выясните можно ли одну из этих коробок положить в другую, если разрешены повороты коробок вокруг любого ребра на угол 90 градусов.

Формат ввода

Первая строка входного файла содержит три целых числа A1, B1 и C1. Вторая строка входного файла содержит три целых числа A2, B2 и C2. Все числа положительны и не превосходят 1000.

Формат вывода

Если коробки одинаковы, выведите "Boxes are equal". Если первая коробка может быть положена во вторую, выведите "The first box is smaller than the second one". Если вторая коробка может быть положена в первую, выведите "The first box is larger than the second one". Иначе, выведите "Boxes are incomparable".

Примеры

Ввод Вывод
1 2 3
3 2 1		 Boxes are equal
2 2 3
3 2 1		 The first box is larger than the second one
2 2 3
3 2 3		 The first box is smaller than the second one
3 4 5
2 4 6		 Boxes are incomparable
================================================ FILE: building_of_schools/BuildingOfSchools.java ================================================ package building_of_schools; import java.io.*; import java.util.StringTokenizer; public class BuildingOfSchools { public static void main(String[] args) throws IOException { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); PrintWriter out = new PrintWriter(System.out); int n = Integer.parseInt(in.readLine()); StringTokenizer st = new StringTokenizer(in.readLine(), " "); int index = 0; while (st.hasMoreTokens() && index < n/2+1) { String point = st.nextToken(); if (index == n/2) { out.println(point); } index++; } out.flush(); } } ================================================ FILE: building_of_schools/README.md ================================================

Строительство школы (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

В деревне Интернетовка все дома расположены вдоль одной улицы по одну сторону от нее. По другую сторону от этой улицы пока ничего нет, но скоро все будет – школы, магазины, кинотеатры и т.д.

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

План деревни можно представить в виде прямой, в некоторых целочисленных точках которой находятся дома учеников. Школу также разрешается строить только в целочисленной точке этой прямой (в том числе разрешается строить школу в точке, где расположен один из домов – ведь школа будет расположена с другой стороны улицы).

Напишите программу, которая по известным координатам домов учеников поможет определить координаты места строительства школы.

Формат ввода

В первой строке входного файла INPUT.TXT сначала записано число N — количество учеников (1 ≤ N ≤ 100000). Во второй строке записаны в строго возрастающем порядке координаты домов учеников — целые числа, не превосходящие 2∙109 по модулю.

Формат вывода

В единственную строку выходного файла OUTPUT.TXT нужно вывести одно целое число — координату точки, в которой лучше всего построить школу. Если ответов несколько, выведите наибольший из них.

Примеры

Ввод Вывод
4
1 2 3 4		 3
3
-1 0 1		 0
================================================ FILE: bulls_cows/BullsCows.java ================================================ package bulls_cows; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class BullsCows { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); String oneNumber = "", twoNumber = ""; int index = 0; while (st.hasMoreTokens()){ if(index == 0){ oneNumber = st.nextToken(); }else { twoNumber = st.nextToken(); } index++; } int bulls = 0, cows = 0; char[] oneArr = oneNumber.toCharArray(); char[] twoArr = twoNumber.toCharArray(); for(int i = 0; i < oneArr.length; i++){ if(oneArr[i] == twoArr[i]){ bulls++; }else { for (char anOneArr : oneArr) { if (twoArr[i] == anOneArr) { cows++; break; } } } } String result = bulls + " " + cows; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: bulls_cows/README.md ================================================

Красивая стена (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Петя и Вася часто играют в различные логические игры. Недавно Петя поведал Васе о новой игре «Быки и коровы» и теперь они играют в эту игру сутками. Суть игры очень проста: Петя загадывает четырехзначное число, состоящее из различных цифр. Вася отгадывает задуманное Петей число, перебирая возможные варианты. Каждый раз Вася предлагает вариант своего числа, а Петя делает Васе подсказку: сообщает количество быков и коров, после чего Вася с учетом подсказки продолжает отгадывание числа до тех пор, пока не отгадает. Быки – это количество цифр в предложенном Васей числе, совпадающих по значению и стоящих в правильной позиции в задуманном Петей числе. Коровы – количество цифр, совпадающих по значению, но находящихся в неверной позиции. Например, если Петя задумал число 5671, а Вася предложил вариант 7251, то число быков равно 1 (только цифра 1 на своем месте), а число коров равно 2 (только цифры 7 и 5 не на своих местах). Петя силен в математике, но даже он может ошибаться. Помогите Пете написать программу, которая бы по загаданному Петей и предложенному Васей числам сообщала количество быков и коров.

Формат ввода

В единственной строке входного файла input.txt записано два четырехзначных натуральных числа A и B через пробел, где А – загаданное Петей число, а В – предложенный Васей вариант.

Формат вывода

В выходной файл output.txt нужно вывести два целых числа через пробел — количество быков и коров.

Примеры

Ввод Вывод
5671 7251 1 2
1234 1234 4 0
2034 6234 2 1
================================================ FILE: bus_tour/BusTour.java ================================================ package bus_tour; import java.io.*; import java.util.*; public class BusTour { public static void main(String[] args) throws IOException { ArrayList data= new ArrayList<>(); // Исходные данные построчно ArrayList heightBridge = new ArrayList<>(); // Высота всех мостов int heightBus = 437; // Высота автобуса int numberBridge = 0; // Номер моста по умолчанию String result; // Результат решения задачи FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ data.add(sc.nextLine()); } StringTokenizer st = new StringTokenizer(data.get(1), " "); while (st.hasMoreTokens()){ heightBridge.add(Integer.valueOf(st.nextToken())); } for(int i = 0; i < heightBridge.size(); i++){ if(heightBridge.get(i) <= heightBus){ numberBridge = i + 1; break; } } result = (numberBridge == 0) ? "No crash" : "Crash " + numberBridge; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: bus_tour/README.md ================================================

Автобусная экскурсия (14%)

Время: 1 сек.
Память: 16 Мб
Сложность: 14%

Оргкомитет Московской городской олимпиады решил организовать обзорную экскурсию по Москве для участников олимпиады. Для этого был заказан двухэтажный автобус (участников олимпиады достаточно много и в обычный они не умещаются) высотой 437 сантиметров. На экскурсионном маршруте встречаются N мостов. Жюри и оргкомитет олимпиады очень обеспокоены тем, что высокий двухэтажный автобус может не проехать под одним из них. Им удалось выяснить точную высоту каждого из мостов. Автобус может проехать под мостом тогда и только тогда, когда высота моста превосходит высоту автобуса.

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

Формат ввода

Во входном файле input.txt сначала содержится число N (1 ≤ N ≤ 1000). Далее идут N натуральных чисел, не превосходящих 10000 - высоты мостов в сантиметрах в том порядке, в котором они встречаются на пути автобуса.

Формат вывода

В единственную строку выходного файла output.txt нужно вывести фразу "No crash", если экскурсия закончится благополучно. Если же произойдет авария, то нужно вывести сообщение "Crash k", где k - номер моста, где произойдет авария. Фразы выводить без кавычек ровно с одним пробелом внутри.

Примеры

Ввод Вывод
1
763		 No crash
3
763 245 113		 Crash 2
1
437		 Crash 1
================================================ FILE: business/Business.java ================================================ package business; import java.util.*; import java.io.*; public class Business { private static ArrayList carCost = new ArrayList<>(); private static ArrayList startData = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); int numberLine = 0; while (sc.hasNextLine()){ numberLine++; String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ if(numberLine != 1){ carCost.add(Integer.valueOf(st.nextToken())); }else{ startData.add(Integer.valueOf(st.nextToken())); } } } } public static void main(String[] argv) throws IOException { getData(); int money = startData.get(1); int k = 0; Collections.sort(carCost); for (Integer aCarCost : carCost) { money = money - aCarCost; if (money >= 0) { k++; } else { break; } } PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(k)); pw.close(); } } ================================================ FILE: business/README.md ================================================

Кризисный бизнес (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

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

Несмотря ни на что, Петр Васильевич не отчаялся и решил начать свое дело. Тщательно проанализировав бизнес-климат в своем регионе, Петр Васильевич пришел к выводу, что наиболее целесообразным будет открыть новый таксопарк. Первое с чего решил начать новоиспеченный бизнесмен – это закупить автомобили. За все время работы Петр Васильевичу удалось накопить сумму S, которую он готов потратить на закупку машин.

В городе, в котором живет Петр Васильевич, есть только один автосалон. Известно, что в этом автосалоне выставлено на продажу N автомобилей, причем установлено, что стоимость i-го автомобиля равняется Ai. Вашей задачей является помочь еще неопытному бизнесмену Петр Васильевичу приобрести максимальное количество автомобилей, потратив сумму не более S.

Формат ввода

В первой строке входного файла input.txt находится два целых положительных числа разделенные одиночным пробелом – это числа N (1 ≤ N ≤ 100) и S (1 ≤ S ≤ 109) соответственно.

Вторая строка содержит ровно N чисел Ai (1 ≤ Ai ≤ 109

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

Формат вывода

В выходной файл output.txt выведите одно целое число – максимальное количество автомобилей, которые сможет приобрести Петр Васильевич на сумму не более чем S.

Примеры

Ввод Вывод
5 30
15 5 11 10 12		 3
6 18
5 10 1 2 1 20		 4
================================================ FILE: cake/Cake.java ================================================ package cake; import java.util.*; import java.io.*; public class Cake { public static void main(String[] args) throws IOException { int number; int guest; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); guest = Integer.valueOf(str); number = (guest == 1) ? 0 : (guest % 2 == 1) ? guest : guest / 2; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(number)); fileOut.close(); } } ================================================ FILE: cake/README.md ================================================

Торт (6%)

Время: 1 сек.
Память: 16 Мб
Сложность: 6%

На свой день рождения Петя купил красивый и вкусный торт, который имел идеально круглую форму. Петя не знал, сколько гостей придет на его день рождения, поэтому вынужден был разработать алгоритм, согласно которому он сможет быстро разрезать торт на N равных частей. Следует учесть, что разрезы торта можно производить как по радиусу, так и по диаметру.

Помогите Пете решить эту задачу, определив наименьшее число разрезов торта по заданному числу гостей.

Формат ввода

Входной файл input.txt содержит натуральное число N – число гостей, включая самого виновника торжества (N ≤ 1000).

Формат вывода

В выходной файл output.txt выведите минимально возможное число разрезов торта.

Примеры

Ввод Вывод
2 1
3 3
================================================ FILE: cake_two/CakeTwo.java ================================================ package cake_two; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class CakeTwo { private static int _gcd(int a, int b) { if (b == 0) return a; else return _gcd(b, a % b); } public static void main(String[] args) throws IOException { String[] data = new Scanner(new FileReader("input.txt")).nextLine().split(" "); int m = Integer.parseInt(data[0]); int n = Integer.parseInt(data[1]); int res = m + n - _gcd(m, n); PrintWriter out = new PrintWriter(System.out); out.println(res); out.flush(); } } ================================================ FILE: cake_two/README.md ================================================

Торт - 2 (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

Никифор на день рождения собирается угостить друзей тортом. Известно, что на дне рождения может быть либо M, либо N человек, включая самого именинника. На какое минимальное количество частей ему нужно разрезать торт (не обязательно всех равных), чтобы при любом из указанных количеств собравшихся, все съели торт поровну?

Формат ввода

Входной файл INPUT.TXT содержит два натуральных числа M и N через пробел (1 ≤ M, N ≤ 30000).

Формат вывода

В выходной файл OUTPUT.TXT выведите единственное число – искомое минимальное количество кусочков торта.

Примеры

Ввод Вывод
2 3 4
================================================ FILE: carousel/Carousel.java ================================================ package carousel; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class Carousel { private static ArrayList answers = new ArrayList<>(); private static long pointTotal(){ int startScore = 3; int mistakePenalty = 3; long total = 0; for(int i : answers){ if (i == 1){ total += startScore; startScore++; }else { startScore = (startScore - mistakePenalty < mistakePenalty) ? mistakePenalty : startScore - mistakePenalty; } } return total; } public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ answers.add(Integer.valueOf(st.nextToken())); } } answers.remove(0); long result = pointTotal(); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: carousel/README.md ================================================

Карусель (22%)

Время: 1 сек.
Память: 16 Мб
Сложность: 22%

Карусель – одна из популярных форм проведения командных соревнований по решению задач. Наибольшую известность в использовании данной модели в России получил ресурс «Интернет-карусели», расположенный в сети Интернет по адресу http://karusel.desc.ru.

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

Начисление баллов происходит согласно следующей схеме:

  • первая задача стоит 3 балла;
  • если к задаче дан верный ответ, то команда получает ее стоимость, а следующая задача будет стоить на 1 балл больше;
  • если на задачу дан неверный ответ, то команда получает за решение 0 баллов, а следующая задача будет стоить на 3 балла меньше, но не менее 3 баллов.

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

Формат ввода

Первая строка входного файла input.txt содержит натуральное число N – количество задач в карусели (N ≤ 105). Во второй строке расположены N цифр 0 или 1, разделенные пробелом; i-я цифра соответствует корректности ответа команды на i-ю задачу (0 – неверный ответ, 1 – верный ответ).

Формат вывода

В выходной файл output.txt выведите целое число – количество набранных баллов.

Примеры

Ввод Вывод
3
1 1 1		 12
9
1 0 1 1 1 1 0 1 1		 30
================================================ FILE: casting/Casting.java ================================================ package casting; import java.util.*; import java.io.*; public class Casting { private static ArrayList data = new ArrayList<>(); private static int actorCount = 0; private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } } private static void dataProcessing(){ int typeCasting = data.get(0); int n = data.get(1); data.remove(data.get(0)); data.remove(data.get(0)); Collections.sort(data); int aFactor = data.get(0); int bFactor = data.get(1); int cFactor = data.get(2); if(typeCasting == 2){ // Вычисление максимального кол-ва актеров actorCount = aFactor; }else{ // Вычисление минимального кол-ва актеров if(aFactor != 0 && bFactor != 0 && cFactor != 0){ actorCount = (aFactor + bFactor + cFactor) - 2 * n; // Пересечение множеств actorCount = (actorCount <= 0) ? 0 : actorCount; // Если значение менее или = 0, множества не пересекаются } } } public static void main(String[] argv) throws IOException{ getData(); dataProcessing(); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(actorCount)); pw.close(); } } ================================================ FILE: casting/README.md ================================================

Кастинг (19%)

Время: 1 сек.
Память: 16 Мб
Сложность: 19%

В театре работает n актеров. Известно, что среди них a – высоких, b – голубоглазых и с – блондинов. Для главной роли в новом спектакле режиссеру требуется только один высокий голубоглазый блондин. Чтобы спланировать свое время для беседы с каждым таким артистом из труппы театра, режиссеру необходимо узнать, какое максимальное или какое минимальное количество артистов из работающих в театре подходит для этой роли.

Требуется написать программу, которая по заданным числам n, a, b и с определяет минимальное или максимальное количество актеров, с которыми режиссер должен переговорить.

Формат ввода

Первая строка входного файла input.txt содержит одно число, которое задает: минимальное или максимальное количество актеров необходимо найти. Это число может принимать следующие значения:

  • 1, если в данном тесте требуется определить минимальное количество актеров;
  • 2, если в данном тесте требуется определить максимальное количество актеров.

Вторая строка входного файла содержит разделенные пробелами четыре целых числа: n, a, b, с (1 ≤ n ≤ 10 000, 0 ≤ a ≤ n, 0 ≤ b ≤ n, 0 ≤ c ≤ n).

Формат вывода

В выходной файл output.txt выведите одно число – минимальное или максимальное (в зависимости от входных данных) количество актеров, которые могут претендовать на главную роль в новом спектакле.

Примеры

Ввод Вывод
2
5 3 4 5		 3
1
5 3 4 5		 2
================================================ FILE: castle/Castle.java ================================================ package castle; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.math.BigInteger; import java.util.Scanner; import java.util.StringTokenizer; public class Castle { private static BigInteger sum(int n, int k){ BigInteger result = BigInteger.valueOf(0); for (int i = 0; i < k; i++){ BigInteger sub = BigInteger.valueOf((n-2)).multiply(BigInteger.valueOf(i)); result = result.add(sub); } return result; } public static void main(String[] args) throws IOException { int n = 0, k = 0; Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ n = Integer.valueOf(st.nextToken()); k = Integer.valueOf(st.nextToken()); } BigInteger result = BigInteger.valueOf(n-1).multiply(BigInteger.valueOf(k)).add(sum(n, k)).add(BigInteger.valueOf(1)); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: castle/README.md ================================================

Замок (29%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 29%

Замок состоит из K уровней. Каждый уровень - это правильный N-угольник, угол которого совпадает с углом предыдущего. На сторонах первого уровня находится по две комнаты (в углах), на сторонах каждого следующего - на одну больше. Сколько в замке комнат?

Формат ввода

В первой строке входного файла input.txt указаны два целых числа N и K (3 ≤ N ≤ 106; 1 ≤ K ≤ 106).

Формат вывода

В выходной файл output.txt выведите целое число - количество комнат в замке.

Примеры

Ввод Вывод
6 3 28
================================================ FILE: cell/Cell.java ================================================ package cell; import java.io.*; import java.util.*; public class Cell { public static void main(String[] args) throws IOException { ArrayList coordinate = new ArrayList<>(); ArrayList letter = new ArrayList<>(Arrays.asList("A", "B", "C", "D", "E", "F", "G", "H")); String cellColor = null; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); char[] ch = str.toCharArray(); for(char aCh : ch){ coordinate.add(String.valueOf(Character.valueOf(aCh))); } for(int i = 0; i < letter.size(); i++){ if(letter.get(i).equals(coordinate.get(0))){ cellColor = ((i+1)%2 == 0 && Integer.valueOf(coordinate.get(1)) % 2 == 0) ? "BLACK" : ((i+1)%2 == 1 && Integer.valueOf(coordinate.get(1)) % 2 == 1) ? "BLACK" : "WHITE"; } } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(Objects.requireNonNull(cellColor)); fileOut.close(); } } ================================================ FILE: cell/README.md ================================================

Клетки (15%)

Время: 1 сек.
Память: 16 Мб
Сложность: 15%

Известно, что шахматная доска имеет размерность 8х8 и состоит из клеток 2х цветов, например, черного и белого (см. рисунок). Каждая клетка имеет координату, состоящую из буквы и цифры. Горизонтальное расположение клетки определяется буквой от A до H, а вертикальное – цифрой от 1 до 8. Заметим, что клетка с координатой А1 имеет черный цвет. Требуется по заданной координате определить цвет клетки.

Формат ввода

В единственной строке входного файла input.txt записана координата клетки на шахматной доске: всего два символа – буква и цифра (без пробелов).

Формат вывода

В выходной файл output.txt нужно вывести «WHITE», если указанная клетка имеет белый цвет и «BLACK», если она черная.

Примеры

Ввод Вывод
C3 BLACK
G8 WHITE
================================================ FILE: census/Census.java ================================================ package census; import java.io.*; import java.util.*; public class Census { private static ArrayList data = new ArrayList<>(); private static int oldManNumber = -1; private static int manAge = 0; private static void dataValidation(){ // int j = 0; // Счетчик номера жильца for (int i = 0; i < data.size(); i++){ if(data.get(i) != 0 && i % 2 == 1){ j++; } if(i % 2 == 1 && data.get(i+1) == 1 && i+1 < data.size()){ // Проверка возраста мужчины if(data.get(i) > manAge){ manAge = data.get(i); oldManNumber = j; } } } } public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str; while (sc.hasNextLine()){ str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } dataValidation(); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(oldManNumber)); fileOut.close(); } } ================================================ FILE: census/README.md ================================================

Перепись (15%)

Время: 1 сек.
Память: 16 Мб
Сложность: 15%

В доме живет N жильцов. Однажды решили провести перепись всех жильцов данного дома и составили список, в котором указали возраст и пол каждого жильца. Требуется найти номер самого старшего жителя мужского пола.

Формат ввода

Во входном файле input.txt в первой строке задано натуральное число N – количество жильцов (N ≤ 100). В последующих N строках располагается информация о всех жильцах: каждая строка содержит два целых числа: V и S – возраст и пол человека (1 ≤ V ≤ 100, S – 0 или 1). Мужскому полу соответствует значение S=1, а женскому – S=0.

Формат вывода

Выходной файл output.txt должен содержать номер самого старшего мужчины в списке. Если таких жильцов несколько, то следует вывести наименьший номер. Если жильцов мужского пола нет, то выведите -1.

Примеры

Ввод Вывод
4
25 1
70 1
100 0
3 1		 2
2
25 0
25 1		 2
================================================ FILE: checking_for_likability/CheckingForLikability.java ================================================ package checking_for_likability; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; public class CheckingForLikability { /** * @param arr Двумерный массив * @return true, если массив симпатичный, false в противном случае * */ private static boolean check(int[][] arr){ for (int i = 0; i < arr.length; i++){ for(int j = 0; j < arr[i].length; j++){ if (i - 1 >= 0 && j - 1 >= 0){ if(arr[i][j] == arr[i][j-1] && arr[i][j] == arr[i-1][j] && arr[i][j] == arr[i-1][j-1]){ return false; } } } } return true; } public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); sc.nextLine(); // Отбросить 1 строку int[][] arr = new int[0][]; int n, m = 0, row = 0; while (sc.hasNextLine()){ String[] lineArr = sc.nextLine().split(" "); if(lineArr.length == 2){ if(arr.length > 0){ data.add(arr); row = 0; } n = Integer.valueOf(lineArr[0]); m = Integer.valueOf(lineArr[1]); arr = new int[n][m]; }else { if(arr.length > 0){ for (int i = 0; i < m; i++){ arr[row][i] = Integer.valueOf(lineArr[i]); } row++; } } } data.add(arr); StringBuilder result = new StringBuilder(); for (int[][] arrays : data){ if(check(arrays)){ result.append("YES").append("\n"); }else result.append("NO").append("\n"); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: checking_for_likability/README.md ================================================

Проверка на симпатичность (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Рассмотрим таблицу, содержащую n строк и m столбцов, в каждой клетке которой расположен ноль или единица. Назовем такую таблицу симпатичной, если в ней нет ни одного квадрата 2 на 2, заполненного целиком нулями или целиком единицами.

Так, например, таблица 4 на 4, расположенная слева, является симпатичной, а расположенная справа таблица 3 на 3 - не является.

Задано несколько таблиц. Необходимо для каждой из них выяснить, является ли она симпатичной.

Формат ввода

Первая строка входного файла input.txt содержит количество t (1 ≤ t ≤ 10) наборов входных данных. Далее следуют описания этих наборов. Описание каждого набора состоит из строки, содержащей числа n и m (1 ≤ n,m ≤ 100), и n строк, каждая из которых содержит по m чисел, разделенных пробелами. j-ое число в i+1-ой строке описания набора входных данных - элемент aij соответствующей таблицы. Гарантируется, что все aij равны либо нулю, либо единице.

Формат вывода

Для каждого набора входных данных выведите в файл output.txt единственную строку, содержащую слово «YES», если соответствующая таблица является симпатичной, и слово «NO» - в противном случае.

Примеры

Ввод Вывод
3
1 1
0
4 4
1 0 1 0
1 1 1 0
0 1 0 1
0 0 0 0
3 3
0 0 1
0 0 1
1 1 1		 YES
YES
NO
================================================ FILE: chess/Chess.java ================================================ package chess; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; import java.util.stream.Collectors; import java.util.stream.IntStream; public class Chess { public static void main(String[] args) throws IOException { String result = ""; List cell = new ArrayList<>(); Map field = IntStream.rangeClosed('A', 'H') // Буквы шахматной доски .boxed() .collect(Collectors.toMap( x -> (char) x.intValue(), x -> x + (1 - 'A'))); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String data = sc.nextLine(); if(data.matches("(\\w){2}-(\\w){2}")){ StringTokenizer st = new StringTokenizer(data, "-"); while (st.hasMoreTokens()){ cell.add(st.nextToken()); } int[][] steps = new int[2][2]; for(int i = 0; i < cell.size(); i++){ char[] ch = cell.get(i).toCharArray(); for (int j = 0; j < ch.length; j++){ String str = String.valueOf(ch[j]); if(str.matches("\\d") && j % 2 == 1){ if(Integer.valueOf(str) <= 8 && Integer.valueOf(str) > 0){ steps[i][j] = Integer.valueOf(str); }else { result = "ERROR"; } }else if(j % 2 == 0) { //ch[j] = Character.toUpperCase(ch[j]); if (field.containsKey(ch[j])) { steps[i][j] = field.get(ch[j]); }else { result = "ERROR"; } }else { result = "ERROR"; } } } if(result.equals("")){ int aCoord = steps[0][0]; int bCoord = steps[0][1]; int cCoord = steps[1][0]; int dCoord = steps[1][1]; if(Math.abs((aCoord - cCoord) * (bCoord - dCoord)) == 2){ result = "YES"; }else { result = "NO"; } } }else { result = "ERROR"; } FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: chess/README.md ================================================

Шахматы (23%)

Время: 1 сек.
Память: 16 Мб
Сложность: 23%

Совсем недавно Вася занялся программированием и решил реализовать собственную программу для игры в шахматы. Но у него возникла проблема определения правильности хода конем, который делает пользователь. Т.е. если пользователь вводит значение «C7-D5», то программа должна определить это как правильный ход, если же введено «E2-E4», то ход неверный. Так же нужно проверить корректность записи ввода: если например, введено «D9-N5», то программа должна определить данную запись как ошибочную. Помогите ему осуществить эту проверку!

Формат ввода

В единственной строке входного файла input.txt записан текст хода (непустая строка), который указал пользователь. Пользователь не может ввести строку, длиннее 5 символов.

Формат вывода

В выходной файл output.txt нужно вывести «YES», если указанный ход конем верный, если же запись корректна (в смысле правильности записи координат), но ход невозможен, то нужно вывести «NO». Если же координаты не определены или заданы некорректно, то вывести сообщение «ERROR».

Примеры

Ввод Вывод
C7-D5 YES
E2-E4 NO
BSN ERROR
================================================ FILE: chess_field/ChessField.java ================================================ package chess_field; import java.util.*; import java.io.*; public class ChessField { private static ArrayList coordinate = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ coordinate.add(Integer.valueOf(st.nextToken()) % 2); } } public static void main(String[] argv) throws IOException{ getData(); String result = (coordinate.get(0).equals(coordinate.get(1)) && coordinate.get(2).equals(coordinate.get(3)) || !coordinate.get(0).equals(coordinate.get(1)) && !coordinate.get(2).equals(coordinate.get(3))) ? "YES" : "NO"; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: chess_field/README.md ================================================

Шахматное поле (16%)

Время: 1 сек.
Память: 16 Мб
Сложность: 16%

На стандартной шахматной доске 8х8 заданы координаты двух клеток. Требуется определить: имеют ли данные клетки одинаковый цвет?

Формат ввода

Входной файл input.txt содержит целые числа x1, y1, x2, y2, описывающие координаты двух клеток (x1,y1) и (x2,y2). Ограничения: 1 ≤ x1,y1,x2,y2 ≤ 8.

Формат вывода

В выходной файл output.txt выведите YES, если поля одного цвета, или слово NO в противном случае.

Примеры

Ввод Вывод
1 1 4 4 YES
1 2 7 5 NO
================================================ FILE: chess_horse/ChessHorse.java ================================================ package chess_horse; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.HashMap; import java.util.Map; import java.util.Scanner; public class ChessHorse { public static void main(String[] args) throws IOException { StringBuilder result = new StringBuilder(); int oneCoordinate, twoCoordinate; Scanner sc = new Scanner(new FileReader("input.txt")); String cellIn = sc.nextLine(); Map field = new HashMap<>(); Map fieldSearchValue = new HashMap<>(); int index = 0; for(char i = 'a'; i <= 'h'; i++){ index += 1; field.put(i, index); fieldSearchValue.put(index, i); } char[] ch = cellIn.toCharArray(); oneCoordinate = field.get(ch[0]); twoCoordinate = ch[1] - '0'; int max = 8; int min = 1; if(oneCoordinate - 2 >= min && twoCoordinate + 1 <= max){ result.append(String.valueOf(fieldSearchValue.get(oneCoordinate-2))).append(twoCoordinate + 1).append("\n"); } if(oneCoordinate - 1 >= min && twoCoordinate + 2 <= max){ result.append(String.valueOf(fieldSearchValue.get(oneCoordinate - 1))).append(twoCoordinate + 2).append("\n"); } if(oneCoordinate + 2 <= max && twoCoordinate + 1 <= max){ result.append( String.valueOf(fieldSearchValue.get(oneCoordinate+2))).append(twoCoordinate + 1).append("\n"); } if(oneCoordinate + 1 <= max && twoCoordinate + 2 <= max){ result.append(String.valueOf(fieldSearchValue.get(oneCoordinate+1))).append(twoCoordinate + 2).append("\n"); } if(oneCoordinate + 2 <= max && twoCoordinate - 1 >= min){ result.append(String.valueOf(fieldSearchValue.get(oneCoordinate+2))).append(twoCoordinate - 1).append("\n"); } if(oneCoordinate + 1 <= max && twoCoordinate - 2 >= min){ result.append(String.valueOf(fieldSearchValue.get(oneCoordinate+1))).append(twoCoordinate - 2).append("\n"); } if(oneCoordinate - 1 >= min && twoCoordinate - 2 >= min){ result.append(String.valueOf(fieldSearchValue.get(oneCoordinate-1))).append(twoCoordinate - 2).append("\n"); } if(oneCoordinate - 2 >= min && twoCoordinate - 1 >= min){ result.append(String.valueOf(fieldSearchValue.get(oneCoordinate-2))).append(twoCoordinate - 1).append("\n"); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: chess_horse/README.md ================================================

Шахматный конь (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Вася решил научиться играть в шахматы. Он нашел книгу с записями партий и внимательно их изучает. Может быть, когда-нибудь Вася станет великим шахматистом, но пока он еще учится в начальной школе, и ему нелегко дается шахматная нотация. Больше всего трудностей у Васи вызывают ходы шахматного коня. Он попросил вас написать программу, которая сможет сообщить Васе, на какие клетки можно пойти конем с заданной клетки.

Вы, наверное, тоже знаете, что конь в шахматах всегда перемещается либо на две клетки по горизонтали и на одну по вертикали, либо на одну по горизонтали и на две по вертикали. Вертикали обозначаются маленькими английскими буквами от a до h, а горизонтали - цифрами от 1 до 8. Любая клетка на шахматной доске обозначается буквой соответствующей вертикали и цифрой соответствующей горизонтали, например, c6 или e2.

Формат ввода

Во входном файле input.txt записано 2 символа – координаты клетки, где стоит конь.

Формат вывода

В выходной файл output.txt в произвольном порядке выведите все координаты клеток, на которые за один ход может попасть конь, находящийся на заданной клетке.

Примеры

Ввод Вывод
e2 c1
c3
d4
f4
g1
g3
a1 b3
c2
================================================ FILE: chess_workshop/ChessWorkshop.java ================================================ package chess_workshop; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class ChessWorkshop { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] firstLine = sc.nextLine().split(" "); int n = Integer.parseInt(firstLine[0]); int m = Integer.parseInt(firstLine[1]); char[][] data = new char[n][m]; for (int i = 0; i < n; i++) { char[] line = sc.nextLine().toCharArray(); if (m >= 0) System.arraycopy(line, 0, data[i], 0, m); } int recolorFirstVariant = 0; int recolorSecondVariant = 0; StringBuilder recolorFirstVariantCoordinate = new StringBuilder(); StringBuilder recolorSecondVariantCoordinate = new StringBuilder(); for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { // 1 вариант перекраски if ((i+j) % 2 == 0 && data[i][j] == 'B') { recolorFirstVariant++; recolorFirstVariantCoordinate.append(i+1).append(" ").append(j+1).append("\r\n"); } else if ((i+j) % 2 == 1 && data[i][j] == 'W') { recolorFirstVariant++; recolorFirstVariantCoordinate.append(i+1).append(" ").append(j+1).append("\r\n"); } // 2 вариант перекраски if ((i+j) % 2 == 0 && data[i][j] == 'W') { recolorSecondVariant++; recolorSecondVariantCoordinate.append(i+1).append(" ").append(j+1).append("\r\n"); } else if ((i+j) % 2 == 1 && data[i][j] == 'B') { recolorSecondVariant++; recolorSecondVariantCoordinate.append(i+1).append(" ").append(j+1).append("\r\n"); } } } PrintWriter out = new PrintWriter(System.out); if (recolorFirstVariant <= recolorSecondVariant) { out.println(recolorFirstVariant); out.println(recolorFirstVariantCoordinate); } else { out.println(recolorSecondVariant); out.println(recolorSecondVariantCoordinate); } out.flush(); } } ================================================ FILE: chess_workshop/README.md ================================================

Экономия (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Хозяин мастерской по изготовлению шахматных досок гроссмейстер Хосе Раулевич Капабланка был очень зол. «Ну, кто так раскрашивает доски?! Ну скажи мне, Бобби, разве я тебя так учил раскрашивать доски?!» - спрашивал он у своего подмастерья.

А дело было вот в чем. Недавно его мастерская получила заказ на изготовление нестандартной шахматной доски размером N на M . Саму шахматную доску из дорогой породы дерева он изготовил, а раскрасить ее поля он поручил своему подмастерью и ученику Бобби. Бобби, однако, справился с этой задачей очень плохо. Он раскрасил доску так, что некоторые соседние поля оказались покрашенными в один цвет. А такого на шахматной доске никогда не было, и быть не может!

Теперь у Бобби есть всего одна ночь на исправление своей ошибки. Казалось бы, времени много. Но все усложняется тем, что перекрасить поле шахматной доски достаточно сложная задача, ведь надо аккуратно снять старый слой краски. Поэтому Бобби хочет перекрасить наименьшее возможное число полей. Помогите ему написать программу, которая найдет: какие поля доски ему надо перекрасить.

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

Соседними полями на шахматной доске Хосе Раулевич считает поля, имеющие общую сторону.

Формат ввода

Первая строка входного файла INPUT.TXT содержит два целых числа: N и M (1 ≤ N, M ≤ 100). Далее идут N строк по M символов в каждой. j-ый символ i-ой из этих строк равен W, если Бобби покрасил соответствующее (т.е. находящееся на пересечении i-ой горизонтали и j-ой вертикали) поле в белый цвет, и B, если в черный.

Формат вывода

В первой строке выходного файла OUTPUT.TXT выведите минимальное количество k полей, которые должен перекрасить Бобби.

Далее выведите k строк, описывающих поля, которые он должен перекрасить. Описание каждого поля должно состоять из двух чисел: i и j (1 ≤ i ≤ N, 1 ≤ j ≤ M), задающих горизонталь и вертикаль, на пересечении которых находится данное поле.

Ни одно поле не должно быть указано в этом списке дважды. Может оказаться так, что k = 0, и Хосе Раулевич зря кричал на Бобби. Впрочем, это объясняется тем, что гроссмейстер уже весьма стар и его зрение далеко не идеально.

Примеры

Ввод Вывод
4 4
BBBB
BBBB
BBBB
BBBB		 8
1 1
1 3
2 2
2 4
3 1
3 3
4 2
4 4
3 3
WBW
BWB
WBW		 0
================================================ FILE: chessboard/Chessboard.java ================================================ package chessboard; import java.util.*; import java.io.*; public class Chessboard { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } public static void main(String[] argv) throws IOException{ getData(); int widht = data.get(0); // Ширина поля int height = data.get(1); // Высота поля int x = data.get(2); // 1 координата точки int y = data.get(3); // 2 координата точки int color = data.get(4); // Цвет точки String result = (widht % 2 == 0 || (widht % 2 == 1 && height % 2 == 0)) ? "equal" : (color == 0 && (x % 2 == y % 2)) ? "black" : (color == 1 && (x % 2 == y % 2)) ? "white" : (color == 0 && (x % 2 != y % 2)) ? "white" : "black"; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: chessboard/README.md ================================================

Шахматная доска - 2 (18%)

Время: 1 сек.
Память: 16 Мб
Сложность: 18%

Аня разделила доску размера m × n на клетки размера 1×1 и раскрасила их в черный и белый цвет в шахматном порядке. Васю заинтересовал вопрос: клеток какого цвета получилось больше – черного или белого.

Для того чтобы выяснить это, он спросил у Ани, в какой цвет она раскрасила j-ю клетку в i-м ряду доски. По этой информации Вася попытался определить, клеток какого цвета на доске больше.

Требуется написать программу, которая по размерам доски и цвету j-й клетки в i-м ряду определит, клеток какого цвета на доске больше — черного или белого.

Формат ввода

Входной файл input.txt содержит пять целых чисел: m, n, i, j и c (1 ≤ m, n ≤ 109, 1 ≤ i ≤ m, 1 ≤ j ≤ n, с = 0 или с = 1). Значение c = 0 означает, что j-я клетка в i-м ряду доски раскрашена в черный цвет, а значение c = 1 – в белый цвет.

Формат вывода

В выходной файл output.txt выведите одно из трех слов:

  • black, если черных клеток на доске больше,
  • white, если белых клеток на доске больше,
  • equal, если черных и белых клеток на доске поровну.

Примеры

Ввод Вывод
3 5 1 1 0 black
3 5 2 1 0 white
4 4 1 1 1 equal
================================================ FILE: chessboard_figure/ChessboardFigure.java ================================================ package chessboard_figure; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class ChessboardFigure { private static int perimeter(ArrayList data, int[][] chessboard, int cellCount){ int perimeter = 0; for(int i = 0; i < cellCount; i++){ for(int j = 0; j < cellCount; j++){ if(chessboard[i][j] == 1){ if(i == 0){ perimeter++; } if(i == cellCount-1){ perimeter++; } if(i-1 >= 0 && chessboard[i-1][j] == 0){ perimeter++; } if(i+1 < cellCount && chessboard[i+1][j] == 0){ perimeter++; } if(j == 0){ perimeter ++; } if(j == cellCount - 1){ perimeter++; } if(j-1 >= 0 && chessboard[i][j-1] == 0){ perimeter++; } if(j+1 < cellCount && chessboard[i][j+1] == 0){ perimeter++; } } } } return perimeter; } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); ArrayList data = new ArrayList<>(); int index = 0; while (sc.hasNextLine()){ if(index != 0){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); data.add(new int[]{Integer.valueOf(st.nextToken()), Integer.valueOf(st.nextToken())}); }else { sc.nextLine(); } index++; } int cellCount = 8; int[][] chessboard = new int[cellCount][cellCount]; for (int[] aData : data) { int one = aData[0]-1; int two = aData[1]-1; for (int i = 0; i < cellCount; i++) { for (int j = 0; j < cellCount; j++) { if (i == one && j == two && chessboard[i][j] == 0) { chessboard[i][j] = 1; } } } } int perimeter = perimeter(data, chessboard, cellCount); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(perimeter)); out.close(); } } ================================================ FILE: chessboard_figure/README.md ================================================

Шахматная доска (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Из шахматной доски по границам клеток выпилили связную (не распадающуюся на части) фигуру без дыр. Требуется определить ее периметр.

Формат ввода

Во входном файле input.txt сначала записано число N (1 ≤ N ≤ 64) – количество выпиленных клеток. В следующих N строках указаны координаты выпиленных клеток, разделенные пробелом (номер строки и столбца – числа от 1 до 8). Каждая выпиленная клетка указывается один раз.

Формат вывода

В выходной файл output.txt выведите одно число – периметр выпиленной фигуры (сторона клетки равна единице).

Примеры

Ввод Вывод
3
1 1
1 2
2 1		 8
1
8 8		 4
================================================ FILE: chest_of_billy_bones/ChestOfBillyBones.java ================================================ package chest_of_billy_bones; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class ChestOfBillyBones { public static void main(String[] args) throws IOException { String[] line = new Scanner(new FileReader("input.txt")).nextLine().split(" "); int x = Integer.parseInt(line[0]); int y = Integer.parseInt(line[1]); int[] result = new int[x]; for (int second = 0; second < y - second; second++) { for (int first = second+1; first <= y - second; first++) { result[0] = first; result[1] = second; for (int i = 2; i < x; i++) { result[i] = result[i-1] + result[i-2]; } if (result[x-1] == y) { PrintWriter out = new PrintWriter(System.out); out.println(first + " " + second); out.flush(); return; } } } } } ================================================ FILE: chest_of_billy_bones/README.md ================================================

Сундук Билли Бонса (33%)

Ссылка на задачу

Разбор

Время: 0.5 сек.
Память: 16 Мб
Сложность: 33%

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

Требуется написать программу, которая определит, сколько монет было в сундуке в первый и во второй года, если в X-м году там оказалось ровно Y монет.

Формат ввода

Входной файл INPUT.TXT содержит натуральные числа X и Y (3 ≤ X ≤ 20, 1 ≤ Y ≤ 32767).

Формат вывода

В выходной файл OUTPUT.TXT выведите через пробел количество монет в первый и второй года. Гарантируется, что решение задачи всегда существует.

Примеры

Ввод Вывод
6 25 5 2
================================================ FILE: circle/Circle.java ================================================ package circle; import java.io.*; import java.util.*; public class Circle { public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); char[] ch = str.toCharArray(); long flag = 0; for (char aCh : ch) { String symbol = Character.toString(aCh); switch (symbol) { case ("6"): flag++; break; case ("8"): flag = flag + 2; break; case ("9"): flag++; break; case ("0"): flag++; break; } } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(flag)); fileOut.close(); } } ================================================ FILE: circle/README.md ================================================

Кругляши (16%)

Время: 1 сек.
Память: 16 Мб
Сложность: 16%

Однажды в просторах рунета появился следующий ребус:

  • 157892 = 3
  • 203516 = 2
  • 409578 = 4
  • 236271 = ?

Никто так и не смог его разгадать. Позже оказалось, что число в правом столбце равно сумме "кругляшей", которые есть в цифрах числа, расположенного слева. Ваша задача написать программу, которая определяет, сколько кругляшей в числе.

Формат ввода

Во входном файле input.txt записано целое число N (0 ≤ N ≤ 10100).

Формат вывода

В выходной файл output.txt выведите одно число – количество кругляшей в числе N.

Примеры

Ввод Вывод
157892 3
203516 2
409578 4
236271 1
================================================ FILE: circle_two/CircleTwo.java ================================================ package circle_two; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class CircleTwo { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int data = sc.nextInt(); int result = data == 0 ? 1 : 2 + (data - 1) * data; FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: circle_two/README.md ================================================

Окружности (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

На какое максимальное число областей можно разбить плоскость при помощи N окружностей одинакового радиуса?

Формат ввода

Входной файл input.txt содержит целое число N – количество окружностей, 0 ≤ N ≤ 33333.

Формат вывода

В выходной файл output.txt выведите одно число – максимальное количество областей, на которое можно разбить плоскость при помощи N окружностей одинакового радиуса.

Примеры

Ввод Вывод
0 1
3 8
================================================ FILE: clock/Clock.java ================================================ package clock; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Map; import java.util.Scanner; import java.util.TreeMap; public class Clock { // Результирующий Map private static Map result = new TreeMap<>(); /** * Подсчет количества цифр * @param number число, в котором считаем цифры * */ private static void countNumbers(String number) { if (number.length() < 2) { addChar('0'); } char[] chars = number.toCharArray(); for (char symbol : chars) { addChar(symbol); } } /** * Посчитать символ * @param number символ, который надо учесть * */ private static void addChar(char number) { int count = 1; if (result.containsKey(number)) { count = result.get(number) + count; } result.put(number, count); } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int[] start = new int[3]; int[] finish = new int[3]; int line = 0; while (sc.hasNextLine()) { String[] parts = sc.nextLine().split(":"); for (int i = 0; i < parts.length; i++) { if (line == 0) { start[i] = Integer.parseInt(parts[i]); } else { finish[i] = Integer.parseInt(parts[i]); } } line++; } // Расчет разницы во времени int hours = start[0]; int minutes = start[1]; int seconds = start[2]; while ((hours < finish[0]) || (hours <= finish[0]) && minutes < finish[1] || (hours <= finish[0] && minutes <= finish[1] && seconds < finish[2])) { countNumbers(String.valueOf(hours)); countNumbers(String.valueOf(minutes)); countNumbers(String.valueOf(seconds)); seconds++; if (seconds >= 60) { seconds = 0; minutes++; } if (minutes >= 60) { minutes = 0; hours++; } } countNumbers(String.valueOf(hours)); countNumbers(String.valueOf(minutes)); countNumbers(String.valueOf(seconds)); PrintWriter out = new PrintWriter(System.out); for (char i = '0'; i <= '9'; i++) { if (result.containsKey(i)) { out.println(result.get(i)); } else { out.println('0'); } } out.flush(); } } ================================================ FILE: clock/README.md ================================================

Часы (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Петя очень любит наблюдать за электронными часами. Он целыми днями смотрел на часы и считал, сколько раз встречается каждая цифра. Через несколько месяцев он научился по любому промежутку времени говорить, сколько раз на часах за это время встретится каждая цифра, и очень гордился этим.

Вася решил проверить Петю, но он не знает, как это сделать. Вася попросил Вас помочь ему. Напишите программу, решающую эту задачу.

Формат ввода

Первая и вторая строки входного файла input.tx содержат начало и конец промежутка времени соответственно. Начальное время не превосходит конечное. Время задается в формате hh:mm:ss (0 ≤ hh < 24, 0 ≤ mm < 60, 0 ≤ ss < 60). hh, mm, ss дополнены ведущими нулями до двух символов. Эти нули также учитываются при подсчете числа цифр.

Формат вывода

Выходной файл output.txt должен содержать 10 строк. В i-ой строке должно быть написано, сколько раз встречается цифра i-1.

Примеры

Ввод Вывод
23:59:58
23:59:59		 0
0
2
2
0
4
0
0
1
3
13:24:09
13:24:40		 5
45
45
45
36
3
3
3
3
4
================================================ FILE: clock_fight/ClockFight.java ================================================ package clock_fight; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; import java.util.StringTokenizer; public class ClockFight { public static void main(String[] args) throws IOException { int hourStart = 0, minuteStart = 0, hourFinish = 0, minuteFinish = 0; Scanner sc = new Scanner(new FileReader("input.txt")); int index = 0; while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); if(index == 0){ hourStart = Integer.valueOf(st.nextToken()); minuteStart = Integer.valueOf(st.nextToken()); }else { hourFinish = Integer.valueOf(st.nextToken()); minuteFinish = Integer.valueOf(st.nextToken()); } index++; } int hourCount = 0; int strokesCount = 0; int stroke = hourStart; while (true){ if(hourStart == hourFinish && minuteStart < minuteFinish){ break; } hourCount++; hourStart++; stroke++; if(hourStart == 25){ hourStart = 1; stroke = 1; } if(stroke > 12){ stroke -= 12; } strokesCount += stroke; if(hourStart == hourFinish){ break; } } if(minuteStart > 30){ hourCount--; } if(minuteFinish > 30){ hourCount++; } int result = strokesCount + hourCount; FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: clock_fight/README.md ================================================

Часы с боем (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Старинные часы бьют каждые полчаса. Причем в начале каждого часа они бьют столько раз, сколько сейчас часов (по 1 разу – в час ночи и в час дня, по 2 раза – в два часа ночи в два часа дня и т.д., в полночь и в полдень они бьют, соответственно, по 12 раз). И еще 1 раз они бьют в середине каждого часа.

Дан промежуток времени (известно, что прошло строго меньше 24 часов). Напишите программу, определяющую, сколько ударов сделали часы за это время.

Формат ввода

В первой строке входного файла input.txt записан начальный момент времени, во второй строке — конечный. Моменты времени задаются двумя целыми числами, разделяющимися пробелом. Первое число задает часы (от 0 до 23), второе — минуты (от 1 до 59, при этом оно не равно 30).

Формат вывода

В выходной файл output.txt выведите одно число — сколько ударов сделали часы за этот отрезок времени.

Примеры

Ввод Вывод
5 20
10 25		 45
10 25
5 20		 135
5 2
5 21		 0
================================================ FILE: clothes/Clothes.java ================================================ package clothes; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; import java.util.stream.Collectors; public class Clothes { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); Map people = new TreeMap<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } data.remove(0); for(Integer color : data){ int count = 1; if (people.containsKey(color)){ count = people.get(color); count++; } people.put(color, count); } List> list = people.entrySet().stream() // Сортировка в map по значению .sorted((v1, v2) -> v1.getValue().compareTo(v2.getValue())) .collect(Collectors.toList()); int max = list.get(list.size()-1).getValue(); int prev = list.size() > 1 ? list.get(list.size()-2).getValue() : 0; int result = max == prev ? 0 : list.get(list.size()-1).getKey(); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: clothes/README.md ================================================

Одежда (24%)

Время: 1 сек.
Память: 16 Мб
Сложность: 24%

Несмотря на небольшую площадь, территорию Волшебной страны населяет множество народов, различных по культуре и внешнему облику, но говорящих на одном языке. Каждый народ предпочитает носить одежду определённого цвета, который отличается от цвета одежды других народов. Народы имеют разные традиции, порой традиции одних народов противоречат традициям других народов. Поэтому жители каждого города следуют традициям того народа, представителей которого проживает в этом городе больше всего. Если оказывается, что таких народов несколько, все жители города следуют традициям самого миролюбивого народа с белым цветом одежды (белый цвет обозначается нулём).

Путешественник стоит на высоком холме недалеко от входа в город. С этого холма он видит цвет одежды каждого жителя города. Путешественник торопится войти в город, ему важно быстро определить, традициям какого народа следовать в этом городе.

Формат ввода

Первая строка входного файла input.txt содержит число N - количество жителей города, которых видит путешественник (1 ≤ N ≤ 104). Вторая строка теста содержит N натуральных чисел, разделенных пробелами. Каждое число сi – это цвет одежды i-го жителя (1 ≤ ci ≤ 100).

Формат вывода

В выходной файл output.txt выведите единственное целое число – цвет одежды народа, традициям которого следуют жители города.

Примеры

Ввод Вывод
6
1 2 5 2 1 2		 2
4
5 5 4 4		 0
================================================ FILE: coin/Coin.java ================================================ package coin; import java.io.*; import java.util.*; public class Coin { public static void main(String[] args) throws IOException { ArrayList coinsAll = new ArrayList<>(); int zero = 0, one = 0; int out; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); while (sc.hasNextLine()){ str = sc.nextLine(); coinsAll.add(Integer.valueOf(str)); } for(int i = 0; i < coinsAll.size(); i++){ // Считаем нули и единицы if(i > 0){ // Пропускаем 1 число из файла if(coinsAll.get(i) == 0){ zero++; }else { one++; } } } if(zero < one){ // Каких монет меньше out = zero; }else if(one < zero){ out = one; }else{ out = one; } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(out)); fileOut.close(); } } ================================================ FILE: coin/README.md ================================================

Монетки (8%)

Время: 1 сек.
Память: 16 Мб
Сложность: 8%

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

Формат ввода

В первой строке входного файла input.txt записано натуральное число N (1 ≤ N ≤ 100) – число монеток. В каждой из последующих N строк содержится одно целое число – 1 если монетка лежит решкой вверх и 0 если вверх гербом.

Формат вывода

В выходной файл output.txt выведите минимальное количество монет, которые нужно перевернуть.

Примеры

Ввод Вывод
5
1
0
1
1
0		 2
================================================ FILE: coin_two/CoinTwo.java ================================================ package coin_two; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; import java.util.StringTokenizer; public class CoinTwo { public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner scan = new Scanner(file); StringTokenizer st = new StringTokenizer(scan.nextLine(), " "); long n = Integer.valueOf(st.nextToken()); long w = Integer.valueOf(st.nextToken()); long d = Integer.valueOf(st.nextToken()); long p = Long.valueOf(st.nextToken()); long numberBasket = 0; int rightWeight = 0; for(int i = 1; i < n; i++){ rightWeight += (w * i); } numberBasket = rightWeight == p ? n : (rightWeight - p) / d; FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(numberBasket)); out.close(); } } ================================================ FILE: coin_two/README.md ================================================

Монеты - 2 (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

В N корзинах находятся золотые монеты. Корзины пронумерованы числами от 1 до N. Во всех корзинах, кроме одной, монеты весят по w граммов. В одной корзине монеты фальшивые и весят w–d граммов. Волшебник берет 1 монету из первой корзины, 2 монеты из второй корзины, и так далее, и, наконец, N-1 монету из (N-1)-й корзины. Из N-й корзины он не берет ничего. Он взвешивает взятые монеты и сразу указывает на корзину с фальшивыми монетами.

Требуется написать программу, которая выполняет это волшебство.

Формат ввода

Входной файл input.txt содержит четыре целых числа: N, w, d и P – суммарного веса отобранных монет (2 ≤ N ≤ 8000, 1 ≤ d < w ≤ 30).

Формат вывода

В выходной файл output.txt выведите номер корзины с фальшивыми монетами.

Примеры

Ввод Вывод
10 25 8 1109 2
10 25 8 1125 10
8000 30 12 959879400 50
================================================ FILE: colored_rain/ColoredRain.java ================================================ package colored_rain; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; import java.util.StringTokenizer; public class ColoredRain { public static void main(String[] args) throws IOException { int[][] matrix = new int[0][]; int[] color = new int[0]; int row = -1; Scanner sc = new Scanner(new FileReader("input.txt")); int rowCount = 0; while (sc.hasNextLine()){ if(row == -1){ rowCount = Integer.valueOf(sc.nextLine()); matrix = new int[rowCount][rowCount]; }else if(row >= 0 && row < rowCount){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); int column = 0; while (st.hasMoreTokens()){ matrix[row][column] = Integer.valueOf(st.nextToken()); column++; } }else { StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); int column = 0; color = new int[rowCount]; while (st.hasMoreTokens()){ color[column] = Integer.valueOf(st.nextToken()); column++; } } row++; } int bad = 0; for(int i = 0; i< rowCount; i++){ for(int j = i; j < rowCount; j++){ if(matrix[i][j] == 1){ if(color[i] != color[j]){ bad++; } } } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(bad)); out.close(); } } ================================================ FILE: colored_rain/README.md ================================================

Цветной дождь (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

В Банановой республике очень много холмов, соединенных мостами. На химическом заводе произошла авария, в результате чего испарилось экспериментальное удобрение "зован". На следующий день выпал цветной дождь, причем он прошел только над холмами. В некоторых местах падали красные капли, в некоторых - синие, а в остальных - зеленые, в результате чего холмы стали соответствующего цвета. Президенту Банановой республики это понравилось, но ему захотелось покрасить мосты между вершинами холмов так, чтобы мосты были покрашены в цвет холмов, которые они соединяют. К сожалению, если холмы разного цвета, то покрасить мост таким образом не удастся. Посчитайте количество таких "плохих" мостов.

Формат ввода

В файле input.txt в первой строке записано N (0 < N ≤ 100) - число холмов. Далее идет матрица смежности, описывающая наличие мостов между холмами (1-мост есть, 0-нет). Предпоследняя строка пустая, а в последней строке записано N чисел, обозначающих цвет холмов: 1 - красный; 2 - синий; 3 - зеленый.

Формат вывода

В файл output.txt вывести количество "плохих" мостов.

Примеры

Ввод Вывод
7
0 1 0 0 0 1 1
1 0 1 0 0 0 0
0 1 0 0 1 1 0
0 0 0 0 0 0 0
0 0 1 0 0 1 0
1 0 1 0 1 0 0
1 0 0 0 0 0 0
 
1 1 1 1 1 3 3		 4
================================================ FILE: coloring_multiplication_tables/ColoringMultiplicationTables.java ================================================ package coloring_multiplication_tables; import java.util.*; import java.io.*; public class ColoringMultiplicationTables { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } private static int[] color(int n, int m){ // Раскрашиваем данные int blue = 0; int green = 0; int red = 0; int black = 0; for(int i = 1; i <= n; i++){ for(int j = 1; j <= m; j++){ if(i * j % 5 == 0){ blue++; }else if(i * j % 3 == 0){ green++; }else if(i * j % 2 == 0){ red++; }else { black++; } } } return new int[]{red, green, blue, black}; } public static void main(String[] argv) throws IOException{ getData(); String[] colorName = {"RED", "GREEN", "BLUE", "BLACK"}; StringBuilder result = new StringBuilder(); int n = data.get(0); int m = data.get(1); int color[] = color(n, m); for(int i = 0; i < colorName.length; i++){ // Формируем строку result.append(colorName[i]).append(" : ").append(color[i]).append("\n"); } PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: coloring_multiplication_tables/README.md ================================================

Раскраска таблицы умножения (22%)

Время: 1 сек.
Память: 16 Мб
Сложность: 22%

(Время: 1 сек. Память: 16 Мб Сложность: 22%)

Таблицей умножения назовем таблицу размера n строк на m столбцов, в которой на пересечении i-ой строки и j-ого столбца стоит число i∙j (строки и столбцы нумеруются с единицы).

В одной из математических школ было решено провести педагогический эксперимент. Для того, чтобы ученикам было проще запоминать таблицу умножения, некоторые числа в ней будут покрашены в красный, некоторые - в синий, а некоторые - в зеленый цвет (оставшиеся числа будут черными).

Процесс покраски чисел можно условно разбить на четыре этапа. На первом этапе все числа красятся в черный цвет. На втором - все четные числа красятся в красный цвет, на третьем – все числа, делящиеся на 3, красятся в зеленый цвет, на четвертом - все числа, делящиеся на 5, красятся в синий цвет.

Директор школы хочет знать, какое количество картриджей для принтеров необходимо закупить для печати таблиц. Поэтому ему необходима информация о том, сколько чисел какого цвета будет в одной раскрашенной таблице умножения n на m. Напишите программу, решающую задачу подсчета соответствующих количеств.

Формат ввода

Входной файл input.txt содержит два натуральных числа n и m (1 ≤ n,m ≤ 1000).

Формат вывода

В первой строке выходного файла output.txt выведите количество чисел, покрашенных в красный цвет, во второй - в зеленый, в третьей - в синий, в четвертой - в черный. Следуйте формату, приведенному в примерах.

Примеры

Ввод Вывод
10 10 RED : 21
GREEN : 39
BLUE : 36
BLACK : 4
5 2 RED : 5
GREEN : 2
BLUE : 2
BLACK : 1
================================================ FILE: community_of_robots/CommunityOfRobots.java ================================================ package community_of_robots; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayDeque; import java.util.Scanner; public class CommunityOfRobots { private static final int ROBOT_COUNT_FOR_GROUP_THREE = 5; private static final int ROBOT_COUNT_FOR_GROUP_FIVE = 9; private static long _robotMaxCount(long robotCountStart) { long fiveGroup = robotCountStart / 5; long threeGroup = (robotCountStart - (fiveGroup * 5)) / 3; long result = threeGroup * ROBOT_COUNT_FOR_GROUP_THREE + fiveGroup * ROBOT_COUNT_FOR_GROUP_FIVE; // максимальное количество групп по 5 while (true) { boolean threePow = (robotCountStart - fiveGroup * 5 ) % 3 == 0; if (threePow) { // если есть группы по 5 и по 3 threeGroup = (robotCountStart - fiveGroup * 5) / 3; long resultTmp = threeGroup * ROBOT_COUNT_FOR_GROUP_THREE + fiveGroup * ROBOT_COUNT_FOR_GROUP_FIVE; if (result < resultTmp) { result = resultTmp; } break; } else { fiveGroup -= 1; } if (fiveGroup < 0) { break; } } threeGroup = robotCountStart / 3; // максимальное количество групп по 3 long resultTmp = threeGroup * ROBOT_COUNT_FOR_GROUP_THREE; if (result < resultTmp) { result = resultTmp; } return result; } public static void main(String[] args) throws IOException { String[] data = new Scanner(new FileReader("input.txt")).nextLine().split(" "); long k = Long.parseLong(data[0]); int n = Integer.parseInt(data[1]); long robotCount = k; ArrayDeque process = new ArrayDeque<>(); process.addLast(k); for (int i = 1; i <= n; i++) { // удаление роботов с 3го года if (i > 3) { robotCount -= process.removeFirst(); } // последний год if (i == n) { break; } long count = _robotMaxCount(robotCount); robotCount += count; process.addLast(count); } PrintWriter out = new PrintWriter(System.out); out.println(robotCount); out.flush(); } } ================================================ FILE: community_of_robots/README.md ================================================

Сообщество роботов (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

Сообщество роботов живет по следующим законам:

  • один раз в начале года они объединяются в группы по три или пять роботов;
  • за год группа из трех роботов собирает 5 новых, а группа из 5 роботов – 9 новых;
  • роботы объединяются так, чтобы собрать за год наибольшее количество новых роботов;
  • каждый робот живет ровно три года после сборки.

В начале первого года было K роботов и все они были только что собраны.

Требуется написать программу, которая найдет количество роботов в начале N-го года.

Формат ввода

Входной файл INPUT.TXT содержит записанные через пробел числа K (1 ≤ K ≤ 500) и N (1 ≤ N ≤ 100).

Формат вывода

Выходной файл OUTPUT.TXT должен содержать одно число - количество роботов в начале N-го года. Количество роботов меньше, чем 231.

Примеры

Ввод Вывод
3 2 8
8 2 22
================================================ FILE: component/Component.java ================================================ package component; import java.util.*; import java.io.*; public class Component { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); int numberLine = 0; while (sc.hasNextLine()){ numberLine++; String str = sc.nextLine(); char[] ch = str.toCharArray(); int k = 0; for (char aCh : ch) { String symbol = String.valueOf(aCh); if (symbol.equals(".")) { k++; } } if(numberLine != 1){ data.add(k); } } } public static void main(String[] argv) throws IOException{ getData(); Collections.sort(data); String cellCount = String.valueOf(data.get(0)); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(cellCount); pw.close(); } } ================================================ FILE: component/README.md ================================================

Детали (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

На клеточном поле N•M расположены две жёсткие детали. Деталь A накрывает в каждой строке несколько (не ноль) первых клеток, деталь B — несколько (не ноль) последних; каждая клетка либо полностью накрыта одной из деталей, либо нет.

Деталь B начинают двигать влево, не поворачивая, пока она не упрётся в A хотя бы одной клеткой. Определите, на сколько клеток будет сдвинута деталь B.

Формат ввода

В первой строке входного файла input.txt записано два числа N и M — число строк и столбцов соответственно (1 ≤ N, M ≤ 100). Далее следуют N строк, задающих расположение деталей. В каждой находится ровно M символов "A" (клетка, накрытая деталью A), "B" (накрытая деталью B) или "." (свободная клетка).

Формат вывода

В единственную строку выходного файла output.txt нужно вывести одно число — ответ на задачу.

Примеры

Ввод Вывод
4 6
AA.BBB
A....B
AAA..B
A..BBB		 1
================================================ FILE: compression_binary_sequences/CompressionBinarySequences.java ================================================ package compression_binary_sequences; import java.util.*; import java.io.*; public class CompressionBinarySequences { private static ArrayList symbols = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); char[] ch = str.toCharArray(); for (char aCh : ch) { String st = String.valueOf(aCh); if (st.equals("1") || st.equals("0")) { symbols.add(st); } } } public static void main(String[] argv) throws IOException{ char[] abc = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'}; getData(); int k = 0; // Счетчик количества нулей перед 1 StringBuilder code = new StringBuilder(); // Итоговая строка for (String symbol : symbols) { if (symbol.equals("1")) { code.append(String.valueOf(abc[k])); // Добавить к строке букву k = 0; } else { k++; } } PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(code); pw.close(); } } ================================================ FILE: compression_binary_sequences/README.md ================================================

Сжатие бинарных последовательностей (19%)

Время: 1 сек.
Память: 16 Мб
Сложность: 19%

Последовательность из символов «0» и «1» называется бинарной. Они широко применяются в информатике и других науках. Одно из неудобств бинарных последовательностей – их трудно запоминать. Для решения этой проблемы были предложены разные способы их сжатия. Программист Слава использует следующий способ: просматривая последовательность слева направо, он заменяет «1» на «a», «01» на «b», «001» на «c», …, «00000000000000000000000001» на «z». Напишите программу, которая поможет Славе автоматизировать этот способ сжатия.

Формат ввода

Входной файл input.txt содержит бинарную последовательность – строку из символов «0» и «1» длиной не более 255 символов. Гарантируется, что к ней применим указанный способ сжатия.

Формат вывода

В выходной файл output.txt выведите одну строку из английских строчных букв от «a» до «z» – сжатие заданной бинарной последовательности.

Примеры

Ввод Вывод
101 ab
101001 abc
0000000000000000000000001 y
================================================ FILE: conditioner/Conditioner.java ================================================ package conditioner; import java.io.*; import java.util.*; public class Conditioner { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); String mode; String str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(st.nextToken()); } } int tempNow = Integer.valueOf(data.get(0)); // Температура сейчас int tempWant = Integer.valueOf(data.get(1)); // Желаемая температура mode = (data.get(2).equals("fan")) ? data.get(0) : // Проверка всех условий (data.get(2).equals("heat") && tempNow < tempWant) ? String.valueOf(tempWant) : (data.get(2).equals("heat") && tempNow > tempWant) ? String.valueOf(tempNow) : (data.get(2).equals("freeze") && tempNow < tempWant) ? String.valueOf(tempNow) : (data.get(2).equals("freeze") && tempNow > tempWant) ? String.valueOf(tempWant) : String.valueOf(tempWant); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(mode); fileOut.close(); } } ================================================ FILE: conditioner/README.md ================================================

Кондиционер (12%)

Время: 1 сек.
Память: 16 Мб
Сложность: 12%

В офисе, где работает программист Петр, установили кондиционер нового типа. Этот кондиционер отличается особой простотой в управлении. У кондиционера есть всего лишь два управляемых параметра: желаемая температура и режим работы.

Кондиционер может работать в следующих четырех режимах:

  • «freeze» — охлаждение. В этом режиме кондиционер может только уменьшать температуру. Если температура в комнате и так не больше желаемой, то он выключается.
  • «heat» — нагрев. В этом режиме кондиционер может только увеличивать температуру. Если температура в комнате и так не меньше желаемой, то он выключается.
  • «auto» — автоматический режим. В этом режиме кондиционер может как увеличивать, так и уменьшать температуру в комнате до желаемой.
  • «fan» — вентиляция. В этом режиме кондиционер осуществляет только вентиляцию воздуха и не изменяет температуру в комнате.

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

Требуется написать программу, которая по заданной температуре в комнате troom, установленным на кондиционере желаемой температуре tcond и режиму работы определяет температуру, которая установится в комнате через час.

Формат ввода

Первая строка входного файла input.txt содержит два целых числа troom и tcond, разделенных ровно одним пробелом (–50 ≤ troom ≤ 50, –50 ≤ tcond ≤ 50).

Вторая строка содержит одно слово, записанное строчными буквами английского алфавита — режим работы кондиционера, как указано выше.

Формат вывода

Выходной файл output.txt должен содержать одно целое число — температуру, которая установится в комнате через час.

Примеры

Ввод Вывод
10 20
heat		 20
10 20
freeze		 10
================================================ FILE: constant_kaprekar/ConstantKaprekar.java ================================================ package constant_kaprekar; import java.util.*; import java.io.*; public class ConstantKaprekar { private static int data; private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); data = sc.nextInt(); } private static int[] numberChange(int data){ // Вычисление максималного и минимального числа int max, min; ArrayList number = new ArrayList<>(); char[] ch = String.valueOf(data).toCharArray(); for (char aCh : ch) { number.add(aCh - '0'); } Collections.sort(number); // Минимальное число StringBuilder strMin = new StringBuilder(); for(int i = 0; i < 4; i++){ if(i < number.size()){ strMin.append(number.get(i)); } } min = Integer.valueOf(String.valueOf(strMin)); number.sort(Collections.reverseOrder()); // Максимальное число StringBuilder strMax = new StringBuilder(); for(int i = 0; i < 4; i++){ if(i < number.size()){ strMax.append(number.get(i)); }else { strMax.append("0"); } } max = Integer.valueOf(String.valueOf(strMax)); return new int[]{max, min}; } public static void main(String[] argv) throws IOException{ getData(); int[] numberMaxMin = numberChange(data); int max = numberMaxMin[0]; int min = numberMaxMin [1]; int index = 0; // Кол-во итераций while (max - min != data) { // Пока не найдем нужное число data = max - min; numberMaxMin = numberChange(data); max = numberMaxMin[0]; min = numberMaxMin[1]; index++; } int Kaprekar = max - min; String result = Kaprekar + "\n" + index; System.out.println(result); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: constant_kaprekar/README.md ================================================

Постоянная Капрекара (22%)

Время: 1 сек.
Память: 16 Мб
Сложность: 22%

(Время: 1 сек. Память: 16 Мб Сложность: 22%)

Возьмем четырехзначное число, в котором не все цифры одинаковы, например 6264. Расположим цифры сначала в порядке убывания - 6642; затем, переставив их в обратном порядке, получим 2466. Вычтем последнее число из 6642. На следующем шаге с полученной разностью проделаем тоже самое. Через несколько таких действий получится число, переходящее само в себя и называемое постоянной Капрекара.

Требуется написать программу, которая находит эту постоянную и количество шагов для ее получения из заданного четырехзначного числа.

Формат ввода

Входной файл input.txt содержит одну строку, в которой записано четырехзначное число.

Формат вывода

В выходной файл output.txt записываются: в первой строке постоянная Капрекара, во второй – количество шагов для ее получения.

Примеры

Ввод Вывод
1234 6174
3
================================================ FILE: construction_of_roads/ConstructionOfRoads.java ================================================ package construction_of_roads; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class ConstructionOfRoads { public static void main(String[] args) throws IOException { int n = Integer.parseInt(new Scanner(new FileReader("input.txt")).nextLine()); PrintWriter out = new PrintWriter(System.out); BigInteger res = BigInteger.valueOf(3).pow((n*(n-1))/2); out.println(res); out.flush(); } } ================================================ FILE: construction_of_roads/README.md ================================================

Постройка дорог (33%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 33%

В известном городе Кызылорда, где находятся N центров, живет некий граф - Азамат. Он желает узнать количество различных построек дорог между ними, если известно, что два центра могут быть связаны в одном из двух направлений или не связаны вообще. Например, при N=2 все получается 3 варианта:

  1. оба центра не связаны
  2. дорога идет из первого во второй центр
  3. дорога идет из второго в первый центр

Формат ввода

Во входном файле INPUT.TXT записано единственное натуральное число - количество центров в городе, 2 ≤ N ≤ 100.

Формат вывода

В единственную строку выходного файла OUTPUT.TXT нужно вывести число всевозможных построек дорог.

Примеры

Ввод Вывод
2 3
4 729
================================================ FILE: contest/Contest.java ================================================ package contest; import java.util.*; import java.io.*; public class Contest { private static ArrayList list = new ArrayList<>(); // Коллекция для построчного считывания данных private static ArrayList time = new ArrayList<>(); // Коллекция для хранения времени на решение задач private static int taskCountOne = 0, taskCountThree = 0, taskCountFive = 0; // Количество решенных задач private static int mistakeCountOne = 0, mistakeCountThree = 0, mistakeCountFive = 0; // Количество штрафного времени по каждому заданию private static int mistakeAllOne = 0, mistakeAllThree = 0, mistakeAllFive = 0; // Количество штрафного времени по каждому заданию private static int maxTime = 300; // Максимальная продолжительность соревнований private static void oneKurs(){ Collections.sort(time); int one = 0; for (Integer aTime : time) { // Расчет по первокурснику if (one >= 0) { one = maxTime - aTime; maxTime = one; taskCountOne++; mistakeCountOne += aTime; mistakeAllOne += mistakeCountOne; } else { break; } } } private static void threeKurs(){ Collections.reverse(time); int three = 0; for (Integer aTime : time) { // Расчет по третьекурснику if (three >= 0) { three = maxTime - aTime; maxTime = three; taskCountThree++; mistakeCountThree += aTime; mistakeAllThree += mistakeCountThree; } else { break; } } } private static void fiveKurs(){ int five = 0; for (Integer aTime : time) { // Расчет по пятикурснику if (five >= 0) { five = maxTime - aTime; maxTime = five; taskCountFive++; mistakeCountFive += aTime; mistakeAllFive += mistakeCountFive; } else { break; } } } private static void time(){ maxTime = 300; } public static void main(String[] args) throws IOException { String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); while(sc.hasNextLine()){ str = sc.nextLine(); list.add(str); } StringTokenizer st = new StringTokenizer(list.get(1), " "); while(st.hasMoreTokens()){ time.add(Integer.valueOf(st.nextToken())); } fiveKurs(); time(); threeKurs(); time(); oneKurs(); // Определение победителя String winner = (taskCountOne > taskCountThree && taskCountOne > taskCountFive) ? "1" : (taskCountThree > taskCountOne && taskCountThree > taskCountFive) ? "3" : "5"; if(taskCountOne == taskCountThree && taskCountOne > taskCountFive){ winner = (mistakeAllOne == mistakeAllThree) ? "1" : (mistakeAllOne > mistakeAllThree) ? "3" : "1"; }else if(taskCountOne == taskCountFive && taskCountOne > taskCountThree){ winner = (mistakeAllOne == mistakeAllFive) ? "1" : (mistakeAllOne > mistakeAllFive) ? "5" : "1"; }else if(taskCountThree == taskCountFive && taskCountThree > taskCountOne){ winner = (mistakeAllThree == mistakeAllFive) ? "3" : (mistakeAllThree > mistakeAllFive) ? "5" : "3"; }else{ if(taskCountOne == taskCountThree && taskCountOne == taskCountFive) { winner = (mistakeAllOne == mistakeAllThree && mistakeAllOne == mistakeAllFive) ? "1" : (mistakeAllOne == mistakeAllThree && mistakeAllOne < mistakeAllFive) ? "1" : (mistakeAllThree == mistakeCountFive && mistakeAllThree < mistakeAllOne) ? "3" : (mistakeAllOne == mistakeAllFive && mistakeAllOne < mistakeAllThree) ? "1" : (mistakeAllFive < mistakeAllThree && mistakeAllFive < mistakeAllOne) ? "5" : (mistakeAllThree < mistakeAllFive && mistakeAllThree < mistakeAllOne) ? "3" : "1"; } } FileWriter countStepFinish = new FileWriter("output.txt");// Запись числа в файл countStepFinish.write(winner); countStepFinish.close(); } } ================================================ FILE: contest/README.md ================================================

Олимпиада (2%)

Время: 1 сек.
Память: 16 Мб
Сложность: 2%

Трое студентов, пятикурсник, третьекурсник и первокурсник, живут в одной комнате общежития и любят участвовать в соревнованиях по программированию по правилам ACM. У каждого из них свой подход к решению задач. Пятикурсник решает все задачи строго по порядку - сначала первую, затем вторую, и так до последней. Третьекурсник решает задачи строго в обратном порядке – сначала последнюю, затем предпоследнюю, и так до первой. А первокурсник сначала решает самую простую задачу, затем – самую простую из оставшихся задач, и так до самой сложной. Сложность задачи определяется временем, необходимым для её решения. Для решения одной и той же задачи наши студенты тратят одинаковое количество времени.

Ваша задача – по описанию соревнований по программированию определить, кто из студентов победит. Напомним, что по правилам ACM побеждает участник, за 300 минут решивший больше всего задач, а при равенстве количества задач – набравший меньше штрафного времени.

Наши студенты – очень сильные программисты, и при решении задач они не делают неправильных попыток. Поэтому за задачу начисляется штраф в размере количества минут от начала соревнования до её посылки на проверку. Если же и количество штрафного времени совпадает – то студент со старшего курса уступает победу студенту с младшего курса.

Формат ввода

Входной файл input.txt содержит натуральное число N (N ≤ 10) – количество задач. Во второй строке записаны N натуральных чисел – количество минут, необходимое для решения каждой задачи. Время решения задачи не превосходит 300 минут.

Формат вывода

В выходной файл output.txt выведите номер курса студента, одержавшего победу в олимпиаде.

Примеры

Ввод Вывод
3
40 30 60 		1
4
10 20 30 40 		1

Пояснение к примерам

В первом тесте пятикурсник набрал 240 штрафных минут (40 + 70 + 130), третьекурсник – 280 (60 + 90 + 130), первокурсник - 230 минут (30 + 70 + 130).

Во втором тесте третьекурсник набрал 300 минут, а первокурсник и пятикурсник – 200 минут. Но пятикурсник уступил первокурснику.

Пояснение к решению

Задачу можно было решить гораздо проще - вывести 1 в файл output.txt, т.к. первокурсник всегда побеждает при таких условиях.

================================================ FILE: convex_hull/ConvexHull.java ================================================ package convex_hull; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class ConvexHull { private static StringBuilder result = new StringBuilder(); private static ArrayList data = new ArrayList<>(); private static int column = 0, row = 0; private static Map emptyRows = new HashMap<>(); private static void getData() throws IOException{ emptyRows.put("top", -1); emptyRows.put("bottom", -1); Scanner scanner = new Scanner(new FileReader("input.txt")); int i = -1; boolean emptyTop = true, emptyBottom = false; while (scanner.hasNextLine()){ String line = scanner.nextLine(); if(i > -1){ int left = -1, right = -1; char[] ch = line.toCharArray(); for(int j = 0; j < ch.length; j++){ if(ch[j] == '*'){ emptyTop = false; emptyBottom = false; emptyRows.put("bottom", -1); if(left == -1){ // Считываем крайнюю левую заполненную клетку left = j; }else { // Считываем крайнюю правую заполненную клетку right = j; } if(right == -1){ right = left; } } } if(emptyTop){ // Считаем пустые строки сверху emptyRows.put("top", i); }else if(!emptyBottom && left == -1){ // Считаем пустые строки снизу emptyRows.put("bottom", i); emptyBottom = true; } data.add(new int[]{left, right}); }else { String[] arr = line.split(" "); column = Integer.valueOf(arr[1]); row = Integer.valueOf(arr[0]); } i++; } } private static void fillArray(){ int farLeft = column, farRight = 0, countRow = 0; for(int j = 0; j < data.size(); j++){ if(emptyRows.get("top") != -1 && j <= emptyRows.get("top") || emptyRows.get("bottom") != -1 && j >= emptyRows.get("bottom")){ for(int k = 0; k < column; k++){ result.append("."); } result.append("\n"); }else { countRow++; int left = data.get(j)[0]; int right = data.get(j)[1]; if(left != -1 && left < farLeft){ // Получаем самую левую крайнюю клетку farLeft = left; } if(right != -1 && right > farRight){ // Получаем самую правую крайнюю клетку farRight = right; } if(j == row-1 || emptyRows.get("bottom") != -1 && j+1 == emptyRows.get("bottom")){ for (int m =0; m < countRow; m++){ for(int k = 0; k < column; k++){ if(k < farLeft || k > farRight){ result.append("."); }else { result.append("*"); } } result.append("\n"); } } } } } public static void main(String[] args) throws IOException { getData(); fillArray(); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: convex_hull/README.md ================================================

Выпуклая оболочка (27%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Определение 1:

Рассмотрим бесконечный лист клетчатой бумаги. Закрасим некоторое множество клеток в черный цвет. Теперь мы хотим закрасить минимальное количество клеток, так, чтобы множество черных клеток стало выпуклым.

Напомним, что геометрическая фигура Φ называется выпуклой, если для любых точек A из Φ и В из Φ с вещественными координатами отрезок [AB] принадлежит Φ.

Формат ввода

В первой строке входного файла input.txt содержатся два числа N и M (1 ≤ N, M ≤ 100) — размеры куска бумаги, куда попали все черные клетки. В каждой из следующих N строк содержится М символов «*» или «.». Символ «*» обозначает черную клетку, а «.» белую.

Формат вывода

В выходной файл output.txt выведите выпуклое множество, содержащее минимальное количество дополнительно покрашенных черных клеток, в ровно N строках по M символов «*» или «.» в каждой./p>

Примеры

Ввод Вывод
2 4
..*.
.**.		 .**.
.**.
4 3
.*.
.*.
.*.
.*.		 .*.
.*.
.*.
.*.
================================================ FILE: crane/Crane.java ================================================ package crane; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class Crane { public static void main(String[] args) throws IOException { String result; int countBoys; int countGirl; int in; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); in = Integer.valueOf(str); countBoys = in / 6; countGirl = in - countBoys * 2; result = countBoys + " " + countGirl + " " + countBoys; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: crane/README.md ================================================

Журавлики (7%)

Время: 1 сек.
Память: 16 Мб
Сложность: 7%

Петя, Катя и Сережа делают из бумаги журавликов. Вместе они сделали S журавликов. Сколько журавликов сделал каждый ребенок, если известно, что Петя и Сережа сделали одинаковое количество журавликов, а Катя сделала в два раза больше журавликов, чем Петя и Сережа вместе?

Формат ввода

В единственной строке входного файла input.txt записано одно натуральное число S – общее количество сделанных журавликов (S < 106).

Формат вывода

В единственную строку выходного файла output.txt нужно вывести три числа, разделенных пробелами – количество журавликов, которые сделал каждый ребенок (Петя, Катя и Сережа).

Примеры

Ввод Вывод
6 1 4 1
24 4 16 4
60 10 40 10
================================================ FILE: creator/Creator.java ================================================ package creator; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class Creator { public static void main(String[] args) throws IOException { ArrayList names = new ArrayList<>(); ArrayList nameMistakes = new ArrayList<>(); Map mistakeCount = new HashMap<>(); List abc = new ArrayList<>(Arrays.asList('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z')); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()){ int index = Integer.valueOf(sc.nextLine()); while (index>0){ String line = sc.nextLine(); names.add(line); mistakeCount.put(line, 0); index--; } index = Integer.valueOf(sc.nextLine()); while (index>0){ nameMistakes.add(sc.nextLine()); index--; } } for(String name : nameMistakes){ if(!names.contains(name)){ char[] chName = name.toCharArray(); for(int i = 0; i < chName.length; i++){ for (Character anAbc : abc) { String testName = name.substring(0, i) + String.valueOf(anAbc) + name.substring(i + 1); if (names.contains(testName)) { int count = mistakeCount.get(testName) + 1; mistakeCount.put(testName, count); break; } } } } } StringBuilder result = new StringBuilder(); for (String name : names) { result.append(mistakeCount.get(name)).append(" "); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: creator/README.md ================================================

Боги (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Археологами найден набор древних копий старинных манускриптов с мифами – различными историями о древних богах. К несчастью, переписчики этих манускриптов не отличались особой грамотностью и умудрились в каждом имени сделать ровно по одной орфографической ошибке – т.е ровно одну из букв божественного имени заменили какой-то другой буквой. Археологи смогли составить список правильных написаний имен богов, так же им удалось выписать из манускриптов все имена собственные. Однако сопоставлять два списка – свыше их сил. Помогите им в этом!

Формат ввода

Первая строка входного файла input.txt содержит число N – количество имен богов в списке. Следующие N строк – имена богов. Далее идет строка, содержащая число M – количество «подозрительных» слов, выписанных из манускриптов. Следующие M строк – «подозрительные» слова. Каждое из имен богов и «подозрительных» слов – последовательность из K заглавных букв английского алфавита (1 ≤ N, M, K ≤ 30).

Формат вывода

В выходной файл output.txt выводится N чисел – для каждого божьего имени выводится число “подозрительных” слов, которые являются именем данного бога с одной ошибкой.

Примеры

Ввод Вывод
3
ZEUS
POSEIDON
AFINA
4
ZEVS
POSEYDON
AVYNA
ZERS		 2 1 0
================================================ FILE: cross_zero/CrossZero.java ================================================ package cross_zero; import java.util.*; import java.io.*; public class CrossZero { private static ArrayList data = new ArrayList<>(); private static String result; private static void getData() throws IOException{ String[][] game = new String[3][3]; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); char[] ch = str.toCharArray(); for (char aCh : ch) { switch (String.valueOf(aCh)) { case "X": data.add(1); break; case "O": data.add(0); break; default: data.add(-3); break; } } } } private static void winnerLose(){ result = (data.get(0) + data.get(4) + data.get(8) == 3 || data.get(2) + data.get(4) + data.get(6) == 3 || data.get(0) + data.get(3) + data.get(6) == 3 || data.get(1) + data.get(4) + data.get(7) == 3 || data.get(2) + data.get(5) + data.get(8) == 3 || data.get(0) + data.get(1) + data.get(2) == 3 || data.get(3) + data.get(4) + data.get(5) == 3 || data.get(6) + data.get(7) + data.get(8) == 3 ) ? "Win" : (data.get(0) + data.get(4) + data.get(8) == 0 || data.get(2) + data.get(4) + data.get(6) == 0 || data.get(0) + data.get(3) + data.get(6) == 0 || data.get(1) + data.get(4) + data.get(7) == 0 || data.get(2) + data.get(5) + data.get(8) == 0 || data.get(0) + data.get(1) + data.get(2) == 0 || data.get(3) + data.get(4) + data.get(5) == 0 || data.get(6) + data.get(7) + data.get(8) == 0) ? "Lose" : "Draw"; } public static void main(String[] argv) throws IOException{ getData(); winnerLose(); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: cross_zero/README.md ================================================

Крестики-нолики (19%)

Время: 1 сек.
Память: 16 Мб
Сложность: 19%

Крестики-нолики – логическая игра между двумя противниками на квадратном поле 3 на 3 клетки. Один из игроков играет «крестиками» (тот, кто ходит первым), другой – «ноликами». Игроки по очереди ставят на свободные клетки поля знаки (один всегда «крестики», другой всегда «нолики»). Первый, выстроивший в ряд три своих фигуры по вертикали, горизонтали или диагонали, выигрывает и на этом игра заканчивается. В том случае, когда все клетки заполнены и победитель не определен, игра завершается ничьей.

По состоянию игрового поля в конце игры требуется определить результат игры для первого игрока: выиграл, проиграл или сыграл вничью.

Формат ввода

Входной файл input.txt содержит информацию об игровом поле – три строки по три символа в каждой. Символ «X» (ASCII 88) означает «крестик», символ «O» (ASCII 79) - «нолик», а символ «.» (ASCII 46) - пустую клетку.

Формат вывода

В выходной файл OUTPUT.TXT выведите в случае победы первого игрока «Win», в случае его проигрыша – «Lose» и «Draw» в случае ничьей.

Примеры

Ввод Вывод
.OX
.XO
XXO		 Win
OXO
.OX
OXX		 Lose
XOX
XOX
OXO		 Draw
================================================ FILE: cryptogram/Cryptogram.java ================================================ package cryptogram; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.HashMap; import java.util.Map; import java.util.Scanner; public class Cryptogram { private static Map _getAlphabet() { Map alphabet = new HashMap<>(); for(char c = 'a'; c <= 'z'; ++c) { alphabet.put(c, ' '); } return alphabet; } public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); ArrayList data = new ArrayList<>(); Map alphabet = _getAlphabet(); String templateString = "the quick brown fox jumps over the lazy dog"; boolean success = false; // есть ли решение Scanner sc = new Scanner(new FileReader("input.txt")); sc.nextLine(); // первая строка while (sc.hasNextLine()) { String line = sc.nextLine(); data.add(line); if (line.length() == templateString.length() && !success) { char[] symbols = line.toCharArray(); for (int i = 0; i < symbols.length; i++) { char templateSymbol = templateString.charAt(i); if (symbols[i] != ' ') { alphabet.put(symbols[i], templateSymbol); } } if (alphabet.containsValue(' ')) { // если заполнен не весь алфавит alphabet = _getAlphabet(); } else { // новая строка StringBuilder newLine = new StringBuilder(); // сборка новой строки for (char symbol : symbols) { if (symbol == ' ') { newLine.append(' '); } else { newLine.append(alphabet.get(symbol)); } } // сравнение новой строки с шаблоном if (String.valueOf(newLine).equals(templateString)) { success = true; } } } } if (success) { for (String line : data) { char[] symbols = line.toCharArray(); for (char symbol: symbols) { if (symbol != ' ') { out.print(alphabet.get(symbol)); } else { out.print(" "); } } out.println(); } } else { out.println("No solution"); } out.flush(); } } ================================================ FILE: cryptogram/README.md ================================================

Криптограмма (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

На одной из лекций по информатике студент Петя узнал про новый шифр - простой замены. Он и на самом деле прост: в тексте каждая буква алфавита заменяется некоторой другой буквой того же алфавита (может быть, той же самой).

Петя написал письмо своему другу Васе. Письмо - это текст из нескольких строк, написанный на английском языке, с использованием только строчных английских букв и пробелов. В произвольное место, отдельной строкой Петя вставил ключевую фразу: "the quick brown fox jumps over the lazy dog", о которой они с Васей договорились заранее. После чего зашифровал письмо. Известно, что пробелы в письме не шифруются. Получив такое письмо, Вася сумеет его расшифровать и прочесть. Иногда Петя ошибается, и забывает вставить ключевую фразу. Увы, в этом случае прочесть письмо невозможно.

Так как процесс расшифровки трудоемок, Вася просит написать программу, с помощью которой он сможет быстро расшифровывать письмо от Пети.

Формат ввода

Первая строка входного файла INPUT.TXT содержит целое число N – количество строк в письме (1 ≤ N ≤ 200). Далее идет N строк письма (пустые строки отсутствуют, в каждой строке не более 80 символов).

Формат вывода

В выходной файл OUTPUT.TXT в случае присутствия в тексте ключевой фразы выведите N строк расшифрованного сообщения. Если ключевой фразы нет, следует вывести «No solution» (без кавычек). Гарантируется, что есть не более одного способа расшифровки текста из входных данных.

Примеры

Ввод Вывод
3
vtz ud xnm xugm itr pyy jttk gmv xt otgm xt xnm puk ti xnm fprxq
xnm ceuob lrtzv ita hegfd tsmr xnm ypwq ktj
frtjrpgguvj otvxmdxd prm iev prmvx xnmq		 now is the time for all good men to come to the aid of the party
the quick brown fox jumps over the lazy dog
programming contests are fun arent they
3
vtz ud xnm xugm itr pyy jttk gmv xt otgm xt xnm puk ti xnm fprxq
xnm fffff lrtzv iia wwwfd tsmr xnm ypwq ktj
frtjrpgguvj otvxmdxd prm iev prmvx xnmq		 No solution
================================================ FILE: cut/Cut.java ================================================ package cut; import java.io.*; import java.text.DecimalFormat; import java.util.*; public class Cut { public static void main(String[] args) throws IOException { ArrayList point = new ArrayList<>(); // Координаты точек double result; String str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ point.add(Double.valueOf(st.nextToken())); } result = Math.sqrt(Math.pow(point.get(3) - point.get(1), 2) + Math.pow(point.get(2) - point.get(0), 2)); // Вычисление длины отрезка String pattern = "##0.00000"; // Формат вывода DecimalFormat decimalFormat = new DecimalFormat(pattern); String format = decimalFormat.format(result); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(format.replace(",",".")); // Замена запятой на точку по условиям задачи fileOut.close(); } } ================================================ FILE: cut/README.md ================================================

Длина отрезка (12%)

Время: 1 сек.
Память: 16 Мб
Сложность: 12%

Отрезок задан координатами своих концевых точек. Требуется вычислить длину этого отрезка.

Формат ввода

Входной файл INPUT.TXT содержит координаты концов отрезка в формате X1 Y1 X2 Y2 . Все координаты – целые числа, не превышающие 1000 по абсолютной величине.

Формат вывода

В выходной файл OUTPUT.TXT выведите длину отрезка с точностью 10-5.

Примеры

Ввод Вывод
3 4 8 4 5
================================================ FILE: cute_pattern/CutePattern.java ================================================ package cute_pattern; import java.util.*; import java.io.*; public class CutePattern { private static ArrayDeque data = new ArrayDeque<>(); private static String[][] dataArr = new String[4][4]; private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ char[] ch = sc.nextLine().toCharArray(); for(Character chLine : ch){ data.add(String.valueOf(chLine)); } } for(int i = 0; i < 4; i++){ for(int j = 0; j < 4; j++){ dataArr[i][j] = data.getFirst(); data.removeFirst(); } } } public static void main(String[] argv) throws IOException{ getData(); String isCute = "Yes"; // Узор красивый по-умолчанию for(int i = 0; i < 4; i++){ for(int j = 0; j < 4; j++){ if(i+1 < 4 && j+1 < 4 && dataArr[i][j].equals(dataArr[i][j+1]) && // Проверка на красивость dataArr[i][j].equals(dataArr[i+1][j]) && dataArr[i][j+1].equals(dataArr[i+1][j+1])) { isCute = "No"; } } } PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(isCute); pw.close(); } } ================================================ FILE: cute_pattern/README.md ================================================

Симпатичный узор (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

На днях Иван у себя в прихожей выложил кафель, состоящий из квадратных черных и белых плиток. Прихожая Ивана имеет квадратную форму 4х4, вмещающую 16 плиток. Теперь Иван переживает, что узор из плиток, который у него получился, может быть не симпатичным. С точки зрения дизайна симпатичным узором считается тот, который не содержит в себе квадрата 2х2, состоящего из плиток одного цвета.

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

Формат ввода

Входной файл input.txt содержит 4 строки по 4 символа «W» или «B» в каждой, описывающие узор из плиток. Символ «W» обозначает плитку белого цвета, а «B» - черного.

Формат вывода

В выходной файл output.txt выведите «Yes», если узор является симпатичным и «No» в противном случае.

Примеры

Ввод Вывод
BWBW
BBWB
WWBB
BWWW		 Yes
BBWB
BBWB
WWBW
BBWB		 No
================================================ FILE: dates/Dates.java ================================================ package dates; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; import java.util.Scanner; public class Dates { public static void main(String[] args) throws IOException, ParseException { int dayCount = new Scanner(new FileReader("input.txt")).nextInt(); final String startDay = "2008-01-01"; final SimpleDateFormat dayFormat = new SimpleDateFormat( "yyyy-MM-dd" ); final Date date = dayFormat.parse(startDay); final Calendar calendar = GregorianCalendar.getInstance(); calendar.setTime(date); calendar.add( GregorianCalendar.DAY_OF_WEEK, dayCount); int dayWeekNumber = calendar.get(Calendar.DAY_OF_WEEK); String dayWeek = ""; switch (dayWeekNumber) { case 1: dayWeek = "Sunday"; break; case 2: dayWeek = "Monday"; break; case 3: dayWeek = "Tuesday"; break; case 4: dayWeek = "Wednesday"; break; case 5: dayWeek = "Thursday"; break; case 6: dayWeek = "Friday"; break; case 7: dayWeek = "Saturday"; break; } PrintWriter out = new PrintWriter(System.out); out.printf("%s, %td.%tm", dayWeek, calendar, calendar); out.flush(); } } ================================================ FILE: dates/README.md ================================================

Даты (34%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 34%

При обработке различной информации часто приходится оперировать с данными о датах. В этой задаче вам нужно составить программу, которая сможет вывести число, месяц и день недели, которые наступят через K дней, начиная с первого января 2008 года. Напомним, что это был вторник.

Формат ввода

Входной файл INPUT.TXT содержит одно целое число K (0 ≤ K ≤ 1000) - количество дней, после первого января, через которое наступит (или наступила) интересующая дата.

Формат вывода

В выходной файл OUTPUT.TXT ваша программа должна записать, какие день недели, число и месяц наступят по прошествии заданного времени. Результаты проверяются автоматически, поэтому вам следует придерживаться формата, показанного в примерах.

Примеры

Ввод Вывод
0 Tuesday, 01.01
5 Sunday, 06.01

Примечание

По-английски дни недели называются так: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday.

================================================ FILE: decoding/Decoding.java ================================================ package decoding; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.HashMap; import java.util.Map; import java.util.Scanner; public class Decoding { private static Map cipher(){ Map abc = new HashMap<>(); int start = 1; for(char i = 'A'; i <= 'Z'; i++){ abc.put(start, i); start++; } abc.put(start, ' '); return abc; } public static void main(String[] args) throws IOException { int numberCount = 10; int systemNumber = 27; StringBuilder result = new StringBuilder(); Map abc = cipher(); Scanner sc = new Scanner(new FileReader("input.txt")); String line = sc.nextLine(); char[] lineArray = line.toCharArray(); for(int i = 0; i < lineArray.length; i++) { int key = 0; if(String.valueOf(lineArray[i]).matches("[0-9]")){ key += (lineArray[i] - '0'); }else { for(int j : abc.keySet()){ if(lineArray[i] == abc.get(j)){ key = j+numberCount-1; } } } key -= i+1; key = key % systemNumber; if(key == 0){ result.append(" "); }else if(key > 0){ result.append(abc.get(key)); }else { result.append(abc.get(abc.size() + key)); } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result).toLowerCase()); out.close(); } } ================================================ FILE: decoding/README.md ================================================

Расшифровка (28%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Рассмотрим работу простейшего шифра. Шифруемое сообщение состоит из английских букв, записанных в нижнем регистре и символа пробела. Шифрование происходит посимвольно. Каждой букве ставим в соответствие число: a – 1, b – 2, … , z – 26, ‘ ‘ – 27. Далее индекс символа складывается с номером в сообщении по модулю 27, а результат сложения представляется в системе счисления с основанием 27 (0, 1, …, Q в верхнем регистре).

Необходимо написать дешифратор.

Формат ввода

В единственной строке входного файла input.txt содержится закодированная строка, длиной от 1 до 255 символов. Строка записана в верхнем регистре.

Формат вывода

В единственную строку выходного файла output.txt нужно вывести расшифровку заданной строки, при этом символы английского алфавита следует выводить в нижнем регистре.

Примеры

Ввод Вывод
L7MO test
576J9FLF decoding
================================================ FILE: deletion/Deletion.java ================================================ package deletion; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.HashSet; import java.util.Scanner; import java.util.Set; public class Deletion { public static void main(String[] args) throws IOException { Set allNumbers = new HashSet<>(); Scanner sc = new Scanner(new FileReader("input.txt")); char[] symbols = sc.nextLine().toCharArray(); for (int i = 0; i < symbols.length; i++){ for(int j = i + 1; j < symbols.length; j++){ for (int k = j + 1; k < symbols.length; k++){ String one = String.valueOf(symbols[i] - '0'); String two = String.valueOf(symbols[j] - '0'); String three = String.valueOf(symbols[k] - '0'); int number = Integer.valueOf(one + two + three); if(number >= 100){ allNumbers.add(number); } } } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(allNumbers.size())); out.close(); } } ================================================ FILE: deletion/README.md ================================================

Вычеркивание (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Задано натуральное число N. Требуется написать программу, вычисляющую количество различных трехзначных чисел получающихся из N вычеркиванием цифр из его десятичной записи.

Формат ввода

Входной текстовый файл input.txt содержит одно натуральное число N (1 ≤ N ≤ 10100).

Формат вывода

Выходной текстовый файл output.txt должен содержать одно целое число - найденное количество трехзначных чисел.

Примеры

Ввод Вывод
12 0
111111111110011111111 4
================================================ FILE: delta/Delta.java ================================================ package delta; import java.io.*; import java.util.*; public class Delta { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); String result; String str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } result = (data.get(0) < data.get(1) + data.get(2) && data.get(1) < data.get(0) + data.get(2) && data.get(2) < data.get(0) + data.get(1)) ? "YES" : "NO"; // Проверка на вырожденность FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: delta/README.md ================================================

Треугольник - 3 (12%)

Время: 1 сек.
Память: 16 Мб
Сложность: 12%

Даны длины трех отрезков. Требуется проверить: могут ли они являться сторонами невырожденного треугольника.

Формат ввода

Входной файл input.txt содержит 3 натуральных числа X Y Z – длины заданных отрезков. Длины отрезков записаны в одной строке через пробел и не превышают 1000.

Формат вывода

В выходной файл output.txt выведите YES, если отрезки могут быть сторонами треугольника и NO в противном случае.

Примеры

Ввод Вывод
3 4 5 YES
1 1 5 NO
================================================ FILE: dictionary/Dictionary.java ================================================ package dictionary; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class Dictionary { public static void main(String[] args) throws IOException { ArrayList words = new ArrayList<>(); String dictionary; int wordsCount = 0; Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()) { words.add(sc.nextLine()); } dictionary = words.get(words.size()-1); words.remove(words.size()-1); words.remove(0); for (String word : words) { char[] dictionaryCopy = dictionary.toCharArray(); char[] characters = word.toCharArray(); boolean wordInDictionary = true; for (char character : characters) { if (!String.valueOf(dictionaryCopy).contains(String.valueOf(character))) { wordInDictionary = false; break; } else { dictionaryCopy[String.valueOf(dictionaryCopy).indexOf(String.valueOf(character))] = ' '; } } if (wordInDictionary) { wordsCount++; } } PrintWriter out = new PrintWriter(System.out); out.println(wordsCount); out.flush(); } } ================================================ FILE: dictionary/READMe.md ================================================

Словарь (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

Дан некоторый набор букв и словарь. Ваша задача - подсчитать, сколько различных слов из словаря можно составить из этих букв.

Формат ввода

В первой строке файла input.txt записано число N - количество слов в словаре (0 ≤ N ≤ 1000). В следующих N строках файла записано по одному слову из словаря. Слова содержат от 1 до 10 маленьких английских букв. Все слова в словаре различны. В последней строке файла записан набор букв (от 1 до 100 букв).

Формат вывода

Запишите в файл output.txt количество различных слов из словаря, которые можно составить из заданного набора букв.

Примеры

Ввод Вывод
7
ant
bee
cat
dog
ewe
fly
gnu
bew		 0
7
bee
fly
cat
dog
ant
ewe
gnu
tancugd		 3
================================================ FILE: different_numbers/DifferentNumbers.java ================================================ package different_numbers; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class DifferentNumbers { public static void main(String[] args) throws IOException { Map numberSystem = new HashMap<>(); long start = 10; for(char i = 'A'; i <= 'Z'; i++){ numberSystem.put(start++, i); } Scanner sc = new Scanner(new FileReader("input.txt")); long numberIn = sc.nextLong(); int maxSystem = 36; int minSystem = 2; StringBuilder result = new StringBuilder(); for(int i = minSystem; i <= maxSystem; i++){ long numberInCopy = numberIn; Set symbols = new HashSet<>(); int index = 0; while (numberInCopy > 0){ long part = numberInCopy % i; if(part < 10){ symbols.add(String.valueOf(part)); }else { symbols.add(String.valueOf(numberSystem.get(part))); } numberInCopy /= i; index++; } if(index == symbols.size()){ result.append(i).append(" "); } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result).trim()); out.close(); } } ================================================ FILE: different_numbers/README.md ================================================

Разные цифры (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Требуется написать программу, определяющую, в каких системах счисления с основаниями от 2 до 36 это число не содержит одинаковых цифр.

Формат ввода

Входной файл input.txt содержит одно целое число N (1 ≤ N ≤ 109), записанное в десятичной системе счисления.

Формат вывода

Выходной файл output.txt должен содержать основания систем счисления в порядке возрастания, разделенные одним пробелом.

Примеры

Ввод Вывод
100 11 12 13 14 15 16 17 18 20 21 22 23 25 26 27 28 29 30 31 32 33 34 35 36
================================================ FILE: digits/Digits.java ================================================ package digits; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; public class Digits { private static int sum(ArrayList copy){ int sum = 0; boolean plus = true; for(int i : copy){ if(plus){ sum += i; plus = false; }else { sum -= i; plus = true; } } return sum; } public static void main(String[] args) throws IOException { ArrayList numbers = new ArrayList<>(); int sum = 0; Scanner sc = new Scanner(new FileReader("input.txt")); char[] ch = sc.nextLine().toCharArray(); for(char aCh : ch){ numbers.add(aCh - '0'); } for(int i = 0; i < numbers.size(); i++){ ArrayList copy = new ArrayList<>(numbers); copy.remove(i); int subtotal = sum(copy); if(i == 0){ sum = subtotal; }else { sum = sum < subtotal ? subtotal : sum; } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(sum)); out.close(); } } ================================================ FILE: digits/README.md ================================================

Цифры (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Составить программу, удаляющую одну цифру из N-значного числа, такую, чтобы плюс-минус сумма была наибольшей. Плюс-минус сумма – это сумма с чередованием цифр числа с разными знаками: для числа 764 это +7-6+4. Если удалить цифру 7, то будет +6-4=2, если удалить цифру 6, то будет +7-4=3, если удалить цифру 4, то будет +7-6=1. При этом видно, что максимум достигается при удалении средней цифры 6 и равен 3.

Формат ввода

Во входном файле input.txt записано натуральное N-значное число (2 ≤ N ≤ 50).

Формат вывода

В выходной файл output.txt выведите значение наибольшей суммы.

Примеры

Ввод Вывод
764 3
6274861 14
================================================ FILE: digits_after_point/DigitsAfterPoint.java ================================================ package digits_after_point; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.math.BigDecimal; import java.math.RoundingMode; import java.util.Scanner; import java.util.StringTokenizer; public class DigitsAfterPoint { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); int a = Integer.valueOf(st.nextToken()); int b = Integer.valueOf(st.nextToken()); int k = Integer.valueOf(st.nextToken()); String symbol; if(a % b == 0){ symbol = "0"; }else { BigDecimal c = new BigDecimal(String.valueOf(a)); BigDecimal d = new BigDecimal(String.valueOf(b)); BigDecimal div; if(k > 6 && (b != 7)){ div = c.divide(d, 6, RoundingMode.DOWN); }else { div = c.divide(d, k%6, RoundingMode.DOWN); } String number = String.valueOf(div); symbol = number.substring(number.length()-1); } FileWriter out = new FileWriter("output.txt"); out.write(symbol); out.close(); } } ================================================ FILE: digits_after_point/README.md ================================================

Цифры после запятой (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

По заданным натуральным числам A и B найти K-ю цифру после запятой в дроби A/B в десятичной системе счисления.

Формат ввода

В единственной строке входного файла input.txt записано три натуральных числа A, B и K через пробел. А и B – цифры (числа от 1 до 9), число K не превышает 106.

Формат вывода

В выходной файл output.txt нужно вывести ответ на задачу.

Примеры

Ввод Вывод
7 4 2 5
1 6 13 6
================================================ FILE: diplomas/Diplomas.java ================================================ package diplomas; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class Diplomas { private static BigInteger maxwh (BigInteger w2, BigInteger h2) { if (w2.compareTo(h2) > 0) { return w2; } else return h2; } private static BigInteger maxd (BigInteger w1, BigInteger h1, BigInteger mid1) { return (mid1.divide(w1).multiply((mid1.divide(h1)))); } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] numbersInput = sc.nextLine().split(" "); BigInteger w = new BigInteger(numbersInput[0]); BigInteger h = new BigInteger(numbersInput[1]); BigInteger n = new BigInteger(numbersInput[2]); BigInteger hi, lo, mid; hi = maxwh(w, h).multiply(n); lo = BigInteger.ZERO; while (hi.subtract(lo).compareTo(BigInteger.ONE) > 0) { mid = (hi.add(lo)).divide(BigInteger.TWO); if (maxd(w, h, mid).compareTo(n) < 0) { lo = mid; } else { hi = mid; } } PrintWriter out = new PrintWriter(System.out); out.println(hi); out.flush(); } } ================================================ FILE: diplomas/README.md ================================================

Дипломы (28%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Когда Петя учился в школе, он часто участвовал в олимпиадах по информатике, математике и физике. Так как он был достаточно способным мальчиком и усердно учился, то на многих из этих олимпиад он получал дипломы. К окончанию школы у него накопилось n дипломов, причем, как оказалось, все они имели одинаковые размеры: w – в ширину и h – в высоту.

Сейчас Петя учится в одном из лучших российских университетов и живет в общежитии со своими одногруппниками. Он решил украсить свою комнату, повесив на одну из стен свои дипломы за школьные олимпиады. Так как к бетонной стене прикрепить дипломы достаточно трудно, то он решил купить специальную доску из пробкового дерева, чтобы прикрепить ее к стене, а к ней – дипломы. Для того чтобы эта конструкция выглядела более красиво, Петя хочет, чтобы доска была квадратной и занимала как можно меньше места на стене. Каждый диплом должен быть размещен строго в прямоугольнике размером w на h. Прямоугольники, соответствующие различным дипломам, не должны иметь общих внутренних точек.

Требуется написать программу, которая вычислит минимальный размер стороны доски, которая потребуется Пете для размещения всех своих дипломов.

Формат ввода

Входной файл input.txt содержит три целых числа: w, h, n (1 ≤ w, h, n ≤ 109).

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
2 3 10 9

Алгоритм

Из-за больших ограничений на n,w,h линейный перебор возможной длины стороны квадрата не проходит по времени, поэтому данную задачу следует решать, используя бинарный поиск по ответу. Очевидно, что размеры доски лежат в пределах от min(w,h) до n * max(w,h). За O(1) легко проверить, поместятся ли все грамоты в квадрат со стороной a (n <= (a / w) * (a / h)). Пускай мы уверены, что искомый ответ лежит в интервале от Min до Max, тогда проверим удовлетворяет ли условию квадрат со стороной Mid = (Min + Max) / 2. Если да, то Max = Mid, иначе Min = Mid+1. Выполняя эту процедуру до тех пор, пока не сойдутся Min и Max мы будем всё точнее получать возможный диапазон ответа (каждый раз область поиска уменьшается в 2 раза). Когда Min станет равно Max выведем значение Min и прекратим работу программы. Сложность такого решения: O(log(n*max(w,h))).

================================================ FILE: divider/Divider.java ================================================ package divider; import java.util.*; import java.io.*; public class Divider{ public static void main(String[] argv) throws IOException{ Scanner sc = new Scanner(new File("input.txt")); int a= sc.nextInt(), b= sc.nextInt(); while(a != b){ if(a > b) a = a - b; else b = b - a; } PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(a); pw.close(); } } ================================================ FILE: divider/README.md ================================================

НОД (15%)

Время: 1 сек.
Память: 16 Мб
Сложность: 15%

Даны два натуральных числа A и B. Требуется найти их наибольший общий делитель (НОД).

Формат ввода

Во входном файле input.txt в единственной строке записаны натуральные числа A и B через пробел (A, B ≤ 109).

Формат вывода

В выходной файл output.txt выведите НОД чисел А и В.

Примеры

Ввод Вывод
12 42 6
================================================ FILE: divider_two/DividerTwo.java ================================================ package divider_two; import java.io.*; import java.util.*; public class DividerTwo { public static void main(String[] args){ Scanner i = new Scanner(System.in); PrintWriter o = new PrintWriter(System.out); int a = i.nextInt(), b = i.nextInt(); while (a != b){ if(a > b) a = a - b; else b = b - a; } o.print(a); o.flush(); } } ================================================ FILE: divination/Divination.java ================================================ package divination; import java.io.*; import java.util.*; public class Divination { public static void main(String[] args) throws IOException { ArrayList numbers = new ArrayList<>(); int result = 0; int str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); str = Integer.valueOf(sc.nextLine()); for(int i = 1000; i >= 1; i--){ if(str%i == 0){ numbers.add(str/i); } } for(Integer i : numbers){ result += i; } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: divination/README.md ================================================

Гадание (13%)

Время: 1 сек.
Память: 16 Мб
Сложность: 13%

Как и многие другие девочки, Маша любит разные гадания. Некоторое время назад Маша узнала новый способ гадать на числах – для какого-нибудь интересующего ее натурального числа n надо посчитать сумму всех чисел, на которые n делится без остатка. Маша не очень любит арифметику, и попросила вас написать программу, которая автоматизирует процесс гадания.

Формат ввода

В единственной строке входного файла input.txt записано натуральное число n (n ≤ 1000), которое Маша была вынуждена сообщить.

Формат вывода

В выходной файл output.txt выведите сумму всех натуральных делителей числа n.

Примеры

Ввод Вывод
6 12
10 18
================================================ FILE: division_two/DivisionTwo.java ================================================ package division_two; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class DivisionTwo { public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); Scanner sc = new Scanner(new FileReader("input.txt")); long number = sc.nextLong(); while (number >= 1) { if (number % 2 == 0) { number /= 2; } else if (number % 5 == 0) { number /= 5; } else { break; } } if (number == 1) { out.println("NO"); } else { out.println("YES"); } out.flush(); } } ================================================ FILE: division_two/README.md ================================================

Деление-2 (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Рассмотрим дробь 1/N. Чтобы преобразовать эту обыкновенную дробь в дробь десятичную, следует разделить числитель на знаменатель. Результат может иметь конечное число знаков, но может быть и бесконечной периодической дробью.

Примеры:

N = 2: 1/2 = 0,5 – конечное число знаков.

N = 7: 1/7 = 0,(142857) – бесконечная периодическая дробь.

N = 28: 1/28=0,03(571428) – бесконечная периодическая дробь с предпериодом (предпериод - минимальная по длине часть после запятой, которая не входит ни в один период).

Если десятичная дробь имеет конечное число знаков, то будем говорить, что она не имеет периода.

Ваша задача – написать программу, которая по заданному N определит, есть ли у дроби 1/N в десятичной записи период, или нет.

Формат ввода

Входной файл input.txt содержит натуральное число N, не превосходящее 1018.

Формат вывода

В выходной файл output.txt выведите «YES» – если у дроби 1/N есть период, иначе выведите «NO».

Примеры

Ввод Вывод
2 NO
3 YES
================================================ FILE: dots_on_dominoes/DotsOnDominoes.java ================================================ package dots_on_dominoes; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class DotsOnDominoes { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int maxDots = sc.nextInt(); long count = 0; for(int i = 0; i <= maxDots; i++){ for(int j = 0; j <= maxDots; j++){ if(i <= j){ count += (i+j); } } } System.out.println(count); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(count)); out.close(); } } ================================================ FILE: dots_on_dominoes/README.md ================================================

Точки на костях Домино (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Для того, чтобы заработать огромный капитал, новым русским необходимо иметь неординарное мышление. Конечно, при такой сложной работе, должны так же присутствовать какие то особенные механизмы для отдыха и развлечений. В этих целях в казино был придуман специальный набор домино для новых русских. Обычные кости домино представляют собой набор из различных комбинаций сочетаний двух плиток, на каждой из которых отображается от 0 до 6 точек. А этот набор представляет собой подобные сочетания плиток, но количество точек на каждой может быть от нуля до заданного значения, которое зависит от интеллектуального уровня игроков. В таком наборе костей присутствуют всевозможные сочетания плиток, но при этом ни одна из костей не повторяется (даже такие комбинации как 2-5 и 5-2 считаются одинаковыми).

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

Помогите написать программу, которая решит эту задачу.

Формат ввода

Входной файл input.txt содержит одно натуральное число N – максимальное количество точек на одной плитке домино. (N ≤ 10000)

Формат вывода

В выходной файл output.txt выведите количество бриллиантовых камней, которые необходимо изготовить для заданного набора костей.

Примеры

Ввод Вывод
2 12
================================================ FILE: double_numbers/DoubleNumbers.java ================================================ package double_numbers; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.HashSet; import java.util.Scanner; import java.util.Set; public class DoubleNumbers { private static boolean check(int number){ Set set = new HashSet<>(); while (number > 0){ int symbol = number % 10; set.add(symbol); number /= 10; } return set.size() < 3; } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int number = sc.nextInt(); int result; if(check(number)){ result = number; }else { int prev = 0, next = 0, prevStep = 0, nextStep = 0; for(int i = number; i > 0; i--){ if(check(i)){ prev = i; break; } prevStep++; } for(int i = number; i <= 30000; i++){ if(check(i)){ next = i; break; } nextStep++; } result = (nextStep < prevStep) ? next : prev; } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: double_numbers/README.md ================================================

Двоякие числа (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Натуральное число называется двояким, если в его десятичной записи встречается не более двух различных цифр. Например, числа 3, 23, 33, 100, 12121 — двоякие, а числа 123 и 9980 — нет.

Для заданного натурального числа N требуется найти ближайшее к нему двоякое число.

Формат ввода

Во входном файле input.txt записано одно натуральное число N, не превосходящее 30 000.

Формат вывода

В выходной файл output.txt требуется выдать единственное число — ближайшее двоякое к числу N. Если таких чисел несколько, то следует вывести наименьшее.

Примеры

Ввод Вывод
123 122
2012 2020
11111 11111
================================================ FILE: economy/Economy.java ================================================ package economy; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.*; public class Economy { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] firstLineData = sc.nextLine().split(" "); String[] secondLineData = sc.nextLine().split(" "); int n = Integer.parseInt(firstLineData[0]); // кол-во бутылок int k = Integer.parseInt(firstLineData[1]); // кол-во человек ArrayList prices = new ArrayList<>(); for (String item : secondLineData) { prices.add(Integer.parseInt(item)); } prices.sort(Comparator.reverseOrder()); long result = 0; Map customerPurchases = new HashMap<>(); for (int i = 1; i <= k; i++) { customerPurchases.put(i, 0); } int customerNumber = 1; int indexPrice = 0; while (indexPrice < n) { result += (customerPurchases.get(customerNumber) + 1) * prices.get(indexPrice); customerPurchases.put(customerNumber, customerPurchases.get(customerNumber)+1); customerNumber++; if (customerNumber > k) { customerNumber = 1; } indexPrice++; } PrintWriter out = new PrintWriter(System.out); out.println(result); out.flush(); } } ================================================ FILE: economy/README.md ================================================

Экономия (28%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Представь, что ты - капитан команды, которая только что выиграла мировой финал ACM ICPC, и теперь тебе предстоит отпраздновать свою победу со своими друзьями, которых у тебя ровно K-1. Для этого необходимо закупить N бутылок любимого напитка (остается только догадываться какого) в ближайшем магазине. Стоимость i-й бутылки составляет Ci рублей. К сожалению, продавец не любит, когда его клиенты покупают слишком много бутылок, поэтому он продаёт только по одной бутылке за раз, а также изменяет цену бутылки для клиента, который ранее у него уже делал покупки. Точнее, если клиент уже купил X бутылок, то он должен заплатить (X+1)*Ci рублей, чтобы купить бутылку номер i.

Необходимо определить минимально возможную стоимость приобретения N бутылок с учетом того, что в процессе покупки могут участвовать не более K человек (только ты и твои друзья).

Формат ввода

Первая строка входного файла INPUT.TXT содержит два числа N и K (N, K ≤ 100), соответственно во второй строке определены значения C1, C2, ..., CN ( Ci ≤ 106). Все числа во входных данных натуральные.

Формат вывода

В выходной файл OUTPUT.TXT выведите оптимальную стоимость покупки.

Примеры

Ввод Вывод
3 3
2 5 6		 13
================================================ FILE: election_of_priests/ElectionOfPriests.java ================================================ package election_of_priests; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.HashMap; import java.util.Map; import java.util.Scanner; import java.util.StringTokenizer; public class ElectionOfPriests { public static void main(String[] args) throws IOException { Map priests = new HashMap<>(); Map change = new HashMap<>(); Scanner sc = new Scanner(new FileReader("input.txt")); int lineNumber = 0; while (sc.hasNextLine()){ String line = sc.nextLine(); if(lineNumber == 1){ StringTokenizer st = new StringTokenizer(line, " "); int i = 1; while (st.hasMoreTokens()){ priests.put(i, Integer.valueOf(st.nextToken())); i++; } }else if(lineNumber > 2){ StringTokenizer st = new StringTokenizer(line, " "); change.put(Integer.valueOf(st.nextToken()), Integer.valueOf(st.nextToken())); } lineNumber++; } StringBuilder result = new StringBuilder(); for(int i : priests.keySet()){ if(change.containsKey(priests.get(i))){ result.append(change.get(priests.get(i))).append(" "); }else { result.append(priests.get(i)).append(" "); } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: election_of_priests/README.md ================================================

Выборы жрецов (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

В стране Олимпиадии снова выборы.

Страна состоит из маленьких графств. Графства объединяются в конфедерации. Каждая конфедерация раз в год выбирает себе покровителя – одного из 200 жрецов. Этот ритуал называется Великими Перевыборами Жрецов и выглядит так: конфедерации одновременно подают заявления (одно от конфедерации) в Совет Жрецов о том, кого они хотели бы видеть своим покровителем (если заявление не подано, то считают, что конфедерация хочет оставить себе того же покровителя). После этого все заявки удовлетворяются. Если несколько конфедераций выбирают одного и того же Жреца, то они навсегда объединяются в одну. Таким образом, каждый Жрец всегда является покровителем не более чем одной конфедерации. Требуется написать программу, позволяющую Совету Жрецов выяснить номер Жреца-покровителя каждого графства после Великих Перевыборов. В Совете все графства занумерованы (начиная с 1). Все Жрецы занумерованы числами от 1 до 200 (некоторые из них сейчас могут не быть ничьими покровителями).

Формат ввода

Во входном файле input.txt записано число N – количество графств в стране (1 ≤ N ≤ 5000) – и далее для каждого графства записан номер Жреца-покровителя конфедерации, в которую оно входит (графства считаются по порядку их номеров). Затем указаны заявления от конфедераций. Сначала записано число M – количество поданных заявлений, а затем M пар чисел (1 ≤ M ≤ 200): первое число – номер текущего Жреца-покровителя, второе – номер желаемого Жреца-покровителя.

Все числа во входном файле разделяются пробелами и (или) символами перевода строки.

Формат вывода

В выходной файл output.txt вывести для каждого графства одно число – номер его Жреца-покровителя после Великих Перевыборов. Сначала – для первого графства, затем – для второго и т.д.

Примеры

Ввод Вывод
7
1 1 5 3 1 5 1
2
5 1
1 3		 3 3 1 3 3 1 3
================================================ FILE: elevator/Elevator.java ================================================ package elevator; import java.util.*; import java.io.*; public class Elevator { private static ArrayList level = new ArrayList<>(); private static int countLevel; private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); char[] ch = str.toCharArray(); for (char aCh : ch) { level.add(aCh - '0'); } } private static void countLevel(){ int i = 0; int iMax = 0; int iMin = 0; for(Integer numberButton : level){ if(numberButton == 1){ i++; }else { i--; } if(iMin > i){ // Находим количество этажей внизу от этажа, с которого вызвали лифт iMin = i; } if(iMax < i){ // Находим количество этажей сверху от этажа, с которого вызвали лифт iMax = i; } } countLevel = Math.abs(iMax) + Math.abs(iMin) + 1; // Прибавляем этажи сверху, снизу и этаж, с которого вызван лифт } public static void main(String[] argv) throws IOException{ getData(); countLevel(); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(countLevel)); pw.close(); } } ================================================ FILE: elevator/README.md ================================================

Лифт (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

В доме Вилли установили скоростной лифт новой экспериментальной модели. В этом лифте кнопки с номерами этажей заменены двумя другими кнопками. При нажатии на первую кнопку лифт поднимается на один этаж вверх, а при нажатии на вторую – опускается на один этаж вниз.

Младшему брату Вилли Дилли очень нравится кататься на новом лифте. Он катается на нём до тех пор, пока не побывает на каждом из этажей хотя бы по одному разу. После этого Дилли довольный возвращается домой.

Зная порядок, в котором Дилли нажимал на кнопки лифта, попробуйте определить общее количество этажей в доме Вилли и Дилли.

Формат ввода

Первая строка входного файла input.txt содержит последовательность нажатий на кнопки лифта. Символ «1» означает, что была нажата первая кнопка, а символ «2» – что была нажата вторая кнопка. Символы «1» и «2» не разделены пробелами. Количество нажатий от 1 до 100. Гарантируется, что лифт никогда не опускался ниже первого и не поднимался выше последнего этажа.

Формат вывода

В выходной файл output.txt следует вывести одно число – количество этажей в доме Вилли и Дилли.

Примеры

Ввод Вывод
11 3
21212 2
1221221221221 6
================================================ FILE: eleven/Eleven.java ================================================ package eleven; import java.util.*; import java.io.*; public class Eleven { private static String number; private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); number = sc.nextLine(); } public static void main(String[] argv) throws IOException{ getData(); long summEven = 0, summOdd = 0; char[] chNumber = number.toCharArray(); for(int i = 0; i < chNumber.length; i++){ if(i%2 == 0){ summEven += chNumber[i] - '0'; }else{ summOdd += chNumber[i] - '0'; } } String result = (summEven == summOdd || Math.abs(summEven - summOdd) % 11 == 0) ? "YES" : "NO"; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: eleven/README.md ================================================

Делимость на 11 (22%)

Время: 1 сек.
Память: 16 Мб
Сложность: 22%

Для делимости числа на 11 необходимо, чтобы разность между суммой цифр, стоящих на четных местах, и суммой цифр, стоящих на нечетных местах, делилась на 11.

Требуется написать программу, которая проверит делимость заданного числа на 11.

Формат ввода

Входной файл INPUT.TXT содержит одно натуральное число N, делимость которого надо проверить (1 ≤ N ≤ 1010000).

Формат вывода

В выходной файл output.txt выведите “YES”, если число делится на 11, или “NO” иначе.

Примеры

Ввод Вывод
121 YES
1211 NO
================================================ FILE: encryption/Encryption.java ================================================ package encryption; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.HashMap; import java.util.Map; import java.util.Scanner; public class Encryption { private static Map _getAlphabet() { Map alphabet = new HashMap<>(); int i = 0; for(char c = 'A'; c <= 'Z'; ++c) { alphabet.put(i, c); i++; } return alphabet; } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String encryptedString = sc.nextLine(); String correctWord = sc.nextLine(); Map alphabet = _getAlphabet(); StringBuilder result = new StringBuilder(); if (encryptedString.contains(correctWord)) { result.append(encryptedString); } else { for (int i = 25; i > 0; i--) { for (int j = 0; j < encryptedString.length(); j++) { int charIndex = 0; for (int k = 0; k < alphabet.size(); k++) { if (encryptedString.charAt(j) == alphabet.get(k)) { charIndex = k; } } int index = (i + charIndex) % 26; result.append(alphabet.get(index)); } if (result.indexOf(correctWord) == -1) { result.delete(0, result.length()); } else { break; } } } PrintWriter out = new PrintWriter(System.out); if (result.length() == 0) { out.println("IMPOSSIBLE"); } else { out.println(result); } out.flush(); } } ================================================ FILE: encryption/README.md ================================================

Шифровка (29%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 29%

Разведкой был перехвачен ряд шифровок, которые передавал Джеймс Бонд. Известно, что каждое послание зашифровано методом циклического сдвига. Суть которого в том, что каждая буква заменяется на букву, отстоящую в алфавите от первой на определенном расстоянии. Это расстояние называется знаменателем шифра. Так, при знаменателе шифра 2 буква D превратится в F, буква Q – в S, а Z – в B. Известно, что Бонд использует знаменатели от 0 до 25, и составляет послания исключительно из заглавных букв английского алфавита. Знаменатели в шифровках постоянно меняются, так что расшифровать содержимое послания будет не просто. После тщательного анализа удалось примерно определить предмет посланий. Теперь для каждого послания точно известно одно из входящих туда слов.

Формат ввода

В первой строке входного файла INPUT.TXT содержится строка с перехваченным посланием, а во второй строке – слово, которое обязательно присутствует в этом послании. Обе строки состоят только из заглавных английских букв и содержат от 1 до 40 символов.

Формат вывода

В выходной файл OUTPUT.TXT выведите расшифрованный текст, либо сообщение «IMPOSSIBLE», если разгадать шифровку невозможно. В тех случаях, когда расшифровка возможна с различными знаменателями, то следует вывести вариант с наименьшим таким значением.

Примеры

Ввод Вывод
HELLOAMERICA
AMERICA		 HELLOAMERICA
KHOORDPHULFD
HELLOAMERICA		 HELLOAMERICA
KHOORDPHULFD
KHOORDPHULFC		 IMPOSSIBLE
================================================ FILE: eniya/Eniya.java ================================================ package eniya; import java.io.*; import java.util.*; public class Eniya { public static void main(String[] args) throws IOException { int weight; ArrayList number = new ArrayList<>(); String str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while(st.hasMoreTokens()){ number.add(Integer.valueOf(st.nextToken())); } weight = number.get(1) * number.get(2) * 2 * number.get(0); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(weight)); fileOut.close(); } } ================================================ FILE: eniya/README.md ================================================

Эния (3%)

Время: 1 сек.
Память: 16 Мб
Сложность: 3%

Неспокойно сейчас на стапелях шестого дока межгалактического порта планеты Торна. Всего через месяц закончится реконструкция малого броненесущего корвета “Эния”. И снова этому боевому кораблю и его доблестной команде предстоят тяжелые бои за контроль над плутониевыми рудниками Сибелиуса. Работа не прекращается ни на секунду, лазерные сварочные аппараты работают круглые сутки. От непрерывной работы плавятся шарниры роботов-ремонтников. Но задержаться нельзя ни на секунду.

И вот в этой суматохе обнаруживается, что термозащитные панели корвета вновь требуют срочной обработки сульфидом тория. Известно, что на обработку одного квадратного метра панели требуется 1 нанограмм сульфида. Всего необходимо обработать N прямоугольных панелей размером A на B метров. Вам необходимо как можно скорее подсчитать, сколько всего сульфида необходимо на обработку всех панелей “Энии”. И не забудьте, что панели требуют обработки с обеих сторон.

Формат ввода

Во входном файле input.txt содержатся 3 целых положительных числа N (N ≤ 100), A (A ≤ 100), B (B ≤ 100).

Формат вывода

В выходной файл output.txt нужно вывести единственное число – вес необходимого для обработки сульфида тория в нанограммах.

Пример 1

Ввод Вывод
5 2 3 60
14 23 5 3220
================================================ FILE: even_odd_task/EvenOddTask.java ================================================ package even_odd_task; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class EvenOddTask { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); int index = 0; int system = 8; while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); if(index > 0){ while (st.hasMoreTokens()){ String numberStr = st.nextToken(); if(Long.valueOf(numberStr) % 2 == 0){ String number = String.valueOf(Long.toString(Long.parseLong(numberStr), system)); int symbol = Integer.valueOf(number.substring(number.length()-3, number.length()-2)); if(symbol % 2 == 1){ data.add(Long.valueOf(numberStr)); } } } } index++; } Collections.sort(data); StringBuilder result = new StringBuilder(); result.append(data.size()).append("\n"); for(long number : data){ result.append(number).append(" "); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result).trim()); out.close(); } } ================================================ FILE: even_odd_task/README.md ================================================

Четно-нечетная задача (26%)

Время: 2 сек.
Память: 16 Мб
Сложность: 26%

Задано n чисел a1, a2, ... , an. Выберите из них четные числа, у которых третья справа цифра в их представлении в восьмеричной системе счисления нечетна.

Выбранные числа отсортируйте по неубыванию и выведите в выходной файл.

Формат ввода

Первая строка входного файла input.txt содержит целое число n (1 ≤ n ≤ 105). Вторая строка входного файла содержит n целых чисел: a1, a2, ... , an. Они отделены друг от друга пробелами и заданы в десятичной системе счисления. Для всех i (1 ≤ i ≤ n ) верно неравенство 64 ≤ ai ≤ 109.

Формат вывода

В первой строке выходного файла output.txt выведите количество k искомых чисел. Во второй строке выведите эти числа в указанном порядке в десятичной системе счисления.

Примеры

Ввод Вывод
4
100 64 64 130		 3
64 64 100
3
128 129 130		 0
================================================ FILE: event/Event.java ================================================ package event; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Arrays; import java.util.Scanner; public class Event { private static boolean leap(int year) { return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0; } public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); Scanner dates = new Scanner(new FileReader("input.txt")); String[] dateStart = dates.nextLine().split("\\."); String[] dateFinish = dates.nextLine().split("\\."); int dayCount = 0; int dayS = Integer.parseInt(dateStart[0]), monthS = Integer.parseInt(dateStart[1]), yearS = Integer.parseInt(dateStart[2]); int dayF = Integer.parseInt(dateFinish[0]), monthF = Integer.parseInt(dateFinish[1]), yearF = Integer.parseInt(dateFinish[2]); while (yearS < yearF || (yearS <= yearF && monthS < monthF) || (yearS <= yearF && monthS <= monthF && dayS < dayF)) { dayCount++; dayS++; if (Arrays.asList(1, 3, 5, 7, 8, 10, 12).contains(monthS) && dayS > 31 || Arrays.asList(4, 6, 9, 11). contains(monthS) && dayS > 30 || (monthS == 2 && (leap(yearS) && dayS > 29 || !leap(yearS) && dayS > 28))) { dayS = 1; monthS++; } if (monthS > 12) { monthS = 1; yearS++; } } out.println(dayCount + 1); out.flush(); } } ================================================ FILE: event/README.md ================================================

Мероприятие (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

Мише поручили решить следующую задачу: имеется дата начала и конца некоторого мероприятия; требуется определить его длительность. Он написал программу и попросил Машу её проверить.

Через некоторое время пришла Маша и расстроила Мишу: «Твоя программа работает неправильно. По-моему, ты забыл, что года бывают високосными».

У Миши очень мало свободного времени и он не успевает исправить свою программу. Помогите ему.

Год является високосным, тогда и только тогда, когда выполнено одно из следующих условий:

  • год делится на 4, но не делится на 100;
  • год делится на 400.

Например, года 400, 404, 496, 504, 2000, 2004 являются високосными, а года 100, 200, 300, 503, 1000, 2001, 2005 - нет.

Формат ввода

Первая строка входного файла input.txt содержит дату начала мероприятия. Вторая строка входного файла содержит дату конца мероприятия. Гарантируется, что первая дата меньше второй. Даты заданы в формате DD.MM.YYYY.

Формат вывода

В выходной файл OUTPUT.TXT выведите единственное число - длительность мероприятия (в днях).

Примеры

Ввод Вывод
01.09.2005
06.10.2005		 36
01.09.0005
01.09.0006		 366
01.02.2004
01.03.2004		 30
================================================ FILE: evolution/Evolution.java ================================================ package evolution; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class Evolution { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); sc.nextLine(); BigInteger first = new BigInteger(sc.nextLine()); BigInteger second = new BigInteger(sc.nextLine()); PrintWriter out = new PrintWriter(System.out); while (first.compareTo(second) != 0) { if (first.compareTo(second) > 0) { first = first.divide(BigInteger.TWO); } else { second = second.divide(BigInteger.TWO); } } out.println(first); out.flush(); } } ================================================ FILE: evolution/README.md ================================================

Эволюция (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

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

  • Все живые организмы планеты происходят от бактерии Bitozoria Programulis.
  • Эволюция происходила шаг за шагом (по предположению ученых – во время изменения климата на планете).
  • На каждом шаге эволюции из каждого вида образовывались ровно два подвида, а предыдущий вид исчезал.
  • Если считать появление бактерии Bitozoria Programulis первым шагом эволюции, то существующие сейчас живые организмы находятся на N-ом шаге.

Чтобы не придумывать названия во время исследований, ученые пронумеровали все виды организмов, которые когда-либо существовали на планете. Для этого они нарисовали дерево эволюции с корнем Bitozoria Programulis, которая получила номер 1. Далее нумеровали виды каждого шага эволюции слева направо. Таким образом непосредственные подвиды Bitozoria Programulis получили номера 2 и 3. Следующими были занумерованы виды третьего шага эволюции – подвиды вида 2 получили номера 4 и 5, а вида 3 – номера 6 и 7, и т.д.

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

Формат ввода

В первой строке входного файла INPUT.TXT записано целое число N (1 ≤ N ≤ 60) – количество этапов эволюции, которые произошли на планете Олимпия до текущего времени. Вторая и третья строки содержат по одному натуральному числу, которые представляют номера видов, для которых требуется найти номер их ближайшего общего предка.

Формат вывода

В выходной файл OUTPUT.TXT выведите одно натуральное число – номер ближайшего предка для двух видов.

Примеры

Ввод Вывод
4
15
12		 3
18
233016
233008		 14563
================================================ FILE: exam/Exam.java ================================================ package exam; import java.util.*; import java.io.*; public class Exam { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ data.add(Long.valueOf(st.nextToken())); } } public static void main(String[] argv) throws IOException{ getData(); long entrantCount = data.get(0); long mathIsSuccsess = data.get(1); long chemistryIsSuccsess = data.get(2); long examIsFailure = data.get(3); long isOneExam = entrantCount - examIsFailure; long twoExamSuccsess = (isOneExam >= mathIsSuccsess + chemistryIsSuccsess) ? 0 : mathIsSuccsess + chemistryIsSuccsess - isOneExam; long mathOnly = mathIsSuccsess - twoExamSuccsess; long chemistryOnly = chemistryIsSuccsess - twoExamSuccsess; StringBuilder result = new StringBuilder(); result.append(twoExamSuccsess).append(" ").append(mathOnly).append(" ").append(chemistryOnly); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: exam/README.md ================================================

Экзамены (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

В этом году при поступлении в университет абитуриентам требовалось успешно сдать экзамены по математике и физике. К сожалению, с этим испытанием справились не все. Известно, что на экзамены пришло N абитуриентов, из них M – сдали математику, F – сдали физику, а L – не сдали ни одного предмета. Найдите, сколько абитуриентов сдали оба предмета и стали студентами, а также определите, сколько абитуриентов сдали один экзамен: только по математике или только по физике.

Формат ввода

Входной файл input.txt содержит четыре целых числа, разделенных пробелами: N (0 < N ≤ 2×109), M, F, L (0 ≤ M, F, L ≤ 2×109).

Формат вывода

В выходной файл output.txt выведите три числа через пробел:

  • a) количество абитуриентов, сдавших оба экзамена;
  • b) количество абитуриентов, сдавших только математику;
  • с) количество абитуриентов, сдавших только физику.

Примеры

Ввод Вывод
2 2 1 0 1 1 0
10 5 5 5 5 0 0
10 5 5 0 0 5 5
================================================ FILE: factorial/Factorial.java ================================================ package factorial; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class Factorial { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] line = sc.nextLine().split(" "); int number = Integer.valueOf(line[0]); int factorials = line[1].length(); int result = number; int k = 1; while (number - k * factorials > 0){ result *= (number - k * factorials); k++; } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: factorial/README.md ================================================

Факториалы!!! (26%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Определение 1:

n!!...!=n(n-k)(n-2k)...(n mod k), если n не делится на k,

n!!...!=n(n-k)(n-2k)...k, если n делится на k (знаков ! в обоих случаях k штук).

Определение 2:

X mod Y — остаток от деления X на Y.

Например, 10 mod 3 = 1; 3! = 3•2•1; 10!!! = 10•7•4•1;

Мы по заданным n и k смогли вычислить значение выражения из определения 1. А вам слабо?

Формат ввода

Во входном файле input.txt содержится ровно одна строка. Сначала – целое число n, (1 ≤ n ≤ 10) , затем ровно один пробел, затем k восклицательных знаков (1 ≤ k ≤ 20).

Формат вывода

В выходной файл OUTPUT.TXT выведите одно число – значение n!!..! .

Примеры

Ввод Вывод
10 !!! 280
9 !! 945
3 ! 6
================================================ FILE: fast_train/FastTrain.java ================================================ package fast_train; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class FastTrain { /** * @param time Время * @return Разница во времени * */ private static int timeTransformInMinute(String[] time) { return Integer.parseInt(time[0]) * 60 + Integer.parseInt(time[1]); } public static void main (String[] args) throws IOException { int maxTime = 24*60; // Больше этого времени поезд в пути быть не может int time = maxTime; int distance = 650; String trainName = " "; int speed = 0; Scanner sc = new Scanner(new FileReader("input.txt")); int index = 0; while (sc.hasNextLine()) { index++; String line = sc.nextLine(); if (index == 1) { // игнорировтаь первую строку continue; } String name = line.substring(line.indexOf("\""), line.lastIndexOf("\"")+1); line = line.replaceAll(name, ""). replaceAll("\"", "").trim(); String[] lineArguments = line.split(" "); if (lineArguments.length > 1) { String[] timeStart = lineArguments[0].split(":"); String[] timeFinish = lineArguments[1].split(":"); int timeInWay = (timeTransformInMinute(timeFinish) - timeTransformInMinute(timeStart)); if (timeInWay < 0) { // поезд приходит на следующие сутки timeInWay = maxTime + timeInWay; } if (timeInWay == 0 && time == maxTime) { // поезд едет ровно сутки trainName = name; speed = (Math.round((float) distance / ((float) time / 60))); } else if (timeInWay != 0 && timeInWay <= time) { time = timeInWay; trainName = name; speed = Math.round((float) distance / ((float) timeInWay / 60)); } } } PrintWriter out = new PrintWriter(System.out); out.println("The fastest train is " + trainName + "."); out.println("Its speed is " + speed + " km/h, approximately."); out.flush(); } } ================================================ FILE: fast_train/README.md ================================================

Быстрый поезд (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Между двумя крупнейшими городами нашей страны Санкт-Петербургом и Москвой ежедневно совершают рейсы n поездов. Для каждого поезда известно его время отправления из Санкт-Петербурга и время прибытия в Москву.

Найдите самый быстрый поезд и его скорость в предположении, что длина железной дороги между Санкт-Петербургом и Москвой равна 650 км.

Формат ввода

Первая строка входного файла input.txt содержит целое число n (1 ≤ n ≤ 100). Каждая из последующих n строк описывает ровно один поезд.

Описание поезда состоит из его названия, времени отправления и времени прибытия. Название поезда – строка длиной от 1 до 50 символов, заключенная в кавычки. Она может содержать буквы английского алфавита, пробелы, цифры, символы тире («–») и подчеркивания («_»). Время отправления и прибытия заданы в формате ЧЧ:ММ. Строчные и заглавные буквы в названиях поездов различаются.

Время в пути для каждого из поездов составляет хотя бы одну минуту и не превышает 24 часов.

Гарантируется, что самый быстрый поезд определяется единственным образом.

Формат вывода

В выходной файл output.txt выведите название самого быстрого поезда и его скорость. Скорость выводите в километрах в час и округляйте к ближайшему целому по математическим правилам. Следуйте формату вывода, приведенному в примерах.

Примеры

Ввод Вывод
3 "ER-200" 06:43 10:40
"Red Arrow" 23:55 07:55
"Express" 23:59 08:00		 The fastest train is "ER-200".
Its speed is 165 km/h, approximately.
3 "Train1" 00:00 00:00
"Train2" 00:00 00:01
"Train3" 00:01 00:01		 The fastest train is "Train2".
Its speed is 39000 km/h, approximately.
2 "Slow Train 1" 10:00 09:59
"Slow Train 2" 10:00 10:00		 The fastest train is "Slow Train 1".
Its speed is 27 km/h, approximately.
================================================ FILE: fibonacci/Fibonacci.java ================================================ package fibonacci; import java.io.*; import java.util.*; public class Fibonacci { private static int result; private static void run(int number){ // Расчет числа Фибоначчи int a = 0, b = 1; while (number > 1){ b = a + b; a = b - a; number--; } result = (number == 0) ? 0 : b; } public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); int number = sc.nextInt(); run(number); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: fibonacci/README.md ================================================

Числа Фибоначчи (16%)

Время: 1 сек.
Память: 16 Мб
Сложность: 16%

Последовательностью Фибоначчи называется последовательность чисел a0, a1, ..., an, ..., где a0 = 0, a1 = 1, ak = ak-1 + ak-2 (k > 1).

Требуется найти N-е число Фибоначчи.

Формат ввода

Во входном файле input.txtзаписано целое число N (0 ≤ N ≤ 30).

Формат вывода

В выходной файл output.txt выведите N-е число Фибоначчи.

Примеры

Ввод Вывод
7 13
================================================ FILE: fibonacci_again/FibonacciAgain.java ================================================ package fibonacci_again; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class FibonacciAgain { public static void main(String[] args) throws IOException { Scanner scan = new Scanner(new FileReader("input.txt")); long number = (scan.nextLong()) % 60; long a = 0, b = 1; for (int i = 0; i < number; i++){ b = a + b; a = b - a; } long result = b%10; FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: fibonacci_again/README.md ================================================

Снова Фибоначчи (23%)

Время: 1 сек.
Память: 16 Мб
Сложность: 23%

Вам наверняка знакомы числа Фибоначчи: 1, 1, 2, 3, 5, 8, 13, 21... Они определяются рекуррентным соотношением: Fn = Fn-1 + Fn-2, F0 = F1 = 1.

Требуется найти последнюю цифру n-го числа Фибоначчи.

Формат ввода

Во входном файле input.txt содержится одно целое число n (0 ≤ n ≤ 108).

Формат вывода

В выходной файл output.txt необходимо вывести одно число - последнюю цифру числа Fn.

Примеры

Ввод Вывод
1 1
5 8
================================================ FILE: fibonacci_sequence/FibonacciSequence.java ================================================ package fibonacci_sequence; import java.util.*; import java.io.*; public class FibonacciSequence { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } } public static void main(String[] argv) throws IOException{ getData(); int a = data.get(1); int b = data.get(2); int c = data.get(2); for(int i = data.get(0) - 1; i > 0; i--){ a = b - a; b = c - a; c = b; } String result = a + " " + b; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: fibonacci_sequence/README.md ================================================

Фибоначчиева последовательность (17%)

Время: 1 сек.
Память: 16 Мб
Сложность: 17%

Последовательность чисел a1, a2, …, ai,… называется Фибоначчиевой, если для всех i ≥ 3 верно, что ai=ai-1+ai-2, то есть каждый член последовательности (начиная с третьего) равен сумме двух предыдущих.

Ясно, что, задавая различные числа a1 и a2, мы можем получать различные такие последовательности, и любая Фибоначчиева последовательность однозначно задается двумя своими первыми членами.

Будем решать обратную задачу. Вам будет дано число n и два члена последовательности: an и an+1. Вам нужно написать программу, которая по их значениям найдет a1 и a2.

Формат ввода

Входной файл input.txt содержит число n и значения двух членов последовательности: an и an+1 (1 ≤ n ≤ 30, члены последовательности — целые числа, по модулю не превышающие 2×109).

Формат вывода

В выходной файл output.txt выведите два числа — значения первого и второго членов этой последовательности.

Примеры

Ввод Вывод
4 3 5 1 1
================================================ FILE: fibonacci_two/FibonacciTwo.java ================================================ package fibonacci_two; import java.util.*; import java.io.*; public class FibonacciTwo { private static long number; private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); number = sc.nextInt(); } public static void main(String[] argv) throws IOException{ getData(); int a = 1, b = 1, k = 1; int isFibonacci = 0; while (number > a){ k++; b = a + b; a = b - a; if(a == number){ isFibonacci = 1; } } String result = (isFibonacci == 0) ? "0" : "1\n" + k; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: fibonacci_two/README.md ================================================

Числа Фибоначчи - 2 (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

Числа Фибоначчи строятся следующим образом: 1, 1, 2, 3, 5, …. В этой последовательности, начиная с третьего числа, каждый следующий член равен сумме двух предыдущих. Получаем, что, например, шестое число равно 8, а десятое - 55.

Требуется написать программу, которая определяет, является ли заданное число числом Фибоначчи.

Формат ввода

Входной текстовый файл input.txt содержит одно натуральное число в диапазоне от 2 до 1200000000.

Формат вывода

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

Примеры

Ввод Вывод
8 1
6
10 0
================================================ FILE: field/Field.java ================================================ package field; import java.io.*; import java.util.*; public class Field { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Long.valueOf(st.nextToken())); } long areaRect = data.get(0) * data.get(1); // Площадь прямоугольника long sqrt = (long) Math.sqrt(areaRect); // Площадь стороны квадрата, если квадрат существует long result = (Math.pow(sqrt, 2) == areaRect) ? sqrt : 0; // Расчет результата System.out.println(result); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: field/README.md ================================================

Поля (16%)

Время: 1 сек.
Память: 16 Мб
Сложность: 16%

Геннадий учится в сельской школе и мечтает стать агрономом. На уроке геометрии Геннадий познакомился с новой фигурой – прямоугольником. Освоив вычисление площади прямоугольника, Гена подумал о том, что квадратные поля гораздо удобнее, нежели прямоугольные. Поразмыслив еще немного, Гена столкнулся с интересной задачей: существует ли такое квадратное поле, у которого площадь в точности равна площади заданного поля прямоугольной формы, чтобы при этом длины сторон обеих полей были бы целыми числами?

Формат ввода

Входной файл input.txt содержит целые числа a и b – длины сторон прямоугольника (1 < = a*b ≤ 1014).

Формат вывода

В выходной файл output.txt выведите либо одно целое число c – длину стороны квадрата, либо 0, если квадрата с целочисленной длиной стороны не существует.

Примеры

Ввод Вывод
1 4 2
2 8 4
15 42 0
================================================ FILE: field_miracles/FieldMiracles.java ================================================ package field_miracles; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class FieldMiracles { public static void main(String[] args) throws IOException { int[] numbers = new int[0]; int sectorCount = 0; Scanner rows = new Scanner(new FileReader("input.txt")); int rowIndex = 0; while (rows.hasNextLine()){ String[] numbersInput = rows.nextLine().split(" "); if (rowIndex != 0) { for (int i = 0; i < numbersInput.length; i++) { numbers[i] = Integer.parseInt(numbersInput[i]); } } else { sectorCount = Integer.parseInt(numbersInput[0]); numbers = new int[sectorCount]; } rowIndex++; } sectorCount = sectorCount-1; boolean end = false; for (int i = 1; i < sectorCount; i++) { if (sectorCount % i == 0) { int j = 0; while (numbers[j % i] == numbers[j] && j < sectorCount) { j++; if (j == sectorCount) { sectorCount = i; end = true; break; } } } if (end) break; } PrintWriter out = new PrintWriter(System.out); out.println(sectorCount); out.flush(); } } ================================================ FILE: field_miracles/README.md ================================================

Поле чудес (31%)

Ссылка на задачу

Время: 0,5 сек.
Память: 16 Мб
Сложность: 31%

Для игры в «Поле чудес» используется круглый барабан, разделенный на сектора, и стрелка. В каждом секторе записано некоторое число. В различных секторах может быть записано одно и то же число. Однажды ведущий игры решил изменить правила. Он сам стал вращать барабан и называть игроку (который барабана не видел) все числа подряд в том порядке, в котором на них указывала стрелка в процессе вращения барабана. Получилось так, что барабан сделал целое число оборотов, то есть последний сектор совпал с первым. После этого, ведущий задал участнику вопрос: какое наименьшее число секторов может быть на барабане? Требуется написать программу, отвечающую на этот вопрос ведущего.

Формат ввода

В первой строке входного файла input.txt записано число N – количество чисел, которое назвал ведущий (2 ≤ N ≤ 30000). Во второй строке записано N чисел, на которые указывала стрелка в процессе вращения барабана. Первое число всегда совпадает с последним (в конце стрелка указывает на тот же сектор, что и в начале). Числа, записанные в секторах барабана – натуральные, не превышающие 32000.

Формат вывода

В выходной файл output.txt необходимо вывести одно число – минимальное число секторов, которое может быть на барабане.

Примеры

Ввод Вывод
13
5 3 1 3 5 2 5 3 1 3 5 2 5		 6
4
1 1 1 1		 1
4
1 2 3 1		 3
================================================ FILE: fire/Fire.java ================================================ package fire; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class Fire { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } int n = data.get(0), m = data.get(1); data.remove(0); data.remove(0); boolean success = true; int time = 0; for (int i = 0; i < data.size(); i++){ if(data.get(i) > m){ success = false; } if(i != data.size()-1){ time += data.get(i) - 1; }else { time += data.get(i); } } String result = time >= m && success ? "yes" : "no"; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: fire/README.md ================================================

Костер (24%)

Время: 1 сек.
Память: 16 Мб
Сложность: 24%

Во время военного похода на морского пехотинца Джо было возложено ответственное задание – развести костёр и поддерживать в нём огонь ровно m минут. Для этого у Джо есть спички и n поленьев, причём Джо известно точное время сгорания каждого полена.

Джо разжигает огонь в момент времени t = 0 и сразу бросает в него одно или несколько поленьев. Затем он должен подбрасывать в огонь новые поленья, не позволяя костру угаснуть (т.е. если последнее полено в костре догорает в момент времени t, то новое полено может быть брошено в огонь не позднее t – 1). Поленья, брошенные в огонь, загораются мгновенно. Одновременно Джо может бросить в огонь любое количество поленьев. Джо должен бросить в огонь все n поленьев.

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

Формат ввода

Первая строка входного файла input.txt содержит целые числа n и m (1 ≤ n ≤ 100, 1 ≤ m ≤ 1000) – количество поленьев и время, в течение которого Джо должен поддерживать огонь в костре. Вторая строка входного файла содержит n целых чисел a1, a2, ..., an, где ai (2 ≤ ai ≤ 1000) – время сгорания i-ого полена в минутах.

Формат вывода

В выходной файл output.txt выведите строку «yes», если Джо сможет поддерживать огонь в костре ровно m минут, и строку «no» в противном случае.

Примеры

Ввод Вывод
2 3 5 yes
2 5
3 9		 no
4 10
3 3 3 3		 no
================================================ FILE: fishing_net/README.md ================================================

Рыболовная сеть (10%)

Время: 1 сек.
Память: 16 Мб
Сложность: 10%

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

Сеть имеет прямоугольную форму размером M×N узлов, все смежные узлы соединены леской. Под разрывом будем понимать только единичный обрыв лески между двумя смежными узлами сети.

Формат ввода

Входной файл input.txt содержит два целых числа M и N – размеры рыболовной сети (1 ≤ M, N ≤ 10 000).

Формат вывода

В выходной файл output.txt выведите максимальное число разрывов заданной сети, которые не приведут к распадению рыболовной снасти Петровича.

Примеры

Ввод Вывод
2 2 1
2 3 2
================================================ FILE: fishing_net/fishingNet.java ================================================ package fishing_net; import java.io.*; import java.util.*; public class fishingNet { public static void main(String[] args) throws IOException { int node = 1; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while(st.hasMoreTokens()){ node = node * (Integer.valueOf(st.nextToken()) - 1); } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(node)); fileOut.close(); } } ================================================ FILE: floret/Floret.java ================================================ package floret; import java.io.*; import java.util.*; public class Floret { public static void main(String[] args) throws IOException { ArrayDeque queue = new ArrayDeque<>(Arrays.asList("G", "C", "V")); StringBuilder result = null; int str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); str = Integer.valueOf(sc.nextLine()); for(int i = 0; i < str; i++){ queue.addFirst(queue.getLast()); queue.removeLast(); } for(String flovers : queue){ if(result != null){ result.append(flovers); }else{ result = new StringBuilder(flovers); } } FileWriter fileOut = new FileWriter("output.txt"); assert result != null; fileOut.write(Objects.requireNonNull(result.toString())); fileOut.close(); } } ================================================ FILE: floret/README.md ================================================

Цветочки (12%)

Время: 1 сек.
Память: 16 Мб
Сложность: 12%

В рождественский вечер на окошке стояло три цветочка, слева направо: герань, крокус и фиалка. Каждое утро Маша вытирала окошко и меняла местами стоящий справа цветок с центральным цветком. А Таня каждый вечер поливала цветочки и меняла местами левый и центральный цветок. Требуется определить порядок цветов ночью по прошествии K дней.

Формат ввода

Во входном файле input.txt содержится натуральное число K – число дней (K ≤ 1000).

Формат вывода

В выходной файл OUTPUT.TXT требуется вывести три английских буквы: «G», «C» и «V» (заглавные буквы без пробелов), описывающие порядок цветов на окошке по истечении K дней (слева направо). Обозначения: G – герань, C – крокус, V – фиалка.

Примеры

Ввод Вывод
1 VGC
5 CVG
================================================ FILE: football/Football.java ================================================ package football; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class Football { public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); int ballCount = sc.nextInt(); int index = 0; while (ballCount > 0){ index++; ballCount -= index; } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(index)); out.close(); } } ================================================ FILE: football/README.md ================================================

Футбол (22%)

Время: 1 сек.
Память: 16 Мб
Сложность: 22%

Вместо того чтобы делать уроки, Вася смотрел футбольный матч и записывал счет, который показывался на табло, после каждого забитого гола. Например, у него могла получиться такая запись: 1:0, 1:1, 1:2, 2:2, 2:3. После этого он сложил все записанные числа: 1+0+1+1+1+2+2+2+2+3=15.

По сумме, получившейся у Васи, определите, сколько всего мячей было забито в матче.

Формат ввода

В первой строке входного файла input.txt записано одно целое неотрицательное число, не превосходящее 1000 – сумма, полученная Васей.

Формат вывода

В выходной файл output.txt выведите одно число – общее количество забитых мячей.

Примеры

Ввод Вывод
15 5
================================================ FILE: frendly_numbers/FrendlyNumbers.java ================================================ package frendly_numbers; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; import java.util.StringTokenizer; public class FrendlyNumbers { private static String reformatNumber(char[] ch){ StringBuilder firstNumberBuilder = new StringBuilder(); String prev = "a"; for (char aCh : ch) { String symbol = String.valueOf(aCh); if (!symbol.equals(prev)) { firstNumberBuilder.append(symbol); } prev = symbol; } return firstNumberBuilder.toString(); } private static boolean check(String firstNumber, String secondNumber){ char[] chFirst = firstNumber.toCharArray(); Arrays.sort(chFirst); firstNumber = reformatNumber(chFirst); char[] chSecond = secondNumber.toCharArray(); Arrays.sort(chSecond); secondNumber = reformatNumber(chSecond); return firstNumber.equals(secondNumber); } public static void main(String[] args) throws IOException { StringBuilder result = new StringBuilder(); ArrayList data = new ArrayList<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ data.add(st.nextToken()); } } data.remove(0); while (data.size() > 0){ String firstNumber = data.get(0); String secondNumber = data.get(1); if(check(firstNumber, secondNumber)){ result.append("YES"); result.append("\n"); }else { result.append("NO"); result.append("\n"); } data.remove(0); data.remove(0); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: frendly_numbers/README.md ================================================

Дружные числа (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Будем называть два числа дружными, если они состоят из одних и тех же цифр. Например, числа 1132 и 32321 являются дружными, а 12 и 123 – нет (в первом числе нет цифры 3). Требуется написать программу, которая определит, являются ли два заданных числа дружными.

Формат ввода

Входной текстовый файл input.txt содержит в первой строке натуральное число K – количество тестов. Количество тестов не превышает 10. В следующих K строках содержатся по два целых числа A и B, разделенные одним пробелом (0 < A < 109, 0 < B < 109).

Формат вывода

Выходной текстовый файл output.txt должен содержать K строк. Для каждого теста в отдельной строке надо выдать сообщение “YES”, если A и B являются дружными, или “NO”, если не являются. В сообщениях кавычки не печатать.

Примеры

Ввод Вывод
1
1132 32321		 YES
2
12 123
11 111		 NO
YES
================================================ FILE: fun_game/FunGame.java ================================================ package fun_game; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.math.BigInteger; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class FunGame { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String number = sc.nextLine(); ArrayList numbers = new ArrayList<>(); String numberBinary = new BigInteger(number, 10).toString(2); while (!numbers.contains(numberBinary)) { numbers.add(numberBinary); numberBinary = numberBinary.substring(numberBinary.length()-1) + numberBinary.substring(0, numberBinary.length()-1); } String maxBinary = Collections.max(numbers); String max = new BigInteger(maxBinary, 2).toString(10); PrintWriter out = new PrintWriter(System.out); out.println(max); out.flush(); } } ================================================ FILE: fun_game/README.md ================================================

Забавная игра (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Легендарный учитель математики Юрий Петрович придумал забавную игру с числами. А именно, взяв произвольное целое число, он переводит его в двоичную систему счисления, получая некоторую последовательность из нулей и единиц, начинающуюся с единицы. (Например, десятичное число 1910 = 1*24+0*23+0*22+1*21+1*20 в двоичной системе запишется как 100112.) Затем учитель начинает сдвигать цифры полученного двоичного числа по циклу (так, что последняя цифра становится первой, а все остальные сдвигаются на одну позицию вправо), выписывая образующиеся при этом последовательности из нулей и единиц в столбик — он подметил, что независимо от выбора исходного числа получающиеся последовательности начинают с некоторого момента повторяться. И, наконец, Юрий Петрович отыскивает максимальное из выписанных чисел и переводит его обратно в десятичную систему счисления, считая это число результатом проделанных манипуляций. Так, для числа 19 список последовательностей будет таким:

10011
11001
11100
01110
00111
10011
…

и результатом игры, следовательно, окажется число 1*24+1*23+1*22+0*21+0*20 = 28.

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

Формат ввода

Входной файл input.txt содержит одно целое число N (0 ≤ N ≤ 32767).

Формат вывода

Ваша программа должна вывести в выходной файл output.txt одно целое число, равное результату игры.

Примеры

Ввод Вывод
19 28
1212 1938
================================================ FILE: funny_sequence/FunnySequence.java ================================================ package funny_sequence; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.HashSet; import java.util.Scanner; import java.util.Set; public class FunnySequence { public static void main(String[] args)throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); int number = sc.nextInt(); Set list = new HashSet<>(1); int outNumber = 1; for (int i = 2; i <= number; i++){ if(list.contains(i)){ outNumber += 3; }else { outNumber += 2; } list.add(outNumber); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(outNumber)); out.close(); } } ================================================ FILE: funny_sequence/README.md ================================================

Забавная последовательность (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Определим последовательность ai следующим образом: a1 = 1, an = an-1+ 3, если число n уже встречалось в последовательности a, и an = an-1 + 2, иначе. Нетрудно видеть, что первые 8 членов этой последовательности таковы: 1, 3, 6, 8, 10, 13, 15, 18.

Ваша задача вычислить an.

Формат ввода

Входной файл input.txt содержит целое число n (1 ≤ n ≤ 105).

Формат вывода

В выходной файл output.txt выведите an.

Примеры

Ввод Вывод
1 1
8 18
================================================ FILE: gambling_shrek/GamblingShrek.java ================================================ package gambling_shrek; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; import java.util.StringTokenizer; public class GamblingShrek { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ data.add(Long.valueOf(st.nextToken())); } } data.remove(0); Collections.sort(data); long dialer = 0; long player = 0; for(int i = 0; i < data.size(); i++){ if(i < data.size()/2){ dialer += data.get(i); }else { player += data.get(i); } } long result = player - dialer; FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: gambling_shrek/README.md ================================================

Азартный Шрэк (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

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

На игровом столе лежат N карточек. На каждой карточке написано целое положительное число. Игра проходит между игроком и крупье. Карточки лежат на столе числами вниз. Игра заключается в том, что игрок открывает ровно N/2 карточек. Сумма всех чисел, написанных на карточках открытых игроком, называется “суммой игрока”. Следующим ходом крупье открывает оставшиеся N/2 карточек. Сумма всех чисел, написанных на карточках открытых крупье, называется “суммой крупье”. Выигрыш игрока определяется разностью чисел между “суммой игрока” и “суммой крупье”. Очевидно, что полученная разность может быть отрицательным числом. Это свидетельствует о том, что игрок проиграл и должен казино соответствующую сумму.

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

Формат ввода

Первая строка входного файла input.txt содержит одно четное натуральное число N (2 ≤ N ≤ 100). Вторая строка входного файла содержит ровно N чисел Ai(1 ≤ Ai ≤ 106) – числа, написанные на игральных карточках. Все числа в строке разделяются одиночными пробелами, Ai – число, написанное на i-й карточке. Карточки нумеруются последовательно, начиная с единицы.

Формат вывода

Единственная строка выходного файла output.txt должна содержать ровно одно целое число – максимальный выигрыш, который может получить Шрек с учетом своей уникальной способности видеть числа, написанные на карточках.

Примеры

Ввод Вывод
2
1 3		 2
4
3 1 8 100		 104
================================================ FILE: game/Game.java ================================================ package game; import java.util.*; import java.io.*; public class Game { public static void main(String[] args) throws IOException { String number; // Число-разница int interimNumber; int differenceNumber; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); // 1 цифра interimNumber = Integer.valueOf(str); differenceNumber = 9 - interimNumber; // Получаем 3 цифру number = str + 9 + differenceNumber; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(number); fileOut.close(); } } ================================================ FILE: game/README.md ================================================

Игра (4%)

Время: 1 сек.
Память: 16 Мб
Сложность: 4%

В свободное время одноклассники Вася и Петя любят играть в различные логические игры: морской бой, крестики-нолики, шахматы, шашки и многое другое. Ребята уже испробовали и поиграли во всевозможные классические игры подобного рода, включая компьютерные. Однажды им захотелось сыграть во что-нибудь новое, но ничего подходящего найти не удалось. Тогда Петя придумал следующую игру «Угадайка»: Играют двое участников. Первый загадывает любое трехзначное число, такое что первая и последняя цифры отличаются друг от друга более чем на единицу. Далее загадавший число игрок переворачивает загаданное число, меняя первую и последнюю цифры местами, таким образом получая еще одно число. Затем из максимального из полученных двух чисел вычитается минимальное. Задача второго игрока – угадать по первой цифре полученного в результате вычитания числа само это число. Например, если Вася загадал число 487, то перестановкой первой и последней цифры он получит число 784. После чего ему придется вычесть из 784 число 487, в результате чего получится число 297, которое и должен отгадать Петя по указанной первой цифре «2», взятой из этого числа. Петя успевает лучше Васи по математике, поэтому практически всегда выигрывает в играх такого типа. Но в данном случае Петя схитрил и специально придумал такую игру, в которой он не проиграет Васе в любом случае. Дело в том, что придуманная Петей игра имеет выигрышную стратегию, которая заключается в следующем: искомое число всегда является трехзначным и вторая его цифра всегда равна девяти, а для получения значения последней достаточно отнять от девяти первую, т.е. в рассмотренном выше случае последняя цифра равна 9-2=7. Помогите Пете еще упростить процесс отгадывания числа по заданной его первой цифре, написав соответствующую программу.

Формат ввода

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

Формат вывода

В выходной файл output.txt нужно вывести значение полученной Васей разности.

Пример 1

Ввод Вывод
5 594
2 297
================================================ FILE: game_meter/GameMeter.java ================================================ package game_meter; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.*; public class GameMeter { /** * @param x1, y1, x2, y2 Координаты точек * @return Расстояние между двумя точками * */ private static double distance(int x1, int y1, int x2, int y2) { return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2)); } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); ArrayList coordinates = new ArrayList<>(); Set result = new TreeSet<>(); while (sc.hasNextLine()) { String[] line = sc.nextLine().split(" "); if (line.length == 2) { coordinates.add(line); } } for (int i = 0; i < coordinates.size(); i++) { for (int j = 0; j < coordinates.size(); j++) { if (i != j) { result.add(distance(Integer.parseInt(coordinates.get(i)[0]), Integer.parseInt(coordinates.get(i)[1]), Integer.parseInt(coordinates.get(j)[0]), Integer.parseInt(coordinates.get(j)[1]))); } } } PrintWriter out = new PrintWriter(System.out); out.println(result.size()); for (double number: result) { out.println(number); } out.flush(); } } ================================================ FILE: game_meter/README.md ================================================

Развлечения с измерителем (28%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Дима обнаружил у папы на столе специальный чертежный прибор, похожий на циркуль-измеритель. Измеритель отличается от обычного циркуля тем, что в обеих его ножках находятся иголки (у обычного циркуля в одной ножке находится иголка, а в другой – грифель).

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

Ваша задача - написать программу, которая по координатам точек определит, сколько различных расстояний встречается среди расстояний, которые измерил Дима.

Формат ввода

Первая строка входного файла input.txt содержит число n – количество точек (2 ≤ n ≤ 50). Следующие n строк содержат по два целых числа – координаты точек. Координаты не превышают 104 по абсолютной величине.

Формат вывода

На первой строке выходного файла output.txt выведите k – количество различных расстояний, которые измерил Дима. Следующие k строк должны содержать по одному вещественному числу – сами расстояния. Расстояния должны быть выведены в возрастающем порядке. Каждое число должно быть выведено с точностью не менее чем 10-9.

Примеры

Ввод Вывод
4
0 0
1 1
1 0
0 1		 2
1.0
1.414213562373
================================================ FILE: game_theory/GameTheory.java ================================================ package game_theory; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class GameTheory { public static void main(String[] args) throws IOException { int max, min; Scanner scan = new Scanner(new FileReader("input.txt")); int lineNumber = -1; ArrayList minRows = new ArrayList<>(); ArrayList maxColumns = new ArrayList<>(); while (scan.hasNextLine()){ String[] coordinates = scan.nextLine().split(" "); if (lineNumber != -1) { int minRow = 9999; for (int column = 0; column < coordinates.length; column++) { int cellValue = Integer.parseInt(coordinates[column]); if (minRow > cellValue) { minRow = cellValue; } if (maxColumns.size() < coordinates.length) { maxColumns.add(-9999); } if (maxColumns.get(column) < cellValue) { maxColumns.set(column, cellValue); } } minRows.add(minRow); } lineNumber++; } Collections.sort(minRows); Collections.sort(maxColumns); min = minRows.get(minRows.size()-1); max = maxColumns.get(0); FileWriter out = new FileWriter("output.txt"); out.write(min + " " + max); out.close(); } } ================================================ FILE: game_theory/README.md ================================================

Теория игр (28%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Одним из интересных объектов, изучаемых в теории игр, являются так называемые антагонистические игры двух лиц. Такие игры характеризуются множеством X стратегий первого игрока, множеством Y стратегий второго игрока и функцией выигрыша K(x, y) (x из X, y из Y). Если множества стратегий X и Y конечны, то такую игру принято называть матричной, так как функцию выигрыша K в этом случае удобно задавать матрицей.

Рассмотрим матричную игру, в которой X = {1,…,n}, Y = {1,…,m}. Матрицу выигрышей обозначим символом K. Нижним значением игры назовем число maxi=1..nminj=1..m Kij . Верхним значением игры назовем число minj=1..mmaxi=1..n Kij. Отметим также, что игры, у которых нижнее и верхнее значение совпадают, называются играми с седловой точкой.

Задана матрица выигрышей K для некоторой матричной игры. Найдите ее верхнее и нижнее значение.

Формат ввода

Первая строка входного файла input.txt содержит целые числа n и m (1 ≤ n,m ≤ 100). Далее следуют n строк по m чисел в каждой. j-ое число i-ой строки равно Kij . Все Kij по модулю не превосходят 1000.

Формат вывода

В выходной файл output.txt выведите нижнее и верхнее значение игры через пробел.

Примеры

Ввод Вывод
3 3
4 -1 -3
-2 1 3
0 2 -3		 -2 2
3 4
-1 0 2 1
-2 0 1 0
2 1 -1 -2		 -1 1
================================================ FILE: gardener_artist/GardenerArtist.java ================================================ package gardener_artist; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class GardenerArtist { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int number = sc.nextInt(); int colorCount = 3; long count = (long) (colorCount * Math.pow(2, number-1)); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(count)); out.close(); } } ================================================ FILE: gardener_artist/README.md ================================================

Садовник-художник (28%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Садовник посадил N деревьев в один ряд. После посадки деревьев садовнику нужно их покрасить. В его распоряжении есть краска трех цветов: белая, синяя и оранжевая. Сколько способов покраски деревьев есть у него, если никакие два соседних дерева нельзя красить в одинаковый цвет?

Формат ввода

В единственной строке входного файла input.txt записано одно натуральное число - количество деревьев N (1 ≤ N ≤ 50).

Формат вывода

В единственную строку выходного файла output.txt нужно вывести одно число - количество способов покраски.

Примеры

Ввод Вывод
3 12
================================================ FILE: gifts/Gifts.java ================================================ package gifts; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; import java.util.StringTokenizer; public class Gifts { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); int x = Integer.valueOf(st.nextToken()); int y = Integer.valueOf(st.nextToken()); int z = Integer.valueOf(st.nextToken()); int total = Integer.valueOf(st.nextToken()); int count = 0; for(int i = 0; i <= total; i += x){ for (int j = 0; j <= total-i; j += y){ for(int k = 0; k <= total - (i + j); k += z){ if(i + j + k == total){ count++; } } } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(count)); out.close(); } } ================================================ FILE: gifts/README.md ================================================

Подарки Деда Мороза (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Ириска весит X грамм, мандарин – Y грамм, пряник – Z грамм.

Требуется написать программу, которая определит, сколько различных вариантов подарков весом ровно W грамм может сделать Дед Мороз.

Формат ввода

В единственной строке входного файла input.txt содержится четыре целых числа X, Y, Z и W (1 ≤ X, Y, Z ≤ 100, 1 ≤ W ≤ 1000).

Формат вывода

Выходной файл output.txt должен содержать одно целое число – количество вариантов подарков.

Примеры

Ввод Вывод
10 25 15 40 3
================================================ FILE: gnome_entertainment/GnomeEntertainment.java ================================================ package gnome_entertainment; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Map; import java.util.Scanner; import java.util.TreeMap; public class GnomeEntertainment { /** * @return Map с алфавитом * */ private static Map getAbc(){ Map abc = new TreeMap<>(); int start = 10; for(char i = 'A'; i <= 'Z'; i++){ abc.put(start, i); start++; } return abc; } /** * @param number Входное число * @param system Система счисления * @param abc Алфавит * @return Число, переведенное в другую систму счисления * */ private static String getSystemNumber(int number, int system, Map abc){ if(number >= 10 || number >= system){ StringBuilder str = new StringBuilder(); while (number > 0){ int symbol = number % system; if(symbol >= 10){ str.append(abc.get(symbol)); }else { str.append(symbol); } number /= system; } return String.valueOf(str.reverse()); } return String.valueOf(number); } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] dataArr = sc.nextLine().split("/"); int date = Integer.valueOf(dataArr[0]); int month = Integer.valueOf(dataArr[1]); int year = Integer.valueOf(dataArr[2]); int systemNumber = date + 1; Map abc = new TreeMap<>(); if(systemNumber > 9){ abc = getAbc(); } StringBuilder result = new StringBuilder(); result.append(getSystemNumber(date, systemNumber, abc)).append("/") .append(getSystemNumber(month, systemNumber, abc)).append("/") .append(getSystemNumber(year, systemNumber, abc)); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: gnome_entertainment/README.md ================================================

Развлечения гномов (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Гномы свободно владеют системами счисления с разными основаниями и достигли они этого ежедневными тренировками. Именно поэтому каждое утро у гномов начинается с того, что они текущую календарную дату переводят в другую систему счисления. Ваше задание такое же: перевести заданную дату D/M/Y в систему счисления с основанием D+1.

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

Формат ввода

Входной файл input.txt содержит строку, содержащую дату в формате D/M/Y в десятичной системе счисления (1 ≤ D ≤ 31, 1 ≤ M ≤ 12, 1 ≤ Y ≤ 9999).

Формат вывода

В выходной файл output.txt выведите одну строку – дату в формате D/M/Y в системе счисления с основанием D+1.

Примеры

Ввод Вывод
1/10/2000 1/1010/11111010000
================================================ FILE: goldbach_conjecture/GoldbachConjecture.java ================================================ package goldbach_conjecture; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class GoldbachConjecture { private static boolean isSimple(int number) { for (int index = 2; index < number; index++) { if (number % index == 0) { return false; } } return true; } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int numberInput = sc.nextInt(); int[] numbersOutput = new int[2]; for (int index = 2; index <= numberInput/2; index++) { int difference = numberInput - index; if (isSimple(index) && isSimple(difference)) { numbersOutput[0] = index; numbersOutput[1] = difference; break; } } PrintWriter out = new PrintWriter(System.out); out.println(numbersOutput[0] + " " + numbersOutput[1]); out.flush(); } } ================================================ FILE: goldbach_conjecture/README.md ================================================

Гипотеза Гольдбаха (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Известно, что любое чётное число, большее 2, представимо в виде суммы 2 простых чисел, причём таких разложений может быть несколько. Впервые гипотезу о существовании данного разложения сформулировал математик Х. Гольдбах.

Требуется написать программу, производящую согласно утверждению Гольдбаха, разложение заданного чётного числа. Из всех пар простых чисел, сумма которых равна заданному числу, требуется найти пару, содержащую наименьшее простое число.

Формат ввода

Входной файл input.txt содержит чётное число N (4 ≤ N ≤ 998).

Формат вывода

В выходной файл output.txt необходимо вывести два простых числа, сумма которых равна числу N. Первым выводится наименьшее число.

Примеры

Ввод Вывод
6 3 3
992 73 919
================================================ FILE: goldbach_conjecture_two/GoldbachConjectureTwo.java ================================================ package goldbach_conjecture_two; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class GoldbachConjectureTwo { private static boolean isSimple(int number) { for (int index = 2; index < number; index++) { if (number % index == 0) { return false; } } return true; } public static void main(String[] args) throws IOException { int n = new Scanner(new FileReader("input.txt")).nextInt(); int result = 0; for (int i = 2; i <= n/2; i++) { int j = n - i; if (isSimple(i) && isSimple(j)) { result++; } } PrintWriter out = new PrintWriter(System.out); out.println(result); out.flush(); } } ================================================ FILE: goldbach_conjecture_two/README.md ================================================

Гипотеза Гольдбаха - 2 (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

Гипотеза Гольдбаха гласит, что любое четное число большее двух представимо в виде суммы двух простых чисел. Она является одной из самых старых нерешенных задач математики. На март 2004 года, гипотеза Гольдбаха проверена для всех четных чисел, больших 2 и не превышающих 1017.

Ваша задача будет несколько более общей. Задано число x. Необходимо найти число способов представить его в виде суммы ровно двух простых чисел (представления, отличающиеся порядком слагаемых, следует считать одинаковыми).

Напомним, что простым называется натуральное число, большее единицы и делящееся только на единицу и на само себя.

Формат ввода

Входной файл INPUT.TXT содержит натуральное число x (x ≤ 10000).

Формат вывода

В выходной файл OUTPUT.TXT выведите ответ на задачу.

Примеры

Ввод Вывод Пояснение
4 1 4=2+2
10 2 10=3+7=5+5
11 0 11 непредставимо
================================================ FILE: golden_sand/README.md ================================================

Золотой песок (10%)

Время: 1 сек.
Память: 16 Мб
Сложность: 10%

Сотрудники завода по производству золотого песка из воздуха решили поправить свое финансовое положение. Они пробрались на склад завода, где хранился золотой песок трех видов. Один килограмм золотого песка первого вида они смогли бы продать за A1 рублей, второго вида – за A2 рублей, а третьего вида – за A3 рублей. Так получилось, что у сотрудников оказалось с собой только три емкости: первая была рассчитана на B1 килограмм груза, вторая на B2 килограмм, а третья на B3 килограмм. Им надо было заполнить полностью все емкости таким образом, чтобы получить как можно больше денег за весь песок. При заполнении емкостей нельзя смешивать песок разных видов, то есть, в одну емкость помещать более одного вида песка, и заполнять емкости песком так, чтобы один вид песка находился более чем в одной емкости.

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

Формат ввода

В единственной строке входного файла input.txt записано 6 натуральных чисел A1, A2, A3, B1, B2, B3, записанных в одной строке через пробел. Все числа не превосходят 100.

Формат вывода

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

Примеры

Ввод Вывод
1 2 3 3 2 1 14
================================================ FILE: golden_sand/goldenSand.java ================================================ package golden_sand; import java.io.*; import java.util.*; public class goldenSand { public static void main(String[] args) throws IOException { ArrayList price = new ArrayList<>(); ArrayList container = new ArrayList<>(); int profit = 0; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ if(price.size() < 3){ price.add(Integer.valueOf(st.nextToken())); // Записывавем цены }else{ container.add(Integer.valueOf(st.nextToken())); // Записываем емкость } } Collections.sort(price); // Сортируем цены Collections.sort(container); // Сортируем емкости for(int i = 0; i number = new ArrayList<>(); String str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while(st.hasMoreTokens()){ number.add(Integer.valueOf(st.nextToken())); } count = number.get(0) * number.get(0) * number.get(1); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(count)); fileOut.close(); } } ================================================ FILE: gulliver/README.md ================================================

Гулливер (4%)

Время: 1 сек.
Память: 16 Мб
Сложность: 4%

Из книги Джонатана Свифта мы знаем, что тот Гулливер посетил страну «Лилипутию», где живут лилипуты, окруженные вещами, животными и заводами небольшого размера. Сначала лилипуты боялись Гулливера, но позже они поняли, что такое соседство приносит им большую выгоду, и они стали помогать ему. Например, лилипуты делали кровать для Гулливера из своих маленьких матрацев, сшитых вместе. Лилипутам были известны размеры Гулливера. Довольно быстро они смогли просчитать количество матрацев, необходимых для шитья большого матраца. Но у них постоянно возникали сложности с их небольшим ростом и стеля постель, они иногда не могли сшить достаточно толстый матрац.

Формат ввода

Входной файл input.txt содержит два целых числа, которые разделены пробелом: K – коэффициент, отражающий во сколько раз Гулливер больше лилипутов, и M – количество слоев матрацев (2 ≤ K, M ≤ 100).

Формат вывода

В выходной файл output.txt выведите количество матрацев лилипутов, необходимых для построения матраца для Гулливера.

Пример 1

Ввод Вывод
2 2 8
12 4 576
================================================ FILE: hairy_business/HairyBusiness.java ================================================ package hairy_business; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class HairyBusiness { /** * Получить данные по ценам * @return Массив с ценами * */ private static ArrayList _getData() throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); ArrayList data = new ArrayList<>(); boolean isFirstLine = true; while (sc.hasNextLine()) { String line = sc.nextLine(); if (!isFirstLine) { String[] numbers = line.split(" "); for (String number: numbers) { data.add(Integer.parseInt(number)); } } isFirstLine = false; } return data; } /** * Получить индекс максимального элемента массива * @param data Массив с данными * @return Индекс максимиума * */ private static int _getMaxElementIndex(ArrayList data) { int max = 0; int maxIndex = 0; for (int i = 0; i < data.size(); i++) { if (data.get(i) > max) { max = data.get(i); maxIndex = i; } } return maxIndex; } public static void main(String[] args) throws IOException { ArrayList data = _getData(); int maxIndex = _getMaxElementIndex(data); int sum = 0; int tmpCount = 1; // Количество дней, за которое нужно суммировать цену for (int i = 0; i < data.size(); i++) { if (i < maxIndex) { tmpCount++; } else if (i == maxIndex) { sum += tmpCount * data.get(maxIndex); // Занизить значения учтенных цен for (int j = 0; j <= maxIndex; j++) { data.set(j, -1); } maxIndex = _getMaxElementIndex(data); tmpCount = 1; } } PrintWriter out = new PrintWriter(System.out); out.println(sum); out.flush(); } } ================================================ FILE: hairy_business/README.md ================================================

Волосатый бизнес (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

Одного неформала выгнали с работы, и теперь ему надо как-то зарабатывать себе на жизнь. Поразмыслив, он решил, что сможет иметь очень неплохие деньги на продаже собственных волос. Известно, что пункты приема покупают волосы произвольной длины стоимостью С у.е. за каждый сантиметр. Так как волосяной рынок является очень динамичным, то цена одного сантиметра волос меняется каждый день как и курс валют. Неформал является очень хорошим бизнес-аналитиком. Он смог вычислить, какой будет цена одного сантиметра волос в каждый из ближайших N дней (для удобства пронумеруем дни в хронологическом порядке от 0 до N-1). Теперь он хочет определить, в какие из этих дней ему следует продавать волосы, чтобы по истечению всех N дней заработать максимальное количество денег. Заметим, что волосы у неформала растут только ночью и вырастают на 1 сантиметр за ночь. Следует также учесть, что до 0-го дня неформал с горя подстригся наголо и к 0-му дню длина его волос составляла 1 сантиметр.

Формат ввода

В первой строке входного файла INPUT.TXT записано целое число N (0 < N ≤ 100). Во второй строке через пробел заданы N натуральных чисел, не превосходящих 100, соответствующие стоимости C[i] 1 сантиметра волос за каждый i-й день.

Формат вывода

В единственную строку выходного файла OUTPUT.TXT нужно вывести максимальную денежную сумму, которую может заработать неформал за N дней.

Примеры

Ввод Вывод
5
73 31 96 24 46		 380
10
1 2 3 4 5 6 7 8 9 10		 100
10
10 9 8 7 6 5 4 3 2 1		 55
================================================ FILE: hamming_distance/HammingDistance.java ================================================ package hamming_distance; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class HammingDistance { private static int byteCount(String line, String template) { int count = 0; for (int i = 0; i < line.length(); i++) { if (line.charAt(i) == template.charAt(i)) { count++; } } return count; } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int index = -1; String template = ""; int minWay = Integer.MIN_VALUE; ArrayList messageIndex = new ArrayList<>(); while (sc.hasNextLine()) { String line = sc.nextLine(); if (index == -1) { template = line; } else if (index != 0) { int byteCount = byteCount(line, template); if (minWay < byteCount) { minWay = byteCount; messageIndex.clear(); messageIndex.add(index); } else if (minWay == byteCount) { messageIndex.add(index); } } index++; } PrintWriter out = new PrintWriter(System.out); out.println(messageIndex.size()); for (int number: messageIndex) { out.print(number + " "); } out.flush(); } } ================================================ FILE: hamming_distance/README.md ================================================

Издевательство (27%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

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

Из пункта A в пункт B было послано одно из n сообщений m1, m2, ..., mn. В пункте B было принято сообщение s.

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

Расстоянием Хэмминга двух строк a и b одинаковой длины называется количество позиций, в которых эти строки различаются (количество элементов в множестве {i | 1 ≤ i ≤ |a|, ai ≠ bi }).

Формат ввода

Первая строка входного файла input.txt содержит s — принятое сообщение. Вторая строка содержит целое число n — количество сообщений, которые могли быть отправлены. Следующие n строк содержат mi — эти сообщения. Длины всех сообщений равны (|s| = |m1| = |m2| = ... = |mn|). Сообщения непустые, состоят только из символов 0 и 1. Размер входного файла не превосходит 60 Кб.

Формат вывода

В первую строку выходного файла output.txt выведите k — количество сообщений, на которых достигается минимум расстояния Хэмминга. Во вторую строку выведите в порядке возрастания k чисел — номера этих сообщений.

Примеры

Ввод Вывод
010101
3
110011
011001
000111		 2
2 3
================================================ FILE: heron/Heron.java ================================================ package heron; import java.io.*; import java.util.*; public class Heron { private static ArrayList data = new ArrayList<>(); private static int min = 0; private static int max = 0; private static void minMax(){ // Определение минимального и максимального количества цапель if(data.get(0) == data.get(1) * 2){ min = data.get(0); max = data.get(0); }else if(data.get(0).equals(data.get(1))){ min = (data.get(0) % 2 == 0) ? data.get(0) / 2 : data.get(0) / 2 + 1; max = data.get(0); }else{ min = (data.get(1) % 2 == 0) ? data.get(1) / 2 : data.get(1) / 2 + 1; max = data.get(0); } } public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } Collections.sort(data); minMax(); String result = min + " " + max; System.out.println(result); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: heron/README.md ================================================

Цапли (15%)

Время: 1 сек.
Память: 16 Мб
Сложность: 15%

Петя и Маша пришли в зоопарк. Больше всего Пете понравились цапли. Он был поражен их способностью спать на одной ноге. В вольере находятся несколько цапель. Некоторые из них стоят на двух ногах, некоторые — на одной. Когда цапля стоит на одной ноге, то другую ее ногу не видно. Петя пересчитал видимые ноги всех цапель, и у него получилось число a. Через несколько минут к вольеру подошла Маша. За это время некоторые цапли могли поменять позу, поэтому Петя предложил ей заново пересчитать видимые ноги цапель. Когда Маша это сделала, у нее получилось число b. Выйдя из зоопарка, Петя с Машей заинтересовались, сколько же всего цапель было в вольере. Вскоре ребята поняли, что однозначно определить это число можно не всегда. Теперь они хотят понять, какое минимальное и какое максимальное количество цапель могло быть в вольере.

Требуется написать программу, которая по заданным числам a и b выведет минимальное и максимальное количество цапель, которое могло быть в вольере.

Формат ввода

Входной файл input.txt содержит два целых числа a и b, разделенных ровно одним пробелом (1 ≤ a ≤ 109, 1 ≤ b ≤ 109).

Формат вывода

В выходной файл output.txt выведите два целых числа, разделенных пробелом — минимальное и максимальное число цапель, которое могло быть в вольере. Гарантируется, что хотя бы одно количество цапель соответствует условию задачи.

Примеры

Ввод Вывод
3 4 2 3
================================================ FILE: hockey/Hockey.java ================================================ package hockey; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class Hockey { public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); long teamCount = sc.nextLong(); long twoTeam = (teamCount -1 > 0) ? teamCount -1 : 1; long threeTeam = (twoTeam-1 > 0) ? twoTeam-1 : 1; long combinationCount = teamCount * twoTeam * threeTeam; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(combinationCount)); fileOut.close(); } } ================================================ FILE: hockey/README.md ================================================

Хоккей (21%)

Время: 1 сек.
Память: 16 Мб
Сложность: 21%

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

Формат ввода

Входной файл input.txt содержит целое число N (1 ≤ N ≤ 104) – количество команд.

Формат вывода

В выходной файл output.txt выведите единственное число – искомое количество способов награждения участников.

Примеры

Ввод Вывод
3 6
20 6840
================================================ FILE: home_school/HomeSchool.java ================================================ package home_school; import java.util.*; import java.io.*; public class HomeSchool { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ data.add(sc.nextLine()); } } public static void main(String[] argv) throws IOException{ getData(); String stationStart = data.get(0); int travelCount = Integer.valueOf(data.get(1)); String result = (stationStart.equals("School") && travelCount % 2 == 0) ? "No" : "Yes"; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: home_school/README.md ================================================

Дом - Школа - Дом (21%)

Время: 1 сек.
Память: 16 Мб
Сложность: 21%

Мальчик Вася каждый день ездит на метро. Утром он едет в школу, а вечером того же дня, обратно из школы, домой. Для того, чтобы немного сэкономить, он покупает электронную смарт-карту на X поездок. Когда он хочет зайти в метро, он прикладывает карту к турникету. Если на карте осталось ненулевое количество поездок, то турникет пропускает Васю и списывает с карты одну поездку. Если же на карте не осталось поездок, то турникет не пропускает Васю, и он (Вася) вынужден купить на этой же станции новую карту на X поездок и вновь пройти через турникет.

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

Вася больше никуда на метро не ездит и поэтому заходит в метро только на станции около дома и на станции около школы.

Формат ввода

Во входном файле input.txt содержится ровно 2 строки. В первой содержится слово «School» или «Home» в зависимости от того, где первый раз Вася купил карточку на X поездок. Во второй строке содержится натуральное число X, 1 ≤ X ≤ 1000.

Формат вывода

В выходной файл output.txt следует вывести «Yes», если будет такой день, что дома утром у Васи на карточке окажется ноль поездок и «No» в противном случае.

Примеры

Ввод Вывод
Home
1		 Yes
School
2		 No
================================================ FILE: homework/Homework.java ================================================ package homework; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class Homework { private static long multi(ArrayList data, long min, long max, int minIndex, int maxIndex){ long multi = 1; boolean start = false; for(int number : data){ if(minIndex < maxIndex){ if(number == max){ start = false; break; } if(start){ multi *= number; } if(number == min){ start = true; } }else { if(number == min){ start = false; break; } if(start){ multi *= number; } if(number == max){ start = true; } } } return multi; } public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } data.remove(0); long sum = 0, min = data.get(0), max = data.get(0); int minIndex = 0, maxIndex = 0; for(int i = 0; i < data.size(); i++){ if(data.get(i) > 0){ sum += data.get(i); } if(data.get(i) < min){ min = data.get(i); minIndex = i; } if(data.get(i) > max){ max = data.get(i); maxIndex = i; } } long multi = multi(data, min, max, minIndex, maxIndex); String result = sum + " " + multi; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: homework/README.md ================================================

Домашнее задание (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Петя успевает по математике лучше всех в классе, поэтому учитель задал ему сложное домашнее задание, в котором нужно в заданном наборе целых чисел найти сумму всех положительных элементов, затем найти где в заданной последовательности находятся максимальный и минимальный элемент и вычислить произведение чисел, расположенных в этой последовательности между ними. Так же известно, что минимальный и максимальный элемент встречаются в заданном множестве чисел только один раз и не являются соседними. Поскольку задач такого рода учитель дал Пете около ста, то Петя как сильный программист смог написать программу, которая по заданному набору чисел самостоятельно находит решение. А Вам слабо?

Формат ввода

В первой строке входного файла input.txt записано единственное число N – количество элементов массива. Вторая строка содержит N целых чисел, представляющих заданный массив. Все элементы массива разделены пробелом. Каждое из чисел во входном файле, в том числе и N, не превышает 102 по абсолютной величине.

Формат вывода

В единственную строку выходного файла output.txt нужно вывести два числа, разделенных пробелом: сумму положительных элементов и произведение чисел, расположенных между минимальным и максимальным элементами. Значения суммы и произведения не превышают по модулю 3*104.

Примеры

Ввод Вывод
5
-7 5 -1 3 9		 17 -15
8
3 14 -9 4 -5 1 -12 4		 26 180
10
-5 1 2 3 4 5 6 7 8 -3		 36 5040
================================================ FILE: honey/Honey.java ================================================ package honey; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class Honey { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ data.add(Long.valueOf(st.nextToken())); } long n = data.get(0); long v = data.get(1); long k = data.get(2); boolean empty = false; long honey = 0; long minus = k; for(int i = 0; i < n; i++){ if(i == 0){ honey += v; }else { if(minus >= v){ minus = v; empty = true; } honey += (v - minus); minus += k; } } String result = (empty) ? "NO " + honey : "YES " + honey; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: honey/README.md ================================================

Мёд (23%)

Время: 1 сек.
Память: 16 Мб
Сложность: 23%

Все любят сладости и, в частности, мед. Винни-Пух тоже его любит. Каждый день он шел лакомиться медом, а по дороге домой заходил в гости к Кролику. Но приближалась зима, и Винни-Пух начал задумываться о запасах. Он решил в течении N дней не лакомиться медом, а собирать полный горшочек объемом V горстей и перекладывать его в бочку. В первый день своего собирательства он так и сделал. Терпения хватило на один день. А на следующий день он не смог устоять и по дороге домой съел K горстей меда из горшочка. В каждый следующий день из полного горшочка он съедал на K горстей больше.

Необходимо определить объем меда, собранного Винни-Пухом на зиму.

Формат ввода

Входной файл input.txt содержит три натуральных числа N (N ≤ 300), V (V ≤ 107) и K (K ≤ 1000). K – объем, на который Винни-Пух с каждым днем съедал больше меда.

Формат вывода

В выходной файл OUTPUT.TXT выведите два значения через пробел. Сначала идет строка «NO», если случилось, что Винни-Пух пришел к Кролику с пустым горшочком и «YES» в противном случае. Второе значение – объем меда, заготовленного Винни-Пухом на зиму.

Примеры

Ввод Вывод
15 100 10 NO 550
10 10 1 YES 55
================================================ FILE: horse/Horse.java ================================================ package horse; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class Horse { private static ArrayList move (String cellFrom) { ArrayList firstMove = new ArrayList<>(); char character = cellFrom.charAt(0); int number = Integer.parseInt(cellFrom.substring(1)); if (character-2 >= 'a' && number-1 >= 1) { firstMove.add(String.valueOf((char)(character-2)) + (number - 1)); } if (character-1 >= 'a' && number-2 >= 1) { firstMove.add(String.valueOf((char)(character-1)) + (number - 2)); } if (character-2 >= 'a' && number+1 <= 8) { firstMove.add(String.valueOf((char)(character-2)) + (number + 1)); } if (character-1 >= 'a' && number+2 <= 8) { firstMove.add(String.valueOf((char)(character-1)) + (number + 2)); } if (character+2 <= 'h' && number-1 >= 1) { firstMove.add(String.valueOf((char)(character+2)) + (number - 1)); } if (character+1 <= 'h' && number-2 >= 1) { firstMove.add(String.valueOf((char)(character+1)) + (number - 2)); } if (character+2 <= 'h' && number+1 <= 8) { firstMove.add(String.valueOf((char)(character+2)) + (number + 1)); } if (character+1 <= 'h' && number+2 <= 8) { firstMove.add(String.valueOf((char)(character+1)) + (number + 2)); } return firstMove; } public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); String[] cells = new Scanner(new FileReader("input.txt")).nextLine().split(", "); String cellFrom = cells[0]; String cellTo = cells[1]; ArrayList firstMove = move(cellFrom); if (firstMove.contains(cellTo)) { out.println(1); } else { boolean flag = false; for (String cell : firstMove) { ArrayList secondMove = move(cell); if (secondMove.contains(cellTo)) { out.println(2); flag = true; break; } } if (!flag) { out.println("NO"); } } out.flush(); } } ================================================ FILE: horse/README.md ================================================

Мы с конем вдвоем по полю пойдем (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

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

Формат ввода

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

Формат вывода

Выходной файл output.txt должен содержать цифру «1», если возможно из одной клетки в другую попасть за 1 ход, либо цифру «2», если попасть можно за 2 хода, либо «NO», если одна клетка недостижима из другой ни за 1 ни за 2 хода.

Примеры

Ввод Вывод
a1, h8 NO
a1, b3 1
a1, d4 2
================================================ FILE: horse_racing/HorseRacing.java ================================================ package horse_racing; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.*; public class HorseRacing { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] firstLine = sc.nextLine().split(" "); int n = Integer.parseInt(firstLine[0]); int k = Integer.parseInt(firstLine[1]); Map> data = new TreeMap<>(); while (sc.hasNextLine()){ String[] line = sc.nextLine().split(" "); if (line.length == 2) { int winner = Integer.parseInt(line[0]); int looser = Integer.parseInt(line[1]); Set losersHorse = new HashSet<>(); if (data.get(winner) != null) { losersHorse = data.get(winner); } losersHorse.add(looser); data.put(winner, losersHorse); } } PrintWriter out = new PrintWriter(System.out); if (data.size() == 0) { out.println("Yes"); } else if (data.get(k) == null) { out.println("No"); } else { // проверяем только интересующую нас лошадь Set losers = data.get(k); Set losersResult = new HashSet<>(losers); for (int loser : losers) { losersResult.addAll(findAllLosers(data, new HashSet<>(), new int[n+1], loser)); } if (losersResult.size() == n-1) { out.println("Yes"); } else { out.println("No"); } } out.flush(); } /** * Получить всех проигравших лоошадей * @param data Начальные данные * @param losers Програвшие для конкретной лошади * @param checked Уже проверенные лошади * @param horseNumber Номер лошади * @return Список всех програвших * */ public static Set findAllLosers(Map> data, Set losers, int[] checked, int horseNumber) { if (data.get(horseNumber) != null && checked[horseNumber] == 0) { checked[horseNumber] = 1; Set tmp = data.get(horseNumber); losers.addAll(data.get(horseNumber)); for (int loser : tmp) { losers.addAll(findAllLosers(data, losers, checked, loser)); } } return losers; } } ================================================ FILE: horse_racing/README.md ================================================

Скачки (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

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

Требуется написать программу, которая поможет Ивану Ивановичу точно определить может ли выиграть выбранная им лошадь.

Формат ввода

Входной файл INPUT.TXT содержит в первой строке два целых числа N (1 ≤ N ≤ 100) и K (1 ≤ K ≤ N), где N – количество лошадей, принимающих участие в скачках, K – номер лошади, на которую хочет сделать ставку Иван Иванович. Следующие строки содержат по два числа X и Y (1 ≤ X, Y ≤ N), обозначающие, что лошадь с номером X быстрее лошади с номером Y. Пары X и Y не повторяются. Набор данных завершается строкой, содержащей единственный ноль. Эту строку обрабатывать не надо.

Гарантируется, что информация, раздобытая Иваном Ивановичем, корректна.

Формат вывода

Выходной файл OUTPUT.TXT должен содержать слово «Yes», если Иван Иванович уверен в своем выигрыше и «No» в противном случае.

Примеры

Ввод Вывод
3 1
1 2
1 3
0		 Yes
3 2
2 3
0		 No
4 2
3 1
2 3
0		 No
================================================ FILE: hunter/Hunter.java ================================================ package hunter; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class Hunter { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); int maxTargetCount; Scanner scan = new Scanner(new FileReader("input.txt")); while (scan.hasNextLine()){ String[] point = scan.nextLine().split(" "); if(point.length == 2){ int x = Integer.valueOf(point[0]); int y = Integer.valueOf(point[1]); data.add(new int[]{x, y}); } } int x0 = 0, y0 = 0; Map directions = new HashMap<>(); directions.put("one", 0); directions.put("two", 0); directions.put("three", 0); directions.put("four", 0); directions.put("xplus", 0); directions.put("yplus", 0); directions.put("xminus", 0); directions.put("yminus", 0); if(data.size() != 0){ for (int i = 0; i < data.size(); i++) { int x1 = data.get(i)[0]; int y1 = data.get(i)[1]; for (int[] point : data) { int x2 = point[0]; int y2 = point[1]; if ((x0 - x2) * (y1 - y2) == (x1 - x2) * (y0 - y2)) { int count; if(x1 > 0 && y1 > 0 && x2 > 0 && y2 > 0){ count = directions.get("one") + 1; directions.put("one", count); }else if(x1 < 0 && y1 > 0 && x2 < 0 && y2 > 0){ count = directions.get("two") + 1; directions.put("two", count); }else if(x1 < 0 && y1 < 0 && x2 < 0 && y2 < 0){ count = directions.get("three") + 1; directions.put("three", count); }else if(x1 > 0 && y1 < 0 && x2 > 0 && y2 < 0){ count = directions.get("four") + 1; directions.put("four", count); }else if(x1 > 0 && y1 == 0 && x2 > 0 && y2 == 0){ count = directions.get("xplus") + 1; directions.put("xplus", count); }else if(x1 < 0 && y1 == 0 && x2 < 0 && y2 == 0){ count = directions.get("xminus") + 1; directions.put("xminus", count); }else if(x1 == 0 && y1 > 0 && x2 == 0 && y2 > 0){ count = directions.get("yplus") + 1; directions.put("yplus", count); }else if(x1 == 0 && y1 < 0 && x2 == 0 && y2 < 0){ count = directions.get("yminus") + 1; directions.put("yminus", count); } } } } } maxTargetCount = (int)(Math.sqrt(Collections.max(directions.entrySet(), Map.Entry.comparingByValue()).getValue())); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(maxTargetCount)); out.close(); } } ================================================ FILE: hunter/README.md ================================================

Охотник (27%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Сезон охоты очень не долог, и поэтому оставшуюся часть года заядлые охотники развлекают себя тем, что стреляют по мишеням в тире. Тир представляет собой плоскость, на которой расставлены мишени. Размерами мишеней можно пренебречь и считать их точками с координатами (x, y). Также известно, что мишени сделаны из картона, поэтому за один выстрел можно поразить сразу все мишени, стоящие на линии выстрела. В начале координат стоит охотник и у него остался последний патрон. Охотник хочет использовать его эффективно – то есть за один выстрел поразить как можно больше целей. Помогите ему в этом.

Формат ввода

В первой строке входного файла input.txt находится натуральное число N (N ≤ 100) – количество мишеней в тире. Далее следует N строк – описание мишеней. В (i+1)-й строке находится два целых числа x и y (-100 ≤ x, y ≤ 100) – координаты i-й мишени. Не существует двух мишеней, стоящих в одной точке, и никакая мишень не стоит в начале координат.

Формат вывода

В выходной файл output.txt выведите максимальное количество мишеней, которое может подстрелить охотник за один выстрел.

Примеры

Ввод Вывод
1
1 1		 1
2
1 1
2 2		 2
3
1 0
2 0
0 1		 2
================================================ FILE: idler/Idler.java ================================================ package idler; import java.util.*; import java.io.*; public class Idler { private static ArrayList data = new ArrayList<>(); private static ArrayList dateStart = new ArrayList<>(); private static ArrayList dateFinish = new ArrayList<>(); private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String string = sc.nextLine(); StringTokenizer st = new StringTokenizer(string, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } data.remove(0); } public static void main(String[] argv) throws IOException{ getData(); for(int i = 0; i < data.size(); i++){ if(i % 2 == 0){ // Первая дата dateStart.add(data.get(i)); }else{ // Последняя дата dateFinish.add(data.get(i)); } } dateStart.sort(Collections.reverseOrder()); // Сортируем первую дату в обратном порядке Collections.sort(dateFinish); // Сортируем последнюю дату по возрастанию String result = (dateStart.get(0) <= dateFinish.get(0)) ? "YES" : "NO"; System.out.println(result); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: idler/README.md ================================================

Лентяй (21%)

Время: 1 сек.
Память: 16 Мб
Сложность: 21%

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

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

Формат ввода

В первой строке входного файла input.txt содержится натуральное число N – количество предметов, которые нужно сдать Валере (N ≤ 100). Далее идет N строк, каждая из которых состоит из двух чисел A и B, задающих отрезок работы очередного преподавателя (1 ≤ A ≤ B ≤ 31).

Формат вывода

В выходной файл output.txt выведите «YES», если возможно встретить всех преподавателей за один день, или «NO», если это сделать невозможно.

Примеры

Ввод Вывод
1
1 2		 YES
2
1 2
3 4		 NO
3
1 8
3 5
4 9		 YES
================================================ FILE: in_bus/README.md ================================================

В автобусе (18%)

Время: 1 сек.
Память: 16 Мб
Сложность: 18%

Цена проезда в автобусах нашего города — один рубль. Однако, не все так просто — каждый взрослый пассажир имеет право провезти бесплатно не более одного ребенка. Это значит, что взрослый пассажир, который провозит с собой k (k > 0) детей, платит всего k рублей: за один билет для себя и за (k - 1) билетов для своих детей. Также взрослый может ехать без детей, в этом случае он платит всего один рубль. Известно, что дети не могут проезжать в автобусе без сопровождения взрослых.

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

Формат ввода

Входной файл input.txt содержит два целых числа n и m (0 ≤ n, m ≤ 105) — количество взрослых и количество детей в автобусе, соответственно.

Формат вывода

В выходной файл output.txt выведите через пробел два числа — минимальную и максимальную возможную стоимость проезда, если поездка возможна, в противном случае следует вывести «Impossible» (без кавычек).

Примеры

Ввод Вывод
1 2 2 2
0 5 Impossible
2 2 2 3
================================================ FILE: in_bus/inBus.java ================================================ package in_bus; import java.util.*; import java.io.*; public class inBus { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } public static void main(String[] argv) throws IOException{ getData(); int min = (data.get(0) >= data.get(1)) ? data.get(0) : data.get(1); int max = (data.get(1) == 0) ? data.get(0) : data.get(0) + (data.get(1) - 1); String result = (data.get(0) == 0 && data.get(1) == 0) ? 0 + " " + 0 : (data.get(0) != 0) ? min + " " + max : "Impossible"; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: java_vs_pcc/JavaVsPcc.java ================================================ package java_vs_pcc; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class JavaVsPcc { private static boolean isUpperCase(char symbol) { return String.valueOf(symbol).equals(String.valueOf(symbol).toUpperCase()); } public static void main(String[] args) throws IOException { String command = new Scanner(new FileReader("input.txt")).nextLine(); StringBuilder newCommand = new StringBuilder(); if (command.contains("_") && command.charAt(0) != '_' && command.charAt(command.length()-1) != '_' && !command.contains("__") ) { String[] tmp = command.split("_"); for (String path: tmp) { if (path.length() == 0) { break; } String upperCase = String.valueOf(path.charAt(0)).toUpperCase(); if (upperCase.equals(String.valueOf(path.charAt(0))) || !path.toLowerCase().equals(path)) { newCommand = new StringBuilder(); newCommand.append("Error!"); break; } if (newCommand.length() == 0) { newCommand.append(path); } else { newCommand.append(upperCase); if (path.length() >= 2) { newCommand.append(path.substring(1)); } } } } else if (!command.contains("_")) { char[] tmp = command.toCharArray(); for (char symbol: tmp) { if (newCommand.length() == 0 && isUpperCase(symbol)) { newCommand.append("Error!"); break; } if (newCommand.length() == 0) { newCommand.append(symbol); } else if (isUpperCase(symbol)) { newCommand.append("_"); newCommand.append(String.valueOf(symbol).toLowerCase()); } else { newCommand.append(symbol); } } } if (newCommand.length() == 0) { newCommand.append("Error!"); } PrintWriter out = new PrintWriter(System.out); out.print(newCommand); out.flush(); } } ================================================ FILE: java_vs_pcc/README.md ================================================

Java vs C++ (34%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 34%

Сторонники языков Java и C++ часто спорят о том, какой язык лучше для решения олимпиадных задач. Одни говорят, что в Java есть масса полезных библиотек для работы со строками, хорошо реализованы механизмы чтения и вывода данных, а так же радует встроенные возможности для реализации длинной арифметики. С другой стороны, С++ является классическим языком, скорость выполнения программ благодаря существующим компиляторам (например, Intel Compiler 10.0) гораздо выше, чем у Java.

Но сейчас нас интересует лишь небольшие отличия, а именно соглашения, которыми пользуются программисты при описании имен переменных в Java и C++. Известно, что для понимания значений переменных часто используют английские слова или даже целые предложения, описывающие суть переменных, содержащих те или иные значения. Приведем ниже правила описания переменных, которыми руководствуются программисты, реализующие программы на Java и C++.

В языке Java принято первое слово, входящее в название переменной записывать с маленькой английской буквы, следующее слово идет с большой буквы (только первая буква слова большая), слова не имеют разделителей и состоят только из английских букв. Например, правильные записи переменных в Java могут выглядеть следующим образом: javaIdentifier, longAndMnemonicIdentifier, name, nEERC.

В языке C++ для описания переменных используются только маленькие английские символы и символ «_», который отделяет непустые слова друг от друга. Примеры: java_identifier, long_and_mnemonic_identifier, name, n_e_e_r_c.

Вам требуется написать программу, которая преобразует переменную, записанную на одном языке в формат другого языка.

Формат ввода

Во входном файле INPUT.TXT задано наименование переменной длиной от 1 до 100 символов, в котором могут встречаться только заглавные и строчные буквы английского алфавита, а также символ подчёркивания.

Формат вывода

В выходной файл OUTPUT.TXT требуется вывести аналог имени переменной в другом языке. Т.е. если переменная представлена в формате Java, то следует перевести в формат C++ и наоборот. В том случае, когда имя переменной не соответствует ни одному из вышеописанных языков, следует вывести «Error!»

Примеры

Ввод Вывод
long_and_mnemonic_identifier longAndMnemonicIdentifier
anotherExample another_example
i i
bad_Style Error!
================================================ FILE: jumpy_journey/JumpyJourney.java ================================================ package jumpy_journey; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class JumpyJourney { public static void main(String[] args) throws IOException { ArrayList coordinate = new ArrayList<>(); int[] frog = new int[2]; int lengthTongue = 0; Scanner sc = new Scanner(new FileReader("input.txt")); int index = 0; while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ if(index == 0){ int n = Integer.valueOf(st.nextToken()); frog = new int[]{Integer.valueOf(st.nextToken()), Integer.valueOf(st.nextToken())}; lengthTongue = Integer.valueOf(st.nextToken()); }else { coordinate.add(new int[]{Integer.valueOf(st.nextToken()), Integer.valueOf(st.nextToken())}); } } index++; } int countJump = 0; for(int i = 0; i < coordinate.size(); i++){ double distance = Math.sqrt(Math.pow(coordinate.get(i)[0] - frog[0], 2) + Math.pow(coordinate.get(i)[1] - frog[1], 2)); if(distance <= lengthTongue){ countJump = i+1; break; } } String result = countJump == 0 ? "Yes" : String.valueOf(countJump); FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: jumpy_journey/README.md ================================================

Прыгучее путешествие (24%)

Время: 1 сек.
Память: 16 Мб
Сложность: 24%

Кузнечик Тёма очень любит прыгать по полянке, на которой он живет. Но однажды беда обрушилась на его голову. На его полянке поселилась злобная лягушка, которая была бы не против полакомиться кузнечиком Тёмой. Однако Тёма решил не унывать и все-таки продолжать прыгать и резвиться на полянке. Однако теперь ему надо делать это весьма осторожно. Для этого он хочет составить план своего путешествия.

Тёма хочет посетить точки A1=(x1, y1), A2=(x2, y2), ..., An=(xn, yn) (можно считать, что изначально он находится в точке A1, затем прыгает в точку A2, потом в A3 и т.д.). Так же ему известно, что лягушка живет в точке B=(x, y) и имеет длину языка L. Таким образом, если после приземления Тёма оказывается на расстоянии не более L от точки B, то лягушка его съест, то есть лягушка может съесть Тёму только, когда он находится на земле. Во время полета съесть Тёму лягушка не может.

Ваша задача помочь Тёме определить, будет ли он съеден лягушкой или нет.

Формат ввода

В первой строке входного файла input.txt записано целое число N (1 ≤ N ≤ 105), координаты точки B и число L (0 ≤ L ≤ 5000). В следующих N строках записаны координаты точек Ai. Все координаты – это целые числа по модулю не превосходящие 104.

Формат вывода

В выходной файл output.txt выведите «Yes», если кузнечик успешно завершит свое путешествие в точке An и не будет съеден в ней. Иначе выведите номер точки, после приземления в которую Тёму съест лягушка. Если Тёма может быть съеден лягушкой в нескольких точках, выведите точку, заданную раньше во входном файле (лягушка, разумеется, использует свой первый шанс, чтобы съесть кузнечика).

Примеры

Ввод Вывод
3 0 0 1
2 0
1 1
0 1		 3
2 0 0 100
1 1
2 2		 1
3 0 0 1
1 1
2 2
3 3		 Yes
================================================ FILE: k_numbers/KNumbers.java ================================================ package k_numbers; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class KNumbers { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); long number = sc.nextLong(); int count = 0; for(long firstPart = 1; firstPart < number; firstPart++){ long secondPart = number - firstPart; int lastSymbolFirstPart = (int)firstPart % 10; int lastSymbolSecondPart = (int)secondPart % 10; int firstSymbolSecondPart = Integer.valueOf(String.valueOf(secondPart).substring(0, 1)); if(lastSymbolFirstPart == firstSymbolSecondPart && (lastSymbolFirstPart + lastSymbolSecondPart) % 10 == (int) number % 10){ StringBuilder overNumber = new StringBuilder(); long numberCopy = secondPart; while (numberCopy > 0){ long digit = numberCopy % 10; overNumber.append(digit); numberCopy /= 10; } long overNumberLong = Long.valueOf(String.valueOf(overNumber)); if(firstPart == overNumberLong){ count++; } } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(count)); out.close(); } } ================================================ FILE: k_numbers/README.md ================================================

К-удивительные числа (25%)

Время: 3 сек.
Память: 16 Мб
Сложность: 25%

Переворотом числа X назовем число, в котором все цифры числа X стоят в обратном порядке. Например, переворотом числа 6372 является число 2736, а числа 7800 - 87. Назовем K-удивительным такое число, которое в сумме со своим переворотом дает число K.

Например, у числа 222 имеется всего два K-удивительных числа: 111 и 210, а у числа 1050 имеется девять K-удивительных числа: 129, 228, 327, 426, 525, 624, 723, 822, 921.

Требуется написать программу, которая по заданному K определит количество K-удивительных чисел.

Формат ввода

Входной файл input.txt содержит одно натуральное число K (1 ≤ K ≤ 106).

Формат вывода

Выходной файл output.txt должен содержать одно число - количество K-удивительных чисел.

Примеры

Ввод Вывод
222 2
1050 9
================================================ FILE: keyboard/Keyboard.java ================================================ package keyboard; import java.io.*; import java.util.*; public class Keyboard { private static String result; public static void main(String[] args) throws IOException { String allButton = "qwertyuiopasdfghjklzxcvbnm"; // Все символы клавиатуры String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); char[] ch = allButton.toCharArray(); // Переписываем символы строки в массив for(int i = 0; i < allButton.length(); i++){ if(str.equals(String.valueOf(ch[i]))){ // Если символ в строке совпал с символом из файла if(i+1 < allButton.length()){ // Если есть еще 1 символ в строке result = String.valueOf(ch[i+1]); // Находим следующий символ }else { result = String.valueOf(ch[0]); // Если в строке нет символов далее, то начать сначала } } } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: keyboard/README.md ================================================

Клавиатура (11%)

Время: 1 сек.
Память: 16 Мб
Сложность: 11%

Для данной буквы английского алфавита нужно вывести справа стоящую букву на стандартной клавиатуре. При этом клавиатура замкнута, т.е. справа от буквы «p» стоит буква «a», от буквы «l» стоит буква «z», а от буквы «m» — буква «q».

Формат ввода

Первая строка входного файла input.txt содержит один символ — маленькую букву английского алфавита.

Формат вывода

В выходной файл output.txt следует вывести букву стоящую справа от заданной буквы, с учетом замкнутости клавиатуры.

Примеры

Ввод Вывод
q w
t y
m q
================================================ FILE: keyboard_two/KeyboardTwo.java ================================================ package keyboard_two; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.HashMap; import java.util.Map; import java.util.Scanner; import java.util.StringTokenizer; public class KeyboardTwo { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); Map keyboardInfo = new HashMap<>(); Map keyboardUse = new HashMap<>(); int index = 0; while (sc.hasNextLine()){ String line = sc.nextLine(); if(index == 1){ StringTokenizer st = new StringTokenizer(line, " "); int number = 1; while (st.hasMoreTokens()){ keyboardInfo.put(number, Integer.valueOf(st.nextToken())); keyboardUse.put(number, 0); number++; } }else if(index == 3){ StringTokenizer st = new StringTokenizer(line, " "); while (st.hasMoreTokens()){ int number = Integer.valueOf(st.nextToken()); if(keyboardUse.containsKey(number)){ int val = keyboardUse.get(number); val++; keyboardUse.put(number, val); } } } index++; } StringBuilder result = new StringBuilder(); for(Integer key : keyboardUse.keySet()){ if(keyboardUse.get(key) > keyboardInfo.get(key)){ result.append("yes").append("\n"); }else { result.append("no").append("\n"); } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: keyboard_two/README.md ================================================

Клавиатура - 2 (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

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

При изготовлении клавиатуры изначально для каждой клавиши задается количество нажатий, которое она должна выдерживать. Если знать эти величины для используемой клавиатуры, то для определенной последовательности нажатых клавиш можно определить, какие клавиши в процессе их использования сломаются, а какие – нет.

Требуется написать программу, определяющую, какие клавиши сломаются в процессе заданного варианта эксплуатации клавиатуры.

Формат ввода

Первая строка входного файла input.txt содержит целое число N (1 ≤ N ≤ 100) – количество клавиш на клавиатуре. Вторая строка содержит n целых чисел – с1, с2, … , сN, где сi (1 ≤ сi ≤ 100000) – количество нажатий, выдерживаемых i-ой клавишей. Третья строка содержит целое число K (1 ≤ K ≤ 100000) – общее количество нажатий клавиш, и последняя строка содержит K целых чисел pj (1 ≤ pj ≤ N) – последовательность нажатых клавиш.

Формат вывода

В выходной файл output.txt необходимо вывести N строк, содержащих информацию об исправности клавиш. Если i-ая клавиша сломалась, то i-ая строка должна содержать слово "yes" (без кавычек), если же клавиша работоспособна – слово "no".

Примеры


Ввод Вывод
5
1 50 3 4 3
16
1 2 3 4 5 1 3 3 4 5 5 5 5 5 4 5		 yes
no
no
no
yes
================================================ FILE: known_everybody/KnownEverybody.java ================================================ package known_everybody; import java.io.*; import java.util.*; public class KnownEverybody { private static String result = "YES"; // Значение по умолчанию public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); char[] ch = str.toCharArray(); for (char aCh : ch) { int symbol = Character.getNumericValue(aCh); if (symbol == 0) { result = "NO"; // Если есть хотя бы 1 ноль break; } } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: known_everybody/README.md ================================================

Всем известно (14%)

Время: 1 сек.
Память: 16 Мб
Сложность: 14%

Всем известно, что многие олимпиадные задачи начинаются со слов «Всем известно». Но мало кто знает, что начинающему программисту Паше такие задачи меньше всего нравятся. Потому что обычно после слов «всем известно» описывается такой факт, о котором он даже не догадывался. После очередной подобной задачи Паша решил проверить, а действительно ли всем известно, что сумма первых N нечетных чисел равняется N2.

Для этого Паша провел опрос всех людей, попавшихся ему под руку в известной социальной сети. Результаты опроса он записал в текстовый файл. Он ставил цифру один, если человеку был действительно известен данный факт, в противном случае в файл записывался нуль. Все было хорошо, пока Паша не открыл файл и не ужаснулся, увидев длинную последовательность из единичек. Как же он теперь будет искать среди них нули?

Уже всем известно, что Паша – начинающий программист, поэтому для обработки результатов исследования он обратился к вам за помощью.

Формат ввода

Входной файл input.txt содержит непустую последовательность из нулей и единиц. Длина последовательности не превышает 104.

Формат вывода

В выходной файл output.txt выведите слово «YES», если факт был известен всем опрошенным людям, и слово "NO" в противном случае.

Примеры

Ввод Вывод
11111101010011 NO
11 YES
================================================ FILE: language_recognition/LanguageRecognition.java ================================================ package language_recognition; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; public class LanguageRecognition { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); int lineNumber = 0; while (sc.hasNextLine()){ String line = sc.nextLine(); if(lineNumber != 0){ data.add(line); } lineNumber++; } StringBuilder result = new StringBuilder(); for(String line : data){ int zero = 0, one = 0, two = 0, check = 0, other = 0; char[] lineArray = line.toCharArray(); for(char i : lineArray){ int number = i - '0'; if(number == 0 && check == 0){ zero += 1; }else if(number == 1 && check == 0){ check = 1; one += 1; }else if(number == 1 && check == 1){ one += 1; }else if(number == 2 && check == 1){ check = 2; two += 1; }else if(number == 2 && check == 2){ two += 1; }else { other += 1; } } if(other == 0 && zero == one && one == two){ result.append("YES").append("\n"); }else { result.append("NO").append("\n"); } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result).trim()); out.close(); } } ================================================ FILE: language_recognition/README.md ================================================

Распознавание языка (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Важным понятием теории формальных грамматик и автоматов является формальный язык. Неформально его можно определить как некоторое множество слов, где под словом понимается некоторая строка из символов.

В этой задаче необходимо проверить, принадлежит ли данное слово языку {0n1n2n, n ≥ 1}. В этот язык входят те и только те слова, которые имеют такую структуру: в них нулей столько же, сколько единиц, а единиц - столько же, сколько и двоек. При этом любой ноль находится ближе к началу слова, чем любая единица, а любая единица находится ближе к началу слова, чем любая двойка. Например, слово 001122 принадлежит этому языку, а слово 0000111122220 - не принадлежит.

Формат ввода

Первая строка входного файла input.txt содержит целое положительное число n (n ≤ 10) – количество слов, которые надо проанализировать. Далее идут n строк, каждая из которых содержит по одному слову. Слова имеют длину не более тридцати тысяч символов и состоят только из нулей, единиц и двоек. Каждое из слов состоит хотя бы из одного символа.

Формат вывода

Выходной файл output.txt должен содержать ровно n строк. Для каждого слова из входного файла выведите по одной строке, содержащей слово YES, если оно принадлежит указанному выше языку, и NO - иначе.

Примеры

Ввод Вывод
3
001122
00011122222
000111222		 YES
NO
YES
2
0000111122220
012		 NO
YES
================================================ FILE: last_digit/LastDigit.java ================================================ package last_digit; import java.io.*; import java.util.*; public class LastDigit{ public static void main(String[] args){ Scanner in = new Scanner(System.in); PrintWriter out = new PrintWriter(System.out); int base = in.nextInt() % 10; int exponent = in.nextInt() % 10; long result = (long) Math.pow(base, exponent); result = (base == 0) ? 0 : result % 10; out.println(result); out.flush(); } } ================================================ FILE: last_digit/README.md ================================================

Последняя цифра A^B (21%)

Время: 1 сек.
Память: 16 Мб
Сложность: 21%

Требуется написать программу, которая находит цифру, на которую оканчивается число AB.

Формат ввода

Входной файл input.txt состоит из единственной строки, содержащей два целых числа A и B, разделенных пробелом (1 ≤ A,B ≤ 10000).

Формат вывода

В единственную строку выходного файла output.txt нужно вывести цифру, на которую оканчивается AB.

Примеры

Ввод Вывод
2 2 4
3 7 7
24 9 4
================================================ FILE: least_common_multiple/LeastCommonMultiple.java ================================================ package least_common_multiple; import java.util.*; import java.io.*; public class LeastCommonMultiple { public static void main(String[] args){ Scanner i = new Scanner(System.in); int a = i.nextInt(), b = i.nextInt(); int c = a, d = b; while (a != b){ // Используется алгоритм Евклида if(a > b) a = a - b; else b = b - a; } int result = c / a * d; PrintWriter o = new PrintWriter(System.out); o.print(result); o.flush(); } } ================================================ FILE: least_common_multiple/README.md ================================================

НОК(19%)

Время: 1 сек.
Память: 16 Мб
Сложность: 19%

Требуется написать программу, определяющую наименьшее общее кратное (НОК) чисел a и b.

Формат ввода

В единственной строке входного файла input.txt записаны два натуральных числа А и В через пробел, не превышающих 46340.

Формат вывода

В единственную строку выходного файла output.txt нужно вывести одно целое число — НОК чисел А и В.

Примеры

Ввод Вывод
36 27 108
39 65 195
================================================ FILE: left_recursion/LeftRecursion.java ================================================ package left_recursion; import java.util.*; import java.io.*; public class LeftRecursion { private static ArrayList data = new ArrayList<>(); private static ArrayList dataLine = new ArrayList<>(); private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ dataLine.add(sc.nextLine()); } for(int i = 0; i < dataLine.size(); i++){ if(i != 0){ StringTokenizer st = new StringTokenizer(dataLine.get(i), "->"); while (st.hasMoreTokens()){ data.add(st.nextToken()); } } } } public static void main(String[] argv) throws IOException{ getData(); int count = 0; String left = ""; for(int i = 0; i < data.size(); i++){ if(i % 2 == 0){ left = data.get(i); }else{ char oneSymbolRight = data.get(i).charAt(0); if(left.equals(String.valueOf(oneSymbolRight))){ count++; } } } PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(count)); pw.close(); } } ================================================ FILE: left_recursion/README.md ================================================

Левая рекурсия (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

В теории формальных грамматик и автоматов (ТФГиА) важную роль играют так называемые контекстно-свободные грамматики (КС-грамматики). КС-грамматикой будем называть четверку, состоящую из множества N нетерминальных символов, множества T терминальных символов, множества P правил (продукций) и начального символа S, принадлежащего множеству N.

Каждая продукция p из P имеет форму A –> a, где A нетерминальный символ (A из N), а a – строка, состоящая из терминальных и нетерминальных символов. Процесс вывода слова начинается со строки, содержащей только начальный символ S. После этого на каждом шаге один из нетерминальных символов, входящих в текущую строку, заменяется на правую часть одной из продукций, в которой он является левой частью. Если после такой операции получается строка, содержащая только терминальные символы, то процесс вывода заканчивается.

Во многих теоретических задачах удобно рассматривать так называемые нормальные формы грамматик. Процесс приведения грамматики к нормальной форме часто начинается с устранения левой рекурсии. В этой задаче мы будем рассматривать только ее частный случай, называемый непосредственной левой рекурсией. Говорят, что правило вывода A –> R содержит непосредственную левую рекурсию, если первым символом строки R является A.

Задана КС-грамматика. Требуется найти количество правил, содержащих непосредственную левую рекурсию.

Формат ввода

Первая строка входного файла input.txt содержит количество n (1 ≤ n ≤ 1000) правил в грамматике. Каждая из последующих n строк содержит по одному правилу. Нетерминальные символы обозначаются заглавными буквами английского алфавита, терминальные - строчными. Левая часть продукции отделяется от правой символами –>. Правая часть продукции имеет длину от 1 до 30 символов.

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
3
S->Sabc
S->A
A->AA		 2
================================================ FILE: letter/Letter.java ================================================ package letter; import java.io.*; import java.util.ArrayList; import java.util.Scanner; public class Letter { public static void main(String[] args) throws IOException { ArrayList lines = new ArrayList<>(); boolean conditionIsFeasible = true; Scanner rows = new Scanner(new InputStreamReader(System.in, "cp866")); PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out, "cp866")); String[] data = rows.nextLine().split(" "); int k = Integer.parseInt(data[0]); int n = Integer.parseInt(data[1]); while (n > 0) { String line = rows.nextLine().trim(); if (line.length() > k) { // проверка на выполнимость условий conditionIsFeasible = false; out.println("Impossible."); break; } lines.add(line); n--; } // System.out.println(lines); if (conditionIsFeasible) { for (String line : lines) { int numberOfSpaces = k - line.length(); // общее кол-во пробелов int numberOfSpacesStart = numberOfSpaces/2; // количество пробелов в начале строки int numberOfSpacesEnd = numberOfSpaces/2 + numberOfSpaces%2; // количество пробелов в начале строки for (int i = 0; i < numberOfSpacesStart; i++) { out.print(" "); } out.print(line); for (int i = 0; i < numberOfSpacesEnd; i++) { out.print(" "); } out.print('\n'); } } out.flush(); } } ================================================ FILE: letter/README.md ================================================

Письмо (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

Вася хочет отправить Пете письмо на листе шириной K. Он хочет распечатать на нем текст, состоящий из N строк. Необходимо изменить количество ведущих и концевых пробелов так, чтобы строки оказались посередине листа, и их длина стала равна K. Вася считает, что строка находится посередине листа, если количество ведущих пробелов не превосходит количества концевых пробелов и, если при сдвиге строки на один символ вправо (т.е. при добавлении одного пробела в начало строки), указанное свойство нарушается.

Формат ввода

Первая строка входного файла input.txt содержит два целых числа K и N (1 ≤ K ≤ 100, 1 ≤ N ≤ 1000). Следующие N строк содержат текст Васиного письма в однобайтовой кодировке (символы с кодами от 32 до 255). Каждая строка письма содержит хотя бы один символ, отличный от пробела. Длина каждой строки во входном файле не превосходит 100.

Формат вывода

Если Вася сможет написать письмо, удовлетворяющее всем его требованиям, то в выходной файл output.txt выведите отформатированный текст письма в той же кодировке, иначе, выведите фразу “Impossible.” (без кавычек).

Примеры

Ввод Вывод
20 3
++Привет!++
+Напиши+мне.++
++++Пока+=)+		 ++++++Привет!+++++++
++++Напиши+мне.+++++
++++++Пока+=)+++++++
5 1
Привет.		 Impossible.

В приведенных примерах для большей наглядности пробелы заменены на плюсы!

================================================ FILE: lexicographic_order_numbers/LexicographicOrderNumbers.java ================================================ package lexicographic_order_numbers; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class LexicographicOrderNumbers { public static void main(String[] args) throws IOException { String[] numbers = new Scanner(new FileReader("input.txt")).nextLine().split(" "); String n = numbers[0]; String k = numbers[1]; ArrayList numArray = new ArrayList<>(); for (int i = 1; i <= Integer.parseInt(n); i++) { numArray.add(String.valueOf(i)); } Collections.sort(numArray); PrintWriter out = new PrintWriter(System.out); for (int i = 0; i < numArray.size(); i++) { if (numArray.get(i).equals(k)) { out.println(i+1); break; } } out.flush(); } } ================================================ FILE: lexicographic_order_numbers/README.md ================================================

Лексикографический порядок чисел (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

Натуральные числа от 1 до N упорядочены лексикографически. Например, для N=25 результат этого упорядочения будет таким: 1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 22, 23, 24, 25, 3, 4, 5, 6, 7, 8, 9.

Требуется написать программу, которая определит, на каком месте оказалось число K.

Формат ввода

Входной файл input.txt содержит два натуральных числа N и K, записанных через пробел (1 ≤ K ≤ N ≤ 104).

Формат вывода

Выходной файл output.txt должен содержать одно натуральное число – номер места, на котором оказалось число K.

Примеры

Ввод Вывод
25 17 9
================================================ FILE: lisaalisa/Lisaalisa.java ================================================ package lisaalisa; import java.util.*; import java.io.*; public class Lisaalisa { private static int total; private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); total = sc.nextInt(); } public static void main(String[] argv) throws IOException{ getData(); int coinCat = 5; int coinFoxPayCount = 0; int coinCatPayCount = 0; switch (total % coinCat){ case (0) : coinCatPayCount = total / coinCat; break; case (1) : coinCatPayCount = total / coinCat - 1; coinFoxPayCount = 2; break; case (2) : coinCatPayCount = total / coinCat - 2; coinFoxPayCount = 4; break; case (3) : coinCatPayCount = total / coinCat; coinFoxPayCount = 1; break; case (4) : coinCatPayCount = total / coinCat - 1; coinFoxPayCount = 3; break; } String result = coinCatPayCount + " " + coinFoxPayCount; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: lisaalisa/README.md ================================================

Лиса Алиса и кот Базилио (22%)

Время: 1 сек.
Память: 16 Мб
Сложность: 22%

Лиса Алиса и кот Базилио вырастили денежное дерево. И выросли на нем трехрублевые и пятирублевые золотые монеты. Лиса Алиса себе взяла трехрублевые монеты, а коту Базилио отдала пятирублевые монеты. Посетовав на свою скромность, она предложила впредь рассчитываться за покупки вместе, деньги давать без сдачи и минимальным числом монет. Известно, что они сделали покупку стоимостью N рублей, при этом они рассчитались без сдачи.

Вам следует написать программу, которая определяет: сколько монет внес кот Базилио, и сколько монет внесла лиса Алиса.

Формат ввода

Во входном файле input.txt записано одно натуральное число N – стоимость покупки в рублях (7 < N < 1000).

Формат вывода

В выходной output.txt выведите два целых числа через пробел: число монет, которые отдал кот Базилио и число монет, которые отдала лиса Алиса.

Примеры

Ввод Вывод
8 1 1
11 1 2
15 3 0
================================================ FILE: list_of_items/ListOfItems.java ================================================ package list_of_items; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.*; public class ListOfItems { public static void main(String[] args) throws IOException { ArrayList items = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); sc.nextLine(); while (sc.hasNextLine()) { items.add(sc.nextLine()); } Collections.sort(items); int count = 0; for (int i = 0; i < items.size(); i++) { if (!(i + 1 < items.size() && items.get(i+1).indexOf(items.get(i)) == 0)) { count++; } } PrintWriter out = new PrintWriter(System.out); out.println(count); out.flush(); } } ================================================ FILE: list_of_items/README.md ================================================

Список предметов (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

Студент Василий к концу семестра решил выяснить, какие предметы ему в этом семестре преподавались. Полный список предметов есть в его записях, но при их просмотре возникли две серьезные трудности. Во-первых, некоторые предметы упоминаются в этих записях более одного раза. Во-вторых, что еще хуже, из-за постоянной спешки Василий часто использует сокращения. Сокращает он довольно просто – отбрасывает несколько последних букв слова. Так, предмет “algebra” в записях может быть обозначен как “algeb”, “algebr” и “alg” (но не как “alg-ra”). Создайте для Василия программу, которая по его записям определяет, сколько предметов у него преподавалось в этом семестре.

Формат ввода

Первая строка входного файла INPUT.TXT содержит число N – количество записей в списке Василия (1 ≤ N ≤ 10 000). Далее идет N строк, каждая из которых содержит строку символов длиной M (2 ≤ M ≤ 20). Строки состоят исключительно из английских символов в нижнем регистре и знаков подчеркивания ('_'). Гарантируется, что входные данные позволяют однозначно определить количество преподававшихся в семестре предметов.

Формат вывода

В выходной файл OUTPUT.TXT выведите количество предметов, которые преподавались в семестре.

Примеры

Ввод Вывод
3
algebra
algeb
history		 2
4
algebr
alg
algebra
algeb		 1
================================================ FILE: live_journal/LiveJournal.java ================================================ package live_journal; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class LiveJournal { private static void printFriends(PrintWriter out, ArrayList friends) { for (int i = 0; i < friends.size(); i++) { out.print(friends.get(i)); if (i + 1 < friends.size()) { out.print(", "); } } out.print('\n'); } public static void main(String[] args) throws IOException { ArrayList firstFriendList = new ArrayList<>(); ArrayList commonFriend = new ArrayList<>(); ArrayList variousFriendList = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); int firstListCount = Integer.parseInt(sc.nextLine()); for (int i = 0; i < firstListCount; i++) { firstFriendList.add(sc.nextLine()); } int secondListCount = Integer.parseInt(sc.nextLine()); for (int i = 0; i < secondListCount; i++) { String friend = sc.nextLine(); if (firstFriendList.contains(friend)) { commonFriend.add(friend); } else { variousFriendList.add(friend); } } Collections.sort(firstFriendList); Collections.sort(commonFriend); Collections.sort(variousFriendList); PrintWriter out = new PrintWriter(System.out); out.print("Friends: " ); printFriends(out, firstFriendList); out.print("Mutual Friends: " ); printFriends(out, commonFriend); out.print("Also Friend of: " ); printFriends(out, variousFriendList); out.flush(); } } ================================================ FILE: live_journal/README.md ================================================

Jивой Jурнал (29%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 29%

Программист Саша участвует в создании блог-сервиса Jивой Jурнал. Планируется, что этот сервис будет предоставлять гораздо больше возможностей, чем известный всем LiveJournal. В настоящее же время проблему составляет реализация всех базовых возможностей LiveJournal'а. Одной из таких возможностей является поддержка списков друзей для пользователей.

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

Необходимо получить список друзей данного пользователя (Friends), список его взаимных друзей (Mutual Friends), и список тех пользователей, у кого данный пользователь содержится в списке друзей, но которые не являются его взаимными друзьями (Also Friend of).

Формат ввода

Первая строка входного файла input.txt содержит число n (0 ≤ n ≤ 200) друзей данного пользователя. Последующие n строк содержат каждая по одному имени пользователя, который является другом данного. (n + 2)-ая строка содержит число m (0 ≤ m ≤ 200) пользователей, у которых данный содержится в списке друзей. Далее заданы имена пользователей, у которых данный находится в списке друзей. Эти пользователи заданы в том же формате, что и друзья данного.

Имена пользователей - строки длиной от 1 до 20 символов, содержащие только строчные буквы английского алфавита и символы тире ("-"). Каждый пользователь указан не более одного раза в каждом из списков.

Формат вывода

В выходной файл output.txt следует вывести список друзей данного пользователя (Friends), список его взаимных друзей (Mutual Friends), и список тех пользователей, у кого данный пользователь содержится в списке друзей, но которые не являются его взаимными друзьями (Also Friend of). В каждом списке пользователи должны быть отсортированы по алфавиту. Следуйте формату, приведенному в примерах.

Примеры

Ввод Вывод
3
vasya-pupkin
bill-hates
ivan-ivanov
2
vasya-pupkin
destroyer		 Friends: bill-hates, ivan-ivanov, vasya-pupkin
Mutual Friends: vasya-pupkin
Also Friend of: destroyer
0
0		 Friends:
Mutual Friends:
Also Friend of:
================================================ FILE: lucky_ticket/LuckyTicket.java ================================================ package lucky_ticket; import java.io.*; import java.util.*; public class LuckyTicket { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); String result; String str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); str = sc.nextLine(); char[] symbols = str.toCharArray(); for (char symbol : symbols) { data.add(Character.getNumericValue(symbol)); } result = (data.get(0) + data.get(1) + data.get(2) == data.get(3) + data.get(4) + data.get(5)) ? "YES" : "NO"; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: lucky_ticket/README.md ================================================

Счастливый билет (12%)

Время: 1 сек.
Память: 16 Мб
Сложность: 12%

Вы пользуетесь общественным транспортом? Вероятно, вы расплачивались за проезд и получали билет с номером. Счастливым билетом называют такой билет с шестизначным номером, где сумма первых трех цифр равна сумме последних трех. Т.е. билет с номером 385916 – счастливый, т.к. 3+8+5=9+1+6. Вам требуется написать программу, которая проверяет счастливость билета.

Формат ввода

В единственной строке входного файла input.txt записано одно целое число N (0 ≤ N < 106).

Формат вывода

В выходной файл output.txt нужно вывести «YES», если билет с номером N счастливый и «NO» в противном случае.

Примеры

Ввод Вывод
385916 YES
123456 NO
================================================ FILE: lucky_ticket_two/LuckyTicketTwo.java ================================================ package lucky_ticket_two; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class LuckyTicketTwo{ private static int summ(String str){ char[] ch = str.toCharArray(); int number = 0; for (char aCh : ch) { int symbol = aCh - '0'; number += symbol; } while (number > 9){ int sum = 0; while (number > 0) { sum += number % 10; number = (int) Math.floor(number/10); } number = sum; } return number; } public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String data = sc.nextLine(); int index = 1; boolean isHappy = false; char[] ch = data.toCharArray(); if(ch.length > 1){ for (char aCh : ch) { StringBuilder leftString = new StringBuilder(); StringBuilder rightString = new StringBuilder(); for (int a = 0; a < index; a++) { leftString.append(String.valueOf(ch[a])); } int left = summ(String.valueOf(leftString)); for (int b = ch.length - 1; b >= index; b--) { rightString.append(String.valueOf(ch[b])); } int rigth = summ(String.valueOf(rightString)); if (left == rigth) { isHappy = true; break; } index++; } } String result = isHappy ? "YES" : "NO"; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: lucky_ticket_two/README.md ================================================

Счастливый билет - 2 (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Билет называется счастливым, если его можно разрезать прямой линией между цифр на две части таким образом, что оказавшиеся на них числа имеют одинаковые цифровые корни. Чтобы вычислить цифровой корень числа, его цифры складывают, если в результате получится число большее или равное 10, то цифры складывают снова и так далее, пока не получится число от 0 до 9 – это и есть цифровой корень. Например, билет с номером 0015420 является счастливым, так как разрезав его на части с числами 0015 и 420 имеем у этих чисел одинаковые цифровые корни.

Требуется написать программу, которая определит, является ли счастливым билет с заданным номером.

Формат ввода

Входной файл input.txt содержит номер счастливого билета. Номер может начитаться с нулей и содержит от 1 до 100 цифр.

Формат вывода

В выходной текстовый файл output.txt выведите «YES», если билет счастливый и «NO» иначе.

Примеры

Ввод Вывод
0015420 YES
00100 NO
================================================ FILE: manhattan_streets/ManhattanStreets.java ================================================ package manhattan_streets; import java.util.*; import java.io.*; public class ManhattanStreets { private static ArrayList data = new ArrayList<>(); private static long result; private static void area(){ long avenue = data.get(0); long street = data.get(1); long width = data.get(2); long height = data.get(3); long areaOneCroossroad = width * width; // Площадь 1 перекрестка long crossroadCount = avenue * street; // Количество перекрестков long areaAvenue = avenue * (width * height - street * areaOneCroossroad); // Площадь авеню без учета перекрестков long areaStreet = street * (width * height - avenue * areaOneCroossroad); // Площадь улиц без учета перекрестков result = areaAvenue + areaStreet + areaOneCroossroad * crossroadCount; // Общая площадь } public static void main(String[] argv) throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Long.valueOf(st.nextToken())); } area(); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(result)); pw.close(); } } ================================================ FILE: manhattan_streets/README.md ================================================

Манхэттенские улицы(17%)

Время: 1 сек.
Память: 16 Мб
Сложность: 17%

Система улиц Нью-Йоркского района Манхеттен весьма интересна. В Манхеттене есть n улиц, идущие с запада на восток (авеню), и m улиц, идущие с севера на юг (просто улицы). Ширина каждого авеню и каждой улицы равна d метров, а длина – k метров. При этом каждая улица пересекает каждый авеню и не имеет общих точек с другими улицами, а каждый авеню пересекает каждую улицу и не имеет общих точек с другими авеню.

Разумеется, все авеню и улицы имеют асфальтовое покрытие. Дорожно-ремонтные службы интересуются: сколько квадратных метров асфальта уложено на все авеню и улицы. На перекрестках, без сомнения, асфальт уложен в один слой.

Напишите программу, вычисляющую ответ на их вопрос.

Формат ввода

Входной файл input.txt содержит четыре натуральных числа n, m, d, k (1 ≤ n, m, d, k ≤ 109, k > m∙d, k > n∙d).

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
1 1 5 10 75
100 10 23 4560 11007800
================================================ FILE: maximum_three/MaximumThree.java ================================================ package maximum_three; import java.io.*; import java.util.StringTokenizer; public class MaximumThree { public static void main(String[] args) throws IOException { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); int n = Integer.parseInt(in.readLine()); int countLine = n; byte[][] field = new byte [n][n]; int row = 0; while (countLine > 0) { StringTokenizer st = new StringTokenizer(in.readLine(), " "); int column = 0; while (st.hasMoreTokens()) { field[row][column] = Byte.parseByte(st.nextToken()); column++; } countLine--; row++; } int result = -10000000; if (n == 1) { result = field[0][0]; } else { for (row = 0; row < n; row++) { for (int column = 0; column < n; column++) { int number; int resultTmp = -10000000; // вверх if (row-1 >= 0 && column-1 >= 0) { number = field[row][column] + field[row-1][column] + field[row-1][column-1]; if (resultTmp < number) resultTmp = number; } if (row-2 >= 0) { number = field[row][column] + field[row-1][column] + field[row-2][column]; if (resultTmp < number) resultTmp = number; } if (row-1 >= 0 && column+1 < n) { number = field[row][column] + field[row-1][column] + field[row-1][column+1]; if (resultTmp < number) resultTmp = number; } // вправо if (row-1 >= 0 && column+1 < n) { number = field[row][column] + field[row][column+1] + field[row-1][column+1]; if (resultTmp < number) resultTmp = number; } if (column+2 < n) { number = field[row][column] + field[row][column+1] + field[row][column+2]; if (resultTmp < number) resultTmp = number; } if (row+1 < n && column+1 < n) { number = field[row][column] + field[row][column+1] + field[row+1][column+1]; if (resultTmp < number) resultTmp = number; } // вниз if (row+1 < n && column+1 < n) { number = field[row][column] + field[row+1][column] + field[row+1][column+1]; if (resultTmp < number) resultTmp = number; } if (row+2 < n) { number = field[row][column] + field[row+1][column] + field[row+2][column]; if (resultTmp < number) resultTmp = number; } if (row+1 < n && column-1 >= 0) { number = field[row][column] + field[row+1][column] + field[row+1][column-1]; if (resultTmp < number) resultTmp = number; } // влево if (column-2 >= 0) { number = field[row][column] + field[row][column-1] + field[row][column-2]; if (resultTmp < number) resultTmp = number; } if (row+1 < n && column-1 >= 0) { number = field[row][column] + field[row][column-1] + field[row+1][column-1]; if (resultTmp < number) resultTmp = number; } if (row-1 >= 0 && column-1 >= 0) { number = field[row][column] + field[row][column-1] + field[row-1][column-1]; if (resultTmp < number) resultTmp = number; } if (result < resultTmp) { result = resultTmp; } } } } PrintWriter out = new PrintWriter(System.out); out.println(result); out.flush(); } } ================================================ FILE: maximum_three/README.md ================================================

Максимальная тройка (33%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 33%

В данной двумерной целочисленной таблице размером N × N требуется найти три элемента, сумма которых максимальна. При этом первый элемент должен быть соседним по горизонтали или вертикали со вторым, а второй — с третьим.

Формат ввода

Входной файл INPUT.TXT содержит в первой строке число N (1 < N ≤ 2000). В следующих N строках записано по N чисел – элементы таблицы. Элементы матрицы по абсолютной величине не превышают 100.

Формат вывода

Выходной файл OUTPUT.TXT должен содержать единственное число — максимальную сумму.

Примеры

Ввод Вывод
3
1 1 1
2 2 1
2 1 0		 6
================================================ FILE: military_base/MilitaryBase.java ================================================ package military_base; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class MilitaryBase { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] field = sc.nextLine().split(" "); int n = Integer.parseInt(field[0]); int m = Integer.parseInt(field[1]); char[][] map = new char[n][m]; int result = 0; int row = 0; while (sc.hasNextLine()) { map[row] = sc.nextLine().toCharArray(); row++; } int start = -1, finish; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (map[i][j] == '#' && start == -1) { start = j; } if (start > -1 && (j == m-1 || map[i][j] == '.')) { if (map[i][j] == '#') { finish = j; } else finish = j-1; result++; if (i+1 < n && map[i+1][start] == '#') { for (int down = i+1; down < n; down++) { boolean exit = false; for (int k = start; k <= finish; k++) { if (map[down][k] == '#') { map[down][k] = '.'; } else { exit = true; break; } } if (exit) break; } } start = -1; } } } PrintWriter out = new PrintWriter(System.out); out.println(result); out.flush(); } } ================================================ FILE: military_base/README.md ================================================

Военная база (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

Со спутника-шпиона получено изображение в некотором волновом диапазоне сверхсекретной военной базы предполагаемого противника. База расположена на Антарктиде, все постройки на ней высечены из кубов льда и имеют на фотографии квадратную форму и не имеют общих фрагментов стен ненулевой длины (по всей видимости, это сделано в целях маскировки от локаторов, работающих в инфракрасном спектре). Благодаря мастерству операторов оказалось, что стены разных построек параллельны границам фотографии.

Для того, чтобы составить сверхсрочный отчет для командования, необходимо узнать, сколько зданий находятся на базе. Напишите программу, которая это сделает.

Формат ввода

В первой строке входного файла INPUT.TXT записаны числа N и M (1 ≤ M, N ≤ 500) – размеры фотографии в пикселях по вертикали и по горизонтали. Следующие N строк содержат по M символов каждая: символ '.' соответствует пустому месту, '#' – элементу постройки.

Формат вывода

В выходной файл OUTPUT.TXT выведите единственное число – количество построек на базе.

Примеры

Ввод Вывод
8 6
......
...##.
...##.
......
.###..
.###..
.###..
......		 2
================================================ FILE: minimum_path_table/MinimumPathTable.java ================================================ package minimum_path_table; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class MinimumPathTable { private static int n = 0; private static int m = 0; // получить данные private static int[][] _getData() throws IOException { int [][] data = new int[0][]; Scanner sc = new Scanner(new FileReader("input.txt")); int row = -1; while (sc.hasNextLine()) { String line = sc.nextLine(); if (row > -1) { String[] cells = line.split(" "); for (int column = 0; column < cells.length; column++) { data[row][column] = Integer.parseInt(cells[column]); } } else { String[] size = line.split(" "); n = Integer.parseInt(size[0]); m = Integer.parseInt(size[1]); data = new int[n][m]; } row++; } return data; } public static void main(String[] args) throws IOException { int[][] data = _getData(); for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (i > 0 && j > 0) { data[i][j] += Math.min(data[i-1][j], data[i][j-1]); } else if (i > 0) { data[i][j] += data[i-1][j]; } else if (j > 0) { data[i][j] += data[i][j-1]; } } } PrintWriter out = new PrintWriter(System.out); out.println(data[n-1][m-1]); out.flush(); } } ================================================ FILE: minimum_path_table/README.md ================================================

Минимальный путь в таблице (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

В прямоугольной таблице N×M (в каждой клетке которой записано некоторое число) в начале игрок находится в левой верхней клетке. За один ход ему разрешается перемещаться в соседнюю клетку либо вправо, либо вниз (влево и вверх перемещаться запрещено). При проходе через клетку с игрока берут столько у.е., какое число записано в этой клетке (деньги берут также за первую и последнюю клетки его пути).

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

Формат ввода

Во входном файле INPUT.TXT задано два числа N и M - размеры таблицы (1 ≤ N ≤ 20, 1 ≤ M ≤ 20). Затем идет N строк по M чисел в каждой - размеры штрафов в у.е. за прохождение через соответствующие клетки (числа от 0 до 100).

Формат вывода

В выходной файл OUTPUT.TXT выведите минимальную сумму, потратив которую можно попасть в правый нижний угол.

Примеры

Ввод Вывод
3 4
1 1 1 1
5 2 2 100
9 4 2 1		 8
5 5
1 1 1 1 1
3 100 100 100 100
1 1 1 1 1
2 2 2 2 1
1 1 1 1 1		 11
================================================ FILE: mockery/Mockery.java ================================================ package mockery; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; import java.util.StringTokenizer; public class Mockery { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int[][] matrix = new int[0][]; int row = -1; while (sc.hasNextLine()) { String str = sc.nextLine(); if (row == -1) { int size = Integer.parseInt(str); matrix = new int[size][size]; } else { StringTokenizer st = new StringTokenizer(str, " "); int column = 0; while (st.hasMoreTokens()){ matrix[row][column] = Integer.parseInt(st.nextToken()); column++; } } row++; } int shortestWay = Integer.MAX_VALUE; for (int i = 0; i < matrix.length; i++) { for (int j = 0; j < matrix.length; j++) { if (i < j) { for (int k = 0; k < matrix.length; k++) { if (matrix[i][j] != 0 && matrix[i][k] != 0 && matrix[j][k] != 0) { int sumRouds = matrix[i][j] + matrix[i][k] + matrix[j][k]; if (shortestWay > sumRouds) { shortestWay = sumRouds; } } } } } } PrintWriter out = new PrintWriter(System.out); out.println(shortestWay); out.flush(); } } ================================================ FILE: mockery/README.md ================================================

Издевательство (28%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

В городе N площадей. Любые две площади соединены между собой ровно одной дорогой с двусторонним движением. В этом городе живет Штирлиц. У Штирлица есть хобби - он любит воскресным утром выйти из дома, сесть в машину, выбрать какой-нибудь кольцевой маршрут, проходящий ровно по трем площадям (то есть сначала он едет с какой-то площади на какую-то другую, потом - на третью, затем возвращается на начальную, и опять едет по этому маршруту). Он воображает, что где-то на этом пути стоит Борман. И так вот ездит Штирлиц все воскресенье, пока голова не закружится, и радуется...

Естественно, что Штирлицу хочется проезжать мимо точки, в которой, как он воображает, стоит Борман, как можно чаще. Для этого, естественно, выбранный Штирлицем маршрут должен быть как можно короче. Напишите программу, которая выберет оптимальный для Штирлица маршрут.

Формат ввода

Во входном файле input.txt записано сначала число N (3 ≤ N ≤ 100), а затем матрица N×N расстояний между площадями (число в позиции i,j обозначает длину дороги, соединяющей i-ую и j-ую площади). Все числа в матрице (кроме стоящих на главной диагонали) - натуральные, не превышающие 1000. Матрица симметрична относительно главной диагонали, на главной диагонали стоят 0.

Формат вывода

В выходной файл output.txt выведите длину оптимального маршрута.

Примеры

Ввод Вывод
5
0 20 10 30 40
20 0 30 1 2
10 30 0 40 1000
30 1 40 0 21
40 2 1000 21 0		 24
================================================ FILE: module_amount/ModuleAmount.java ================================================ package module_amount; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class ModuleAmount { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } data.remove(0); StringBuilder plus = new StringBuilder(); StringBuilder minus = new StringBuilder(); int sumPlus = 0; int sumMinus = 0; int countPlus = 0; int countMinus = 0; int index = 1; for(int number : data){ if(number >= 0){ sumPlus += number; countPlus++; plus.append(index).append(" "); }else { sumMinus += Math.abs(number); countMinus++; minus.append(index).append(" "); } index++; } String result = sumPlus >= sumMinus ? String.valueOf(countPlus) + "\n" + plus : String.valueOf(countMinus) + "\n" + minus; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: module_amount/README.md ================================================

Модуль суммы (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Дана последовательность целых чисел. Требуется найти подпоследовательность заданной последовательности с максимальным модулем суммы входящих в нее чисел. Напомним, что модуль целого числа x равняется x, если x ≥ 0 и -x, если x < 0.

Формат ввода

Первая строка входного файла input.txt содержит натуральное число n (1 ≤ n ≤ 10000) - длину последовательности. Во второй строке записаны n целых чисел, по модулю не превосходящих 10000.

Формат вывода

В первой строке выходного файла output.txt выведите длину k выбранной вами подпоследовательности. Во второй строке должны быть записаны k различных чисел, разделенных пробелами - номера выбранных членов последовательности.

Примеры

Ввод Вывод
5
-1 4 -1 6 -7		 2
2 4
================================================ FILE: money_money_money/MoneyMoneyMoney.java ================================================ package money_money_money; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class MoneyMoneyMoney { public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); long x = new Scanner(new FileReader("input.txt")).nextLong(); if (x % 2 == 0) { out.println("0 0"); } else { long a = 2; long b = x + a; out.println(a + " " + b); } out.flush(); } } ================================================ FILE: money_money_money/README.md ================================================

Money, money, money (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

Правительство Флатландии решило провести реформу денежной системы. Цель реформы – радикально уменьшить число банкнот в обращении, в результате их должно остаться ровно две. Таким образом, после реформы во Флатландии будут циркулировать банкноты достоинством a тугриков и b тугриков, где a и b поручено выбрать министерству финансов.

Одна из проблем заключается в том, что президент Флатландии ненавидит число x. Поэтому министр финансов решил, что выберет такие a и b, что нельзя будет заплатить ровно x тугриков без сдачи. С другой стороны, для любой суммы большей x должна быть возможность заплатить ее без сдачи.

Итак, вам поручено выбрать соответствующие a и b.

Формат ввода

Входной файл INPUT.TXT содержит натуральное число x, не превосходящее 1012.

Формат вывода

В выходной файл OUTPUT.TXT выведите два целых числа a и b такие, что сумму в x тугриков нельзя заплатить банкнотами в a и b тугриков без сдачи, а любую большую сумму – можно. Если решения не существует, выведите в выходной файл два нуля.

Примеры

Ввод Вывод
3 2 5
4 0 0
5 3 4
================================================ FILE: more_less/MoreLess.java ================================================ package more_less; import java.io.*; import java.util.*; public class MoreLess { public static void main(String[] args) throws IOException { String symbol; ArrayList number = new ArrayList<>(); String str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ str = sc.nextLine(); number.add(Integer.valueOf(str)); } symbol = (number.get(0) > number.get(1)) ? ">" : // Проверка условия задачи (number.get(0) < number.get(1)) ? "<" : "="; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(symbol); fileOut.close(); } } ================================================ FILE: more_less/README.md ================================================

Больше-меньше (3%)

Время: 1 сек.
Память: 16 Мб
Сложность: 3%

Одна из основных операций с числами – их сравнение. Мы подозреваем, что вы в совершенстве владеете этой операцией и можете сравнивать любые числа, в том числе и целые. В данной задаче необходимо сравнить два целых числа.

Формат ввода

В двух строчках входного файла input.txt записаны числа A и B, не превосходящие по абсолютной величине 2×109.

Формат вывода

Запишите в выходной файл output.txt один символ "<", если A < B, ">", если A > B и "=", если A=B.

Пример 1

Ввод Вывод
5
7		 <
-7
-12 		>
13
13 		=
================================================ FILE: mouse/Mouse.java ================================================ package mouse; import java.io.*; import java.util.*; public class Mouse { public static void main(String[] args) throws IOException { ArrayList size = new ArrayList<>(); String out; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while(st.hasMoreTokens()){ size.add(Long.valueOf(st.nextToken())); } out = (size.get(2)*2 <= size.get(0) && size.get(2)*2 <= size.get(1)) ? "YES" : "NO"; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(out); fileOut.close(); } } ================================================ FILE: mouse/README.md ================================================

Мышка (9%)

Время: 1 сек.
Память: 16 Мб
Сложность: 9%

Однажды компьютерная мышка подумала, что стоит взять про запас еще один коврик. Чтобы никто не заметил запасного коврика, мышка решила его спрятать под свой прямоугольный коврик. Пробравшись ночью на склад, мышка обнаружила там только круглые коврики. Удастся ли мышке спрятать круглый коврик под прямоугольным ковриком?

Формат ввода

Входной файл input.txt содержит три натуральных числа: W, H и R, где W и H - ширина и высота прямоугольного коврика, а R – радиус запасного коврика. Все числа не превосходят значения 109.

Формат вывода

В выходной файл output.txt выведите «YES», если новый коврик можно спрятать под старым, и слово «NO», если этого сделать нельзя.

Примеры

Ввод Вывод
4 7 2 YES
4 7 3 NO
================================================ FILE: multi_digits/MultiDigits.java ================================================ package multi_digits; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class MultiDigits { /** * @param number Произвольное число * @return true, если число делится на произведение цифр, false в противном случае * */ private static boolean check(long number){ long numberCopy = number; long multi = 1; while (number > 0){ long digit = number % 10; if(digit == 0){ return false; } multi *= digit; number /= 10; } return numberCopy % multi == 0; } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] lineArr = sc.nextLine().split(" "); long l = Long.valueOf(lineArr[0]); long r = Long.valueOf(lineArr[1]); int count = 0; for (long i = l; i <= r; i++){ if(check(i)) count++; } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(count)); out.close(); } } ================================================ FILE: multi_digits/README.md ================================================

Произведение цифр - 2 (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Найдите количество чисел из отрезка [L, R], которые делятся на произведение своих цифр.

Формат ввода

Входной файл input.txt содержит два целых числа L и R. (1 ≤ L ≤ R ≤ 109, |R-L| ≤ 105)

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
1 12 11
================================================ FILE: multiplication_of_numbers/MultiplicationOfNumbers.java ================================================ package multiplication_of_numbers; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class MultiplicationOfNumbers { private static int div(int number) { for (int i = 9; i != 1; i--) { if (number % i == 0) { return i; } } return -1; } public static void main (String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); int n = new Scanner(new FileReader("input.txt")).nextInt(); int number = 1; if (n > 1) { StringBuilder line = new StringBuilder(); while ((n /= number) > 1 && (number = div(n)) != -1) { line.append(number); } if (number == -1) { out.println(-1); } else { out.println(line.reverse()); } } else if (n == 0) { out.println(10); } else if (n == 1) { out.println(1); } out.flush(); } } ================================================ FILE: multiplication_of_numbers/README.md ================================================

Произведение цифр (42%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 45%

Требуется найти наименьшее натуральное число Q такое, что произведение его цифр равно заданному числу N.

Формат ввода

В единственной строке входного файла INPUT.TXT записано одно целое число N (0 ≤ N ≤ 109).

Формат вывода

В выходной файл OUTPUT.TXT нужно вывести искомое число Q. В том случае, если такого числа не существует, следует вывести -1.

Примеры

Ввод Вывод
10 25
13 -1
8 8
90 259
================================================ FILE: multiplication_table/MultiplicationTable.java ================================================ package multiplication_table; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.HashMap; import java.util.Map; import java.util.Scanner; import java.util.StringTokenizer; public class MultiplicationTable { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); int n = Integer.valueOf(st.nextToken()); int m = Integer.valueOf(st.nextToken()); int numeral = 10; Map out = new HashMap() {{ put(0, 0); put(1, 0); put(2, 0); put(3, 0); put(4, 0); put(5, 0); put(6, 0); put(7, 0); put(8, 0); put(9, 0); }}; for(int i = 1; i <= n; i++){ for(int j = 1; j <= m; j++){ int multi = i * j; while (multi != 0){ int search = multi % 10; out.put(search, out.get(search) + 1); multi /= 10; } } } StringBuilder result = new StringBuilder(); for(int i = 0; i < numeral; i++){ if(out.containsKey(i)){ result.append(String.valueOf(out.get(i))); }else { result.append("0"); } result.append("\n"); } FileWriter output = new FileWriter("output.txt"); output.write(String.valueOf(result).trim()); output.close(); } } ================================================ FILE: multiplication_table/README.md ================================================

Таблица умножения (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Большой любитель математики Вова решил повесить у себя в комнате таблицу умножения. После некоторых раздумий он обнаружил, что обычная таблица умножения 10 на 10 уже не популярна в наши дни. Он решил повесить у себя в комнате таблицу N на M. Представив себе эту таблицу, Вова задался вопросом - сколько раз в ней встречается каждая из цифр от 0 до 9?

И прежде чем нарисовать эту таблицу Вова попросил вас написать программу, которая даст ответ на его вопрос.

Как известно, в таблице умножения на пересечении строки i и столбца j записано число i∙j.

Формат ввода

Входной файл input.txt состоит из единственной строки, на которой через пробел записаны два натуральных числа N и M (1 ≤ N, M ≤ 1000).

Формат вывода

Выходной файл output.txt должен состоять из десяти строк. На строке i выведите количество раз, которое Вове придется нарисовать цифру i - 1.

Примеры

Ввод Вывод
10 10 28
24
27
15
23
15
17
8
15
6
================================================ FILE: n_digit_numbers/NDigitNumbers.java ================================================ package n_digit_numbers; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.*; public class NDigitNumbers { /** * @param number Число * @return Сумма цифр числа, произведение * */ private static boolean digitSumMulti(long number) { int sum = 0; int multi = 1; while (number != 0) { long digit = number % 10; if (digit == 0) { return false; } sum += digit; if (digit != 1) { multi *= digit; } if (multi > 90 || multi/2 > sum) { return false; } number /= 10; } return sum == multi; } /** * @param number Число * @return Количество перестановок * */ private static int swapCount(long number) { Map digitCount = new HashMap<>(); long numberTmp = number; while (numberTmp != 0) { int digit = (int) (numberTmp % 10); if (digitCount.containsKey(digit)) { digitCount.put(digit, digitCount.get(digit)+1); } else { digitCount.put(digit, 1); } numberTmp /= 10; } int multi = 1; for (int digit : digitCount.values()) { if (digit != 0) { multi *= fact(digit); } } return (fact(String.valueOf(number).length()))/(multi); } /** * @param number Число * @return Факториал числа * */ private static int fact(int number) { int count = 1; for (int i = number; i > 1; i--) { count *= i; } return count; } public static void main(String[] args) throws IOException { int digit = new Scanner(new FileReader("input.txt")).nextInt(); long min = 0; long countFound = 0, minFound = -1; if (digit > 1) { min = Long.parseLong("1" + "1".repeat(digit - 1)); } if (digit > 1) { int aCount = digit == 10 ? 9 : 0; int bCount = digit >= 9 ? 9 : 0; int cCount = digit >= 8 ? 9 : 0; int dCount = digit >= 7 ? 9 : 0; int eCount = digit >= 6 ? 9 : 0; int fCount = digit >= 5 ? 9 : 0; int gCount = digit >= 4 ? 9 : 0; int hCount = digit >= 3 ? 9 : 0; for (int a = 0; a <= aCount; a++) { for (int b = a; b <= bCount; b++) { for (int c = b; c <= cCount; c++) { for (int d = c; d <= dCount; d++) { for (int e = d; e <= eCount; e++) { for (int f = e; f <= fCount; f++) { for (int g = f; g <= gCount; g++) { for (int h = g; h <= hCount; h++) { for (int i = h; i <= 9; i++) { for (int j = i; j <= 9; j++) { long number = a*(long) Math.pow(10, 9) + b*(long) Math.pow(10, 8) + c*(long) Math.pow(10, 7) + d*(long) Math.pow(10, 6) + e*(long) Math.pow(10, 5) + f*(long) Math.pow(10, 4) + g*(long) Math.pow(10, 3) + h*(long) Math.pow(10, 2) + i*(long) Math.pow(10, 1) + j; if (number >= min) { if (digitSumMulti(number)) { countFound += swapCount(number); if (minFound == -1) { minFound = number; } } } } } } } } } } } } } } PrintWriter out = new PrintWriter(System.out); if (digit == 1) { out.println(10 + " " + 0); } else { out.println(countFound + " " + minFound); } out.flush(); } } ================================================ FILE: n_digit_numbers/README.md ================================================

N-значные числа (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

Найти количество N-значных чисел, у которых сумма цифр равна их произведению. Вывести наименьшее среди таких чисел для заданного N.

Формат ввода

В единственной строке входного файла input.txt записано одно натуральное число N, которое не превышает 10.

Формат вывода

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

Примеры

Ввод Вывод
1 10 0
2 1 22
================================================ FILE: natural_number_series/NaturalNumberSeries.java ================================================ package natural_number_series; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class NaturalNumberSeries { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String str = sc.nextLine(); int len = str.length(); StringBuilder series = new StringBuilder(); int index = 1; int start = 0; while (true){ if(series.length() >= len){ String substr = series.substring(start, start+len); if(substr.equals(str)){ break; } start++; } series.append(index); index++; } start++; FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(start)); out.close(); } } ================================================ FILE: natural_number_series/README.md ================================================

Натуральный ряд чисел (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Натуральные числа записаны в строку без каких-либо разделителей. Начало этой строки имеет вид 123456789101112131415161718192021… .

Требуется написать программу, которая определит первое вхождение десятичной записи заданного числа N в этой строке.

Формат ввода

Входной файл input.txt содержит заданное число N (1 ≤ N ≤ 104).

Формат вывода

Выходной файл output.txt должен содержать одно число – позицию, начиная с которой в строке записано первое вхождение заданного числа. Нумерация позиций начинается с единицы.

Примеры

Ввод Вывод
45 4
101 10
142 73
================================================ FILE: neerc/Neerc.java ================================================ package neerc; import java.util.*; import java.io.*; public class Neerc { private static ArrayList team = new ArrayList<>(); private static ArrayList startData = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); int numberLine = 0; while (sc.hasNextLine()){ numberLine++; String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ if(numberLine == 2){ team.add(Integer.valueOf(st.nextToken())); // Количество участников от каждого института }else{ startData.add(Integer.valueOf(st.nextToken())); } } } } public static void main(String[] argv) throws IOException { getData(); int roomCount = startData.get(1); int contestant = 0; for (Integer aTeam : team) { if (roomCount >= aTeam) { contestant += aTeam; } else { contestant += roomCount; } } PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(contestant)); pw.close(); } } ================================================ FILE: neerc/README.md ================================================

NEERC (17%)

Время: 1 сек.
Память: 16 Мб
Сложность: 17%

В полуфинале студенческого чемпионата мира по программированию NEERC (http://neerc.ifmo.ru) участвуют команды из n институтов. Участники для проведения соревнований распределяются по k залам, каждый из которых имеет размеры, достаточные для размещения всех команд от всех институтов. При этом по правилам соревнований в одном зале может находиться не более одной команды от института.

Многие институты уже подали заявки на участие в полуфинале. Оргкомитет полуфинала хочет допустить до участия максимально возможное количество команд. При этом, разумеется, должна существовать возможность рассадить их по залам без нарушения правил.

Напишите программу, определяющую максимальное количество команд, которые можно допустить до участия в полуфинале.

Формат ввода

Первая строка входного файла input.txt содержит число n - число институтов, подавших заявки. Вторая строка входного файла содержит n чисел a1, …, an (ai - это количество команд, заявленных от института номер i). Последняя строка входного файла содержит число k - количество залов, в которых проходят соревнования.

Все числа во входном файле целые, положительные и не превосходят 10000.

Формат вывода

В выходной файл output.txt выведите одно целое число - ответ на задачу.

Примеры

Ввод Вывод
3
1 2 4
3		 6
3
1 2 4
4		 7
================================================ FILE: neznaika/Neznaika.java ================================================ package neznaika; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; import java.util.StringTokenizer; public class Neznaika { public static void main(String[] args) throws IOException { int t1, t2, s1, s2, s; Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); t1 = Integer.valueOf(st.nextToken()); t2 = Integer.valueOf(st.nextToken()); s1 = Integer.valueOf(st.nextToken()); s2 = Integer.valueOf(st.nextToken()); s = Integer.valueOf(st.nextToken()); String result = ""; if(s1 <= s2) { result = "NO"; }else { double v1 = (double) s1/t1; double way = 0, time = 0; if(s <= s1){ time = s * v1; }else { while (true){ way += s1; if(way >= s){ if(way == s){ time += t1; }else { double delta = (t1 - (s - s1) / v1); System.out.println(delta); time += delta; } break; }else { time += t1; way -= s2; time += t2; } } } result = String.valueOf(time); } FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: neznaika/README.md ================================================

Незнайка (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Незнайка и его друзья собрались в космическое путешествие. Они уже и новый звездолет построили. Хоть он и построен был с учетом новых технологий, был у него один большой недостаток. После T1 часов полета, аккумуляторы требовали обязательной подзарядки от солнечной батареи в течении T2 часов, а конструкция звездолета такова, что его двигатель на время подзарядки останавливается и звездолет начинает двигаться в обратную сторону. Известно, что за T1 часов полета звездолет улетает на S1 км, а за T2 часов разрядки возвращается на S2 км.

Требуется определить: сколько потребуется времени для полета Незнайки и его друзей на различные планеты, если известно расстояние S до планет.

Формат ввода

Входной файл input.txt содержит пять натуральных чисел, разделенных пробелами: T1, T2, S1, S2, S. Все числа не превышают 107.

Формат вывода

В выходной файл output.txt выведите время в часах (с точностью до двух знаков после запятой), за которое звездолет долетит до планеты. Если добраться до планеты не получится, то следует вывести «NO».

Примеры

Ввод Вывод
5 3 5 3 4 4.00
5 3 5 3 6 12.00
5 1 3 3 6 NO
10 1 100 20 500 65.00
================================================ FILE: number_buses/NumberBuses.java ================================================ package number_buses; import java.io.*; import java.util.*; import java.util.regex.Matcher; import java.util.regex.Pattern; public class NumberBuses { private static ArrayList data = new ArrayList<>(); private static ArrayList resultCheck = new ArrayList<>(); private static int flag = 0; private static void check(){ for(int i = 0; i < data.size(); i++){ if(i != 0){ String str = data.get(i).replaceAll("[^\\d+][^\\w+]", ""); // Вырезаем из строки все символы кроме цифр и букв int len = str.length(); Character[] ch = new Character[len]; for(int a = 0; a < len; a++){ ch[a] = str.charAt(a); } String line = "ABCEHKMOPTXY"; String numbers = "0123456789"; if(ch.length == 6){ if(ch[0] != null){ // 1 символ Pattern patternOne = Pattern.compile(String.valueOf(ch[0])); Matcher matcherOne = patternOne.matcher(line); if(matcherOne.find()){ flag++; } } if(ch[1] != null){ // 2 символ Pattern patternTwo = Pattern.compile(Character.toString(ch[1])); Matcher matcherTwo = patternTwo.matcher(numbers); if(matcherTwo.find()){ flag++; } } if(ch[2] != null){ // 3 символ Pattern patternThree = Pattern.compile(Character.toString(ch[2])); Matcher matcherThree = patternThree.matcher(numbers); if(matcherThree.find()){ flag++; } } if(ch[3] != null){ // 4 символ Pattern patternFour = Pattern.compile(Character.toString(ch[3])); Matcher matcherFour = patternFour.matcher(numbers); if(matcherFour.find()){ flag++; } } if(ch[4] != null){ // 5 символ Pattern patternFive = Pattern.compile(Character.toString(ch[4])); Matcher matcherFive = patternFive.matcher(line); if(matcherFive.find()){ flag++; } } if(ch[5] != null){ // 6 символ Pattern patternSix = Pattern.compile(Character.toString(ch[5])); Matcher matcherSix = patternSix.matcher(line); if(matcherSix.find()){ flag++; } } } resultCheck.add(String.valueOf(flag)); flag = 0; } } } private static void symbolChange(){ if(!resultCheck.isEmpty()){ for(int j = 0; j < resultCheck.size(); j++){ if(resultCheck.get(j).equals("6")){ resultCheck.set(j, "Yes"); }else{ resultCheck.set(j, "No"); } } } } public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ data.add(sc.nextLine()); } check(); symbolChange(); String result = String.valueOf(resultCheck).replaceAll(", ", "\n").replaceAll("^\\[|]$", ""); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: number_buses/README.md ================================================

Номера автобусов (16%)

Время: 1 сек.
Память: 16 Мб
Сложность: 16%

Однажды Вася очень долго просидел на остановке, прежде чем дождался своего автобуса. Чтобы как-то занять время, он решил записывать на листочке государственные регистрационные номера проходящих мимо автобусов, следующих по другому маршруту, нежели нужен был Васе. При этом производилась запись лишь основного номера, без учета региональной принадлежности. В итоге Васе удалось записать N таких номеров.

Основная часть государственного регистрационного номера состоит из 6 символов: трех букв и трех цифр. Сначала идет буква, затем 3 цифры и еще 2 буквы заканчивают запись. В качестве цифр могут использоваться любые цифры от 0 до 9, а в качестве букв только прописные буквы, обозначения которых присутствуют как в английском, так и в русском алфавите, т.е. только следующие символы: A, B, C, E, H, K, M, O, P, T, X, Y. Например, «P204BT» - правильный номер, а «X182YZ» и «ABC216» - нет.

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

Формат ввода

Первая строка входного файла input.txt содержит единственное натуральное число N – количество записанных Васей номеров (N ≤ 50). Далее следует N строк с записями номеров автобусов. Длины строк от 1 до 300 и содержат только символы с кодами ASCII от 33 до 127 (не содержат пробелов, специальных и русских символов).

Формат вывода

В выходной файл output.txt выведите N строк, в i-й строке должно содержаться «Yes», если соответствующая i-я запись номера верна и «No» в противном случае.

Примеры

Ввод Вывод
5 P204BT
X182YZ
a216bc
A216BC
ABC216		 Yes
No
No
Yes
No
================================================ FILE: number_e/NumberE.java ================================================ package number_e; import java.math.BigDecimal; import java.util.*; import java.io.*; public class NumberE { private static int symbolCount; private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); symbolCount = sc.nextInt(); } public static void main(String[] argv) throws IOException{ getData(); BigDecimal e = new BigDecimal("2.7182818284590452353602875"); // Число е String result = String.format("%(."+symbolCount+"f", e).replaceAll(",", "."); // Округление с заданной точностью PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: number_e/README.md ================================================

Число E (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

Выведите в выходной файл округленное до n знаков после десятичной точки число E. В данной задаче будем считать, что число Е в точности равно 2.7182818284590452353602875.

Формат ввода

Входной файл input.txt содержит целое число n (0 ≤ n ≤ 25).

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
0 3
25 2.7182818284590452353602875
13 2.7182818284590
================================================ FILE: number_of_smith/NumberOfSmith.java ================================================ package number_of_smith; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class NumberOfSmith { /** * @param numberData Число в формате строки * @return Число * */ private static int getNumber(String numberData) { return Integer.parseInt(numberData); } /** * @param number Число * @return Сумма цифр числа * */ private static int sumNumberSymbol(int number) { int sum = 0; while (number != 0) { sum += (number % 10); number /= 10; } return sum; } /** * @param number Число * @return true если число простое, false - иначе * */ private static boolean isSimple(int number) { double sqrt = Math.sqrt(number); if(number == 1 || number == 2) return true; if(number % 2 == 0) return false; for(int i = 3; i <= sqrt; i += 2){ if(number % i == 0) return false; } return true; } /** * @param number Число * @return Список простых множителей числа * */ private static ArrayList simpleMultipliers(int number) { ArrayList multipliers = new ArrayList<>(); for (int i = 2; i <= number;) { if (isSimple(i) && number % i == 0) { multipliers.add(i); number /= i; } else { i++; } } return multipliers; } /** * @param number Число * @return Сумма цифр простых множителей * */ private static int sumSimpleMultipliers(int number) { int sum = 0; ArrayList multipliers = simpleMultipliers(number); for (int multiplier : multipliers) { sum += sumNumberSymbol(multiplier); } return sum; } /** * @param numberData Число в формате строки * @return 1 если это число Смита, 0 - иначе * */ private static int isNumberOfSmith (String numberData) { int number = getNumber(numberData); if (!isSimple(number) && sumNumberSymbol(number) == sumSimpleMultipliers(number)) { return 1; } return 0; } public static void main(String[] args) throws IOException { String[] numbersInput = new Scanner(new FileReader("input.txt")).nextLine().split(" "); PrintWriter out = new PrintWriter(System.out); for (String number : numbersInput) { out.print(isNumberOfSmith (number)); } out.flush(); } } ================================================ FILE: number_of_smith/README.md ================================================

Числа Смита (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Число Смита — такое составное число, сумма цифр которого равняется сумме цифр всех его простых сомножителей. Так, примером числа Смита может служить 202, поскольку 2 + 0 + 2 = 4 и 2 + 1 + 0 + 1 = 4 (202 = 2 * 101). Напишите программу, которая для заданной последовательности чисел определяет, какие из них являются числами Смита.

Формат ввода

Входной файл input.txt содержит не более 20 натуральных чисел в пределах от 4 до 106.

Формат вывода

В выходной файл output.txt выведите строку из 0 и 1 (1, если соответствующее число является числом Смита и 0 иначе).

Примеры

Ввод Вывод
4 20 17 202 1001
================================================ FILE: number_palindrome/NumberPalindrome.java ================================================ package number_palindrome; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class NumberPalindrome { /** * @param numberInput Число * @param numberSystem Система счисления * @return Число в заданной системе счисления * */ private static String translateNumeralSystems(long numberInput, int numberSystem) { return Long.toString(numberInput, numberSystem); } /** * @param numberInput Число * @param numberSystem Система счисления * @return true - Число является палиндромом, false - Число не палиндром * */ private static boolean isPalindrome(long numberInput, int numberSystem) { char[] numberArray = translateNumeralSystems(numberInput, numberSystem).toCharArray(); int finish = numberArray.length - 1; for (int start = 0; start <= numberArray.length / 2; start++) { if (numberArray[start] != numberArray[finish]) { return false; } finish--; } return true; } /** * Печать результатов * @param numberSystems Коллекция с системами счисления * */ private static void printResult(ArrayList numberSystems) { PrintWriter out = new PrintWriter(System.out); if (numberSystems.size() == 1) { out.println("unique"); out.println(numberSystems.get(0)); } else if (numberSystems.size() > 1) { out.println("multiple"); for (int number: numberSystems) { out.print(number + " "); } } else { out.println("none"); } out.flush(); } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); long numberInput = sc.nextLong(); ArrayList numberSystems = new ArrayList<>(); for (int numberSystem = 2; numberSystem <= 36; numberSystem++) { if (isPalindrome(numberInput, numberSystem)) { numberSystems.add(numberSystem); } } printResult(numberSystems); } } ================================================ FILE: number_palindrome/README.md ================================================

Число - палиндром (29%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 29%

Напомним, что палиндромом называется строка, одинаково читающаяся с обеих сторон. Например, строка «ABBA» является палиндромом, а строка «ABC» - нет.

Необходимо определить, в каких системах счисления с основанием от 2 до 36 представление заданного числа N является палиндромом.

В системах счисления с основанием большим 10 в качестве цифр используются буквы английского алфавита: A, B, ... , Z. Например, A11 = 1010, Z36 = 3510.

Формат ввода

Входной файл input.txt содержит заданное число N в десятичной системе счисления (1 ≤ N ≤ 109).

Формат вывода

Если соответствующее основание системы счисления определяется единственным образом, то выведите в первой строке выходного файла output.txt слово «unique», если оно не единственно — выведите в первой строке выходного файла слово «multiple». Если же такого основания системы счисления не существует — выведите в первой строке выходного файла слово «none».

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

Примеры

Ввод Вывод
123 unique
6
111 multiple
6 10 36
102892748 none
================================================ FILE: number_participants_olympiad/NumberParticipantsOlympiad.java ================================================ package number_participants_olympiad; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class NumberParticipantsOlympiad { public static void main (String[] args) throws IOException { Scanner scan = new Scanner(new FileReader("input.txt")); String[] items = scan.nextLine().split(" "); int k = Integer.parseInt(items[0]); int n = Integer.parseInt(items[1]); int m = Integer.parseInt(items[2]); int d = Integer.parseInt(items[3]); int itemCount = 0; for (int item = 1; item <= (k*m*n*d); item++) { if ((item % k == 0 && item % n == 0 && item % m == 0) && (item /k + item /n + item /m == item - d)) { itemCount = item; break; } } itemCount = itemCount > 0 ? itemCount : -1; PrintWriter out = new PrintWriter(System.out); out.println(itemCount); out.flush(); } } ================================================ FILE: number_participants_olympiad/README.md ================================================

Количество участников олимпиады (29%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 29%

Как известно, на вопрос о том, сколько у него учеников, древнегреческий учёный Пифагор отвечал так: "Половина моих учеников изучает математику, четвертая часть изучает природу, седьмая часть проводит время в молчаливом размышлении, остальную часть составляют 3 девы".

Секретарь олимпиады на вопрос: "Сколько участников на олимпиаде по информатике?", отвечал подобно Пифагору: "K-тая часть участников начала решать первую задачу, M-тая часть – вторую, а N-тая – третью. В то же время D участников решают проблему: "С чего начать?". Ваша задача определить количество участников олимпиады или вывести -1, если секретарь ошибся.

Формат ввода

В единственной строке входного файла input.txt записаны числа K, N, M, D (1 ≤ K, N, M, D ≤ 100).

Формат вывода

В единственную строку выходного файла output.txt нужно вывести одно число - количество участников олимпиады или вывести -1, если секретарь ошибся.

Примеры

Ввод Вывод
2 4 7 3 28
2 2 2 3 -1
================================================ FILE: numbers/Numbers.java ================================================ package numbers; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.Scanner; public class Numbers { public static void main(String[] args) throws IOException { String min, max; ArrayList numbers = new ArrayList<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String numberIn = sc.nextLine(); char[] ch = numberIn.toCharArray(); for(Character symbol : ch){ numbers.add(String.valueOf(symbol)); } // Максимальное число numbers.sort(Comparator.reverseOrder()); StringBuilder str = new StringBuilder(); for(String symbol : numbers){ str.append(symbol); } max = String.valueOf(str); // Минимальное число Collections.sort(numbers); int zeroCount = 0; str = new StringBuilder(); for (String number : numbers) { if (number.equals("0")) { zeroCount++; } else { if (zeroCount != 0) { str.append(number); for (int j = zeroCount; j > 0; j--) { str.append("0"); } zeroCount = 0; } else { str.append(number); } } } min = String.valueOf(str); FileWriter out = new FileWriter("output.txt"); out.write(min + " " + max); out.close(); } } ================================================ FILE: numbers/README.md ================================================

Наименьшее и наибольшее числа из тех же цифр (23%)

Время: 1 сек.
Память: 16 Мб
Сложность: 23%

Требуется написать программу, которая найдет наименьшее и наибольшее числа, состоящие из тех же цифр, что и заданное натуральное число N.

Формат ввода

Входной файл INPUT.TXT содержит натуральное число N (N ≤ 2×109).

Формат вывода

Выходной файл OUTPUT.TXT должен содержать в одной строке наименьшее, а через пробел – наибольшее числа.

Примеры

Ввод Вывод
7051 1057 7510
851 158 851
================================================ FILE: numbers_game/NumbersGame.java ================================================ package numbers_game; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayDeque; import java.util.Scanner; import java.util.StringTokenizer; public class NumbersGame { private static ArrayDeque queue = new ArrayDeque<>(); private static int play(){ int player = 0; if(queue.getFirst() >= queue.getLast()){ player += queue.getFirst(); queue.removeFirst(); }else { player += queue.getLast(); queue.removeLast(); } return player; } public static void main(String[] args) throws IOException { int firstPlayerPoints = 0; int secondPlayerPoints = 0; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ queue.add(Integer.valueOf(st.nextToken())); } } queue.removeFirst(); int steps = queue.size(); for (int i = 0; i < steps; i++){ if (i % 2 == 0){ firstPlayerPoints += play(); }else { secondPlayerPoints += play(); } } String result = firstPlayerPoints + ":" + secondPlayerPoints; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: numbers_game/README.md ================================================

Игра в числа (23%)

Время: 1 сек.
Память: 16 Мб
Сложность: 23%

Игра в числа ведётся на одномерном массиве целых положительных чисел. Перед началом, жеребьёвкой определяется, кто будет ходить первым (первый игрок), а кто – вторым (второй игрок). Процесс игры состоит в том, что игроки по очереди (сначала первый игрок, затем второй, следом опять первый и так далее) вычёркивают числа из массива. Вычеркнуть можно только число, находящееся в конце или начале оставшегося массива. При этом всегда вычёркивается максимальное число из этих двух. Если первое и последнее числа массива равны, то вычёркивается первое. Игра продолжается до того момента, пока не будут вычеркнуты все числа. Каждое вычеркнутое число идёт в актив тому игроку, который его вычеркнул. После окончания игры каждый игрок суммирует вычеркнутые им числа. Победителем объявляется тот, кто наберет больше очков.

Некоторые игроки поняли, что результат не зависит от стратегии игры, и решили попросить Вас написать программу для получения результата.

Формат ввода

В первой строке входного файла input.txt находится одно целое число N – количество чисел в массиве (1 ≤ N ≤ 104). Во второй строке находятся N целых положительных чисел из диапазона [1, 32000], разделённых пробелом.

Формат вывода

В выходной файл OUTPUT.TXT выведите два числа, разделенные двоеточием. Первое число – количество очков, набираемых первым игроком при игре на этом массиве, второе число – для второго.

Примеры

Ввод Вывод
5
4 4 1 5 4		 9:9
1
1234		 1234:0
================================================ FILE: numbers_without_same_digit/NumbersWithoutSameDigit.java ================================================ package numbers_without_same_digit; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.HashSet; import java.util.Scanner; import java.util.Set; public class NumbersWithoutSameDigit { public static void main(String[] args) throws IOException { Scanner scan = new Scanner(new FileReader("input.txt")); int numberIn = scan.nextInt(); int index = 0; int numberOut = 0; while (index != numberIn){ numberOut++; int numberOutCopy = numberOut; boolean isSet = true; Set digit = new HashSet<>(); while (numberOutCopy != 0){ if(digit.contains(numberOutCopy % 10)){ isSet = false; }else { digit.add(numberOutCopy % 10); } numberOutCopy /= 10; } index += isSet ? 1 : 0; } System.out.println(numberOut); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(numberOut)); out.close(); } } ================================================ FILE: numbers_without_same_digit/README.md ================================================

Числа без одинаковых цифр (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Антон записал ряд натуральных чисел в порядке возрастания: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 и т.д. Затем вычеркнул из него все числа, в которых имеется хотя бы две одинаковых цифры, и получил последовательность: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23 и т.д.

Вам необходимо по заданному N найти N-ое по счету число в получившейся последовательности.

Формат ввода

В единственной строке входного файла input.txt записано натуральное число N (1 ≤ N ≤ 10000).

Формат вывода

В единственную строку выходного файла output.txt нужно вывести N-ое по счету число без одинаковых цифр.

Примеры

Ввод Вывод
100 123
================================================ FILE: numerologist/Numerologist.java ================================================ package numerologist; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class Numerologist { public static void main(String[] args)throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String time = sc.nextLine(); int index = 0; while (time.length() > 1){ long timeLong = 0; char[] chArr = time.toCharArray(); for (char aChArr : chArr) { timeLong += Character.getNumericValue(aChArr); } index++; time = String.valueOf(timeLong); } String result = time + " " + index; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: numerologist/README.md ================================================

Нумеролог (24%)

Время: 1 сек.
Память: 16 Мб
Сложность: 24%

Чтобы предсказать судьбу человека, нумеролог берет время жизни человека в секундах, затем складывает все цифры этого числа. Если полученное число состоит более чем из одной цифры, операция повторяется, пока в числе не останется одна цифра. Затем по полученной цифре и числу операций, необходимых для преобразования числа в цифру нумеролог предсказывает судьбу человека. Нумеролог плохо умеет считать, а числа, с которыми он работает, могут быть очень большими. Напишите программу, которая бы делала все расчеты за него.

Формат ввода

Входной файл input.txt содержит число N – время жизни человека в секундах (1 ≤ N ≤ 101000).

Формат вывода

В выходной файл output.txt выведите два числа через пробел: полученную цифру из числа N и число преобразований.

Пример 1

Ввод Вывод
1 1 0
10 1 1
99 9 2
================================================ FILE: nutlets/Nutlets.java ================================================ package nutlets; import java.io.*; import java.util.*; public class Nutlets { public static void main(String[] args) throws IOException { String symbol; ArrayList number = new ArrayList<>(); String str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while(st.hasMoreTokens()){ number.add(Integer.valueOf(st.nextToken())); } symbol = (number.get(0) * number.get(1) >= number.get(2)) ? "YES" : "NO"; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(symbol); fileOut.close(); } } ================================================ FILE: nutlets/README.md ================================================

Орешки (3%)

Время: 1 сек.
Память: 16 Мб
Сложность: 3%

Белочка собрала в лесу N шишек c орешками. Белочка очень привередливо выбирала шишки, и брала только те, в которых ровно M орешков. Также известно, что для пропитания зимой ей необходимо не менее K орешков. Определите, хватит ли на зиму орешков белочке.

Формат ввода

Входной файл input.txt содержит три натуральных числа: N, M и K (N, M ≤ 100, K ≤ 10 000).

Формат вывода

В выходной файл output.txt выведите «YES» если белочке хватит орешков и «NO» в противном случае.

Пример 1

Ввод Вывод
4 5 20 YES
4 5 21 NO
3 2 1 YES
================================================ FILE: office/Office.java ================================================ package office; import java.util.*; import java.io.*; public class Office { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } } public static void main(String[] argv) throws IOException{ getData(); int peopleAllDay = 0; for (Integer aData : data) { peopleAllDay += aData; } int result = peopleAllDay / 27; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(result)); pw.close(); } } ================================================ FILE: office/README.md ================================================

Офис (18%)

Время: 1 сек.
Память: 16 Мб
Сложность: 18%

Летом Вася очень любил смотреть в окно. Напротив его дома расположился офис некоторой строительной фирмы. В течение всего месяца Вася наблюдал за его сотрудниками. Про каждый из 31 дня месяца он знает, сколько сотрудников пришло на работу. Ему также известно, что каждый из сотрудников берет ровно по 4 выходных в месяц.

Теперь он ломает голову над загадкой – сколько всего сотрудников работает в этом офисе. Напишите программу, которая ответит Васе на этот вопрос.

Формат ввода

В единственной строке входного файла input.txt записано 31 целое неотрицательное число. Эти числа описывают количество сотрудников, пришедших в офис в соответствующие дни месяца. Гарантируется, что входные данные корректны.

Формат вывода

В единственную строку выходного файла output.txt нужно вывести единственное число – общее количество сотрудников офиса. Гарантируется, что ответ не превышает 100.

Примеры

Ввод Вывод
10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 0 0 0 0 10
================================================ FILE: only_right_down/OnlyRightDown.java ================================================ package only_right_down; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class OnlyRightDown { private static int n = 0; private static int m = 0; // получить данные private static int[][] _getData() throws IOException { int [][] data = new int[0][]; Scanner sc = new Scanner(new FileReader("input.txt")); int row = -1; while (sc.hasNextLine()) { String line = sc.nextLine(); if (row > -1) { String[] cells = line.split(" "); for (int column = 0; column < cells.length; column++) { data[row][column] = Integer.parseInt(cells[column]); } } else { String[] size = line.split(" "); n = Integer.parseInt(size[0]); m = Integer.parseInt(size[1]); data = new int[n][m]; } row++; } return data; } public static void main(String[] args) throws IOException { int[][] data = _getData(); // данные int[][] ways = new int[n][m]; // подсчет шагов ways[0][0] = 1; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { // значение в последней клетке не учитываем if (i == n-1 && j == m-1) { break; } int num = data[i][j]; if (ways[i][j] > 0) { if (i+num < n) { // можно сделать шаг по вертикали ways[i+num][j] += ways[i][j]; } if (j+num < m) { // можно сделать шаг по горизонтали ways[i][j+num] += ways[i][j]; } } } } PrintWriter out = new PrintWriter(System.out); out.println(ways[n-1][m-1]); out.flush(); } } ================================================ FILE: only_right_down/README.md ================================================

Только вправо или вниз (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

Игровое поле N×M заполняется целыми числами, одно неотрицательное целое число в каждой клетке. Цель игры состоит в том, чтобы пройти по любому разрешенному пути от верхнего левого угла до правого нижнего. Целое число в каждой клетке указывает, какой длины шаг должен быть из текущей клетки. Все шаги могут быть или направо или вниз. Если в результате какого-либо шага игрок покидает пределы поля, такой шаг запрещается.

На рис. 1 приведен пример игрового поля 3×4, где сплошная окружность показывает положение начала, а пунктирная окружность – цель. Рис. 2 показывает три возможных пути от начала до цели для рассматриваемого примера игрового поля, с удаленными промежуточными числами.

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

Формат ввода

Входной файл INPUT.TXT содержит в первой строке размеры поля N (1 ≤ N ≤ 70) и M (1 ≤ M ≤ 70). В последующих N строках входного файла, каждая из которых описывает отдельную строку игрового поля, записаны через пробел по M целых чисел от 0 до 100 – длины шагов из клеток данной строки.

Формат вывода

Выходной файл OUTPUT.TXT должен содержать одно число - число различных вариантов путей от верхнего левого угла до правого нижнего. Для каждого поля будет менее чем 231 различных путей.

Примеры

Ввод Вывод
3 4
2 1 1 2
3 2 1 44
3 1 1 0		 3
================================================ FILE: optimization_circle/OptimizationCircle.java ================================================ package optimization_circle; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; import java.util.StringTokenizer; public class OptimizationCircle { public static void main(String[] args) throws IOException { double a = 0, b = 0, r = 0; double max, x, y; Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ a = Double.valueOf(st.nextToken()); b = Double.valueOf(st.nextToken()); r = Double.valueOf(st.nextToken()); } max = Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2)) * r; double countVar = max / (Math.pow(a, 2) + Math.pow(b, 2)); x = a * countVar; y = b * countVar; String xRes = String.format("%.7f", x).replaceAll(",", "."); String yRes = String.format("%.7f", y).replaceAll(",", "."); String result = max + "\n" + xRes + " " + yRes; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: optimization_circle/README.md ================================================

Короткая последовательность (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Найдите максимальное значение функции f(x, y) = Ax + By при условии, что x2 + y2 = R2, и аргументы, при котором оно достигается.

Формат ввода

Входной файл input.txt содержит три вещественных числа: A, B, R (1 ≤ A, B, R ≤ 10), заданные не более чем с тремя знаками после десятичной точки.

Формат вывода

В первой строке выходного файла output.txt выведите максимальное значение, которое достигает функция. Во второй строке выведите значения аргументов x0,y0, при которых это значение достигается. Все числа должны быть выведены с точностью не хуже 10−5.

Примеры

Ввод Вывод
1 1 1 1.414213562373
0.707106781187 0.707106781187
2.0 1.0 1.0 2.236067977500
0.894427191000 0.447213595500
================================================ FILE: oranges/Oranges.java ================================================ package oranges; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; import java.util.StringTokenizer; public class Oranges { private static long decision(long a, long b){ if(a * b == 0){ return a + b; } if(a < b){ return decision(a, b % a); }else { return decision(a % b, b); } } public static void main(String[] args) throws IOException { long friends = 0; long oranges = 0; Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ friends = Integer.valueOf(st.nextToken()); oranges = Integer.valueOf(st.nextToken()); } long result; if(oranges % friends == 0){ result = 1; }else { result = friends/decision(friends, oranges); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: oranges/README.md ================================================

Апельсины (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Катя решила пригласить к себе в гости n друзей. Так как ее друзья очень любят фрукты, то в качестве угощения для них она купила m одинаковых апельсинов.

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

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

Формат ввода

Входной файл input.txt содержит два положительных целых числа n и m (1 ≤ n, m ≤ 109).

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
2 5 2
2 4 1
================================================ FILE: oversteping/Oversteping.java ================================================ package oversteping; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class Oversteping { public static void main(String[] agrs) throws IOException { String[] data = new Scanner(new FileReader("input.txt")).nextLine().split(" "); int n = Integer.parseInt(data[0]); BigInteger m = new BigInteger(data[1]); BigInteger pow = BigInteger.TWO.pow(n); BigInteger answer = BigInteger.TWO.modPow(pow, m); PrintWriter out = new PrintWriter(System.out); out.println(answer); out.flush(); } } ================================================ FILE: oversteping/README.md ================================================

Сверхстепень (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Назовем значение выражения 22n n-ой сверхстепенью числа 2. Таким образом, например, третья сверхстепень числа 2 равна 223 = 28 = 256.

Ваша задача – вычислить n-ую сверхстепень двойки по модулю m.

Формат ввода

Входной файл INPUT.TXT содержит два целых числа: n (0 ≤ n ≤ 105) и m (2 ≤ m ≤ 104).

Формат вывода

В выходной файл OUTPUT.TXT выведите ответ на задачу.

Примеры

Ввод Вывод
3 1000 256
10 10 6
================================================ FILE: palindrome/Palindrome.java ================================================ package palindrome; import java.io.*; import java.util.*; public class Palindrome { public static void main(String[] args) throws IOException { ArrayList number = new ArrayList<>(); // Прямой порядок символов ArrayList numberReverse = new ArrayList<>(); // Обратный порядок символов String result; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); char[] ch = str.toCharArray(); for (char aCh : ch) { number.add(String.valueOf(aCh)); } for(int j = ch.length; j >0; j--){ // Записать в коллекцию в обратном порядке numberReverse.add(String.valueOf(ch[j-1])); } result = (number.equals(numberReverse)) ? "YES" : "NO"; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: palindrome/README.md ================================================

Четырехзначный палиндром (10%)

Время: 1 сек.
Память: 16 Мб
Сложность: 10%

Требуется написать программу, определяющую, является ли четырехзначное натуральное число N палиндромом, т.е. числом, которое одинаково читается слева направо и справа налево.

Формат ввода

Входной файл input.txt содержит натуральное число N (1000 ≤ N ≤ 9999).

Формат вывода

В выходной файл output.txt следует вывести слово «YES», если число N является палиндромом, или «NO» – если нет.

Примеры

Ввод Вывод
6116 YES
1231 NO
================================================ FILE: palindromic_time/PalindromicTime.java ================================================ package palindromic_time; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; import java.util.StringTokenizer; public class PalindromicTime { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine(), ":"); int hourIn = Integer.valueOf(st.nextToken()); int minuteIn = Integer.valueOf(st.nextToken()); StringBuffer hour; StringBuffer minute; while (true){ minuteIn++; if(minuteIn >=59){ hourIn++; minuteIn = -1; } if(hourIn == 24){ hourIn = 0; } hour = String.valueOf(hourIn).length() == 1 ? new StringBuffer("0" + hourIn) : new StringBuffer(String.valueOf(hourIn)); minute = String.valueOf(minuteIn).length() == 1 ? new StringBuffer("0" + minuteIn) : new StringBuffer(String.valueOf(minuteIn)); minute.reverse(); if(String.valueOf(hour).equals(String.valueOf(minute))){ minute.reverse(); break; } } String result = String.valueOf(hour) + ":" + String.valueOf(minute); FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: palindromic_time/README.md ================================================

Палиндромное время (24%)

Время: 1 сек.
Память: 16 Мб
Сложность: 24%

Пекарь считает, что для получения рождественского пирога идеальной симметричной формы его нужно вынимать из духовки в тот момент, когда часы показывают «палиндромное» время, которое читается одинаково слева-направо и справа-налево.

Напишите программу, которая определяет по времени установки пирога в духовку время, когда будет подходящее время для его извлечения.

Формат ввода

В единственной строке входного файла input.txt записано время установки пирога в духовку в формате HH:MM (00 ≤ HH ≤ 23, 00 ≤ MM ≤ 59).

Формат вывода

В единственную строку выходного файла output.txt нужно вывести ближайшее «палиндромное» время в формате HH:MM.

Примеры

Ввод Вывод
00:00 01:10
12:34 13:31
23:59 00:00
================================================ FILE: parallelepiped/Parallelepiped.java ================================================ package parallelepiped; import java.io.*; import java.util.*; public class Parallelepiped { public static void main(String[] args) throws IOException { ArrayList side = new ArrayList<>(); String squareSide; long square; long volume; String str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ side.add(Long.valueOf(st.nextToken())); } volume = side.get(0) * side.get(1) * side.get(2); // Расчет объема square = (side.get(0) * side.get(1) + side.get(0) * side.get(2) + side.get(1) * side.get(2)) * 2; // Расчет площади поверхности фигуры squareSide = square + " " + volume; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(squareSide); fileOut.close(); } } ================================================ FILE: parallelepiped/README.md ================================================

Прямоугольный параллелепипед (10%)

Время: 1 сек.
Память: 16 Мб
Сложность: 10%

Прямоугольный параллелепипед - это объемная фигура, у которой шесть граней, и каждая из них является прямоугольником. Моделями прямоугольного параллелепипеда служат классная комната, кирпич, спичечная коробка. Длины трех ребер прямоугольного параллелепипеда, имеющих общий конец, называют его измерениями. На приведенном рисунке измерения представлены ребрами AB, BC и BF с общим концом в точке B, а значения измерений равны их длинам a, b и c соответственно.

По заданным измерениям прямоугольного параллелепипеда Вам необходимо определить площадь его поверхности и объем.

Формат ввода

Единственная строка входного файла input.txt содержит разделенные пробелом три натуральных числа A, B и С – измерения параллелепипеда, каждое из измерений не превышает 106.

Формат вывода

В выходной файл output.txt выведите через пробел два целых числа: площадь поверхности и объем заданного параллелепипеда.

Примеры

Ввод Вывод
1 1 1 6 1
2 3 4 52 24
================================================ FILE: percents/Percents.java ================================================ package percents; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.HashMap; import java.util.Map; import java.util.Scanner; public class Percents { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); sc.nextLine(); ArrayList proportions = new ArrayList<>(); ArrayList importance = new ArrayList<>(); int count = 0; while (sc.hasNextLine()) { String[] line = sc.nextLine().split(" "); importance.add(line[0]); int percent = Integer.parseInt(line[1]); proportions.add(percent); count += percent; } ArrayList> percents = new ArrayList<>(); double percentAverage = 100/(double)count; int percentCount = 0; int priorityHighCount = 0; // дробный важный компонент int priorityLowCount = 0; // дробный неважный компонент for (int i = 0; i < proportions.size(); i++) { double percentFloat = proportions.get(i) * percentAverage; int percent = (int) Math.floor(percentFloat); int priority = percentFloat != percent && importance.get(i).equals("+") ? 2 : percentFloat != percent && importance.get(i).equals("-") ? 1 : 0; if (priority == 2) { priorityHighCount++; } else if (priority == 1) { priorityLowCount++; } Map percentInfo = new HashMap<>(); percentInfo.put(percent, priority); percents.add(percentInfo); percentCount += percent; } int percentageDifference = 100 - percentCount; int priorityTwo = percentageDifference - priorityHighCount; // количество процентов с приоритетом 2 int priorityOne = 0; // кол-во процентов с приоритетом 1 int priorityZero = 0; // количество процентов с приоритетом 0 if (priorityTwo <= 0) { priorityTwo = percentageDifference; } else { priorityTwo = priorityHighCount; priorityOne = percentageDifference - priorityLowCount; if (priorityOne <= 0) { priorityOne = priorityLowCount; } else { priorityZero = percentageDifference - (priorityHighCount + priorityLowCount); } } for (int i = 0; i < percents.size(); i++) { if (percentageDifference == 0) { break; } Map mapTmp = percents.get(i); for (int key : mapTmp.keySet()) { int priority = mapTmp.get(key); if (priority == 2 && priorityTwo > 0) { mapTmp.put(key+1, priority); mapTmp.remove(key); priorityTwo--; percentageDifference--; percents.set(i, mapTmp); } else if (priority == 1 && priorityOne > 0) { mapTmp.put(key+1, priority); mapTmp.remove(key); priorityOne--; percentageDifference--; percents.set(i, mapTmp); } else if (priority == 0 && priorityZero > 0) { mapTmp.put(key+1, priority); mapTmp.remove(key); priorityZero--; percentageDifference--; percents.set(i, mapTmp); } } } PrintWriter out = new PrintWriter(System.out); for (Map percent : percents) { for (int key : percent.keySet()) { out.println(key); } } out.flush(); } } ================================================ FILE: percents/README.md ================================================

Проценты (33%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 33%

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

Однако и здесь есть определенные тонкости. Нетрудно убедиться, что, если округлять все дробные числа процентов по математическим правилам, то результирующая сумма может отличаться от нужной. Поэтому никто не сможет усомниться в вашей честности, если вы произведете округление так, как сочтете нужным. Осталось только найти лучший вариант.

Вам заданы количества всех ингредиентов, входящих в состав продукта. Для каждого ингредиента известно, положительно или отрицательно влияет на продажи его присутствие в составе. По этим данным необходимо рассчитать процентные доли каждого из ингредиентов от их суммарного количества и округлить их в нужную сторону. При этом не следует допускать, чтобы одновременно доля какого-либо вредного компонента была округлена вверх, а доля какого-либо хорошего - вниз.

Формат ввода

В первой строке входного файла INPUT.TXT задано количество ингредиентов n (1 ≤ n ≤ 30). Следующие n строк описывают сами ингредиенты: знак «+» для положительно влияющих на продажи, и «-» для отрицательно влияющих, а затем, через пробел, количество соответствующего ингредиента - целое число от 1 до 1000.

Формат вывода

В выходной файл OUTPUT.TXT выведите n целых чисел, в сумме дающих 100, по одному на строке - процентные содержания ингредиентов.

Примеры

Ввод Вывод
2
- 10
+ 5		 66
34
3
- 10
- 10
- 10		 33
34
33
================================================ FILE: permutation/Permutation.java ================================================ package permutation; import java.io.*; import java.util.*; public class Permutation { public static void main(String[] args) throws IOException { ArrayList numbers = new ArrayList<>(); String out; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while(st.hasMoreTokens()){ numbers.add(Integer.valueOf(st.nextToken())); } out = (numbers.get(0) + numbers.get(1) == numbers.get(2)) ? "YES" : (numbers.get(0) + numbers.get(2) == numbers.get(1)) ? "YES" : (numbers.get(1) + numbers.get(2) == numbers.get(0)) ? "YES" : "NO"; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(out); fileOut.close(); } } ================================================ FILE: permutation/README.md ================================================

От перестановки что-то меняется ... (9%)

Время: 1 сек.
Память: 16 Мб
Сложность: 9%

Всем известно, что «от перестановки слагаемых сумма не изменяется». Однако, случается и так, что перестановка двух чисел приводит к более интересным последствиям.

Пусть, например, заданы три числа: a1, a2, a3. Рассмотрим равенство a1+ a2= a3. Оно может быть неверным (например, если a1= 1, a2= 4, a3= 3), однако может стать верным, если поменять некоторые числа местами (например, если поменять местами a2 и a3, оно обратится в равенство 1 + 3 = 4).

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

Формат ввода

Входной файл input.txt содержит три целых числа: a1, a2, a3 (−108 ≤ a1, a2, a3 ≤ 108).

Формат вывода

В выходной файл output.txt выведите заданную последовательность в обратном порядке.

Примеры

Ввод Вывод
3 5 2 YES
2 2 5 NO
2 2 4 YES
================================================ FILE: phone/Phone.java ================================================ package phone; import java.io.*; import java.util.*; public class Phone { private static long result; private static ArrayList data = new ArrayList<>(); private static void in(){ // обработка входных данных String str; FileReader file = null; try { file = new FileReader("input.txt"); } catch (FileNotFoundException e) { e.printStackTrace(); } Scanner sc = new Scanner(Objects.requireNonNull(file)); // Если есть файл str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Long.valueOf(st.nextToken())); } } private static void out() throws IOException { // Выходные данные FileWriter fileOut = null; try { fileOut = new FileWriter("output.txt"); } catch (IOException e) { e.printStackTrace(); } Objects.requireNonNull(fileOut).write(String.valueOf(result)); fileOut.close(); } public static void main(String[] args) throws IOException { in(); result = (data.get(3) >= data.get(0)) ? data.get(0) * data.get(1) + (data.get(3) - data.get(0)) * data.get(2) : data.get(3) * data.get(1); System.out.println(result); out(); } } ================================================ FILE: phone/README.md ================================================

Телефон (12%)

Время: 1 сек.
Память: 16 Мб
Сложность: 12%

Услуги телефонной сети оплачиваются по следующему правилу: за разговоры до А минут в месяц – В рублей за минуту, а разговоры сверх установленной нормы оплачиваются из расчета С рублей за минуту. Требуется написать программу, вычисляющую плату за пользование телефоном для разговоров продолжительностью Т минут в месяц.

Формат ввода

Входной файл input.txt содержит натуральные числа A, B, C и T, не превышающие 1000. Числа располагаются в одной строке и разделены пробелами.

Формат вывода

В выходной файл output.txt выведите единственное целое число – месячную плату за пользование телефоном.

Примеры

Ввод Вывод
30 2 3 30 60
20 1 3 30 50
================================================ FILE: photographic_negative/PhotographicNegative.java ================================================ package photographic_negative; import java.util.*; import java.io.*; public class PhotographicNegative { private static ArrayList data = new ArrayList<>(); // Исходные данные построчно private static ArrayList imgOriginal = new ArrayList<>(); // Пиксели оригинального изображения private static ArrayList imgNegative = new ArrayList<>(); // Пиксели негатива private static void getData() throws IOException{ // Получение данных из файла FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(st.nextToken()); } } } private static void dataProcessing(){ // Перебор данных for(int i = 0; i < data.size(); i++){ int numberLine = Integer.valueOf(data.get(0)); if(i != 0 && i != 1){ // Игнорируем цифры из файла if(i < numberLine + 2){ // Берем первые строки - изображение оригинала char[] chOrigig = data.get(i).toCharArray(); for (char aChOrigig : chOrigig) { imgOriginal.add(String.valueOf(aChOrigig)); } }else{ char[] chNegative = data.get(i).toCharArray(); for (char aChNegative : chNegative) { String symbol = String.valueOf(aChNegative); if (symbol.equals("B")) { // Заменить символы для негатиива imgNegative.add("W"); } else { imgNegative.add("B"); } } } } } } public static void main(String[] argv) throws IOException{ getData(); dataProcessing(); int wrong = 0; // Количество неверных пикселей for(int i = 0; i < imgOriginal.size(); i++){ if(!imgOriginal.get(i).equals(imgNegative.get(i))){ // Если символы не совпадают wrong++; // Увеличить значение ошибки на 1 } } PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(wrong)); pw.close(); } } ================================================ FILE: photographic_negative/README.md ================================================

Миша и негатив (17%)

Время: 1 сек.
Память: 16 Мб
Сложность: 17%

Миша уже научился хорошо фотографировать и недавно увлекся программированием. Первая программа, которую он написал, позволяет формировать негатив бинарного черно-белого изображения.

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

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

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

Требуется написать программу, которая в качестве входных данных использует исходное бинарное черно-белое изображение и полученный Мишиной программой негатив, и на основе этого определяет количество пикселей, в которых допущена ошибка.

Формат ввода

Первая строка входного файла input.txt содержит целые числа n и m (1 ≤ n, m ≤ 100) – высоту и ширину исходного изображения (в пикселях). Последующие n строк содержат описание исходного изображения. Каждая строка состоит из m символов «B» и «W». Символ «B» соответствует черному пикселю, а символ «W» – белому. Далее следует пустая строка, а после нее – описание выведенного Мишиной программой изображения в том же формате, что и исходное изображение.

Формат вывода

В выходной файл output.txt необходимо вывести число пикселей негатива, которые неправильно сформированы Мишиной программой.

Примеры

Ввод Вывод
3 4
WBBW
BBBB
WBBW

BWWW
WWWB
BWWB		 2
2 2
BW
BB

WW
BW		 2
================================================ FILE: picking_blueberries/PickingBlueberries.java ================================================ package picking_blueberries; import java.util.*; import java.io.*; public class PickingBlueberries { private static ArrayList berryCount = new ArrayList<>(); private static ArrayList berrySum = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ berryCount.add(Integer.valueOf(st.nextToken())); } } } public static void main(String[] argv) throws IOException{ getData(); for(int i = 0; i < berryCount.size(); i++){ if(i == 0){ // Убираем количество кустов berryCount.remove(0); } } berryCount.add(berryCount.get(0)); // Добавляем кол-во ягод на 1м кусте в конец коллекции berryCount.add(berryCount.get(1)); // Добавляем кол-во ягод на 2м кусте в конец коллекции int result = 0; for(int i = 0; i < berryCount.size(); i++){ if(i+1 < berryCount.size() && i+2 < berryCount.size()){ result = berryCount.get(i) + berryCount.get(i+1) + berryCount.get(i+2); // Считаем количество ягод на 3х соседних кустах } berrySum.add(result); result = 0; } berrySum.sort(Collections.reverseOrder()); // Сортируем последовательность с количеством ягод на 3 кустах в обратном порядке result = berrySum.get(0); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(result)); pw.close(); } } ================================================ FILE: picking_blueberries/README.md ================================================

Сбор черники (17%)

Время: 1 сек.
Память: 16 Мб
Сложность: 17%

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

Эти кусты обладают разной урожайностью, поэтому ко времени сбора на них выросло различное число ягод – на i-ом кусте выросло ai ягод.

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

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

Формат ввода

Первая строка входного файла input.txt содержит целое число N (3 ≤ N ≤ 1000) – количество кустов черники. Вторая строка содержит N целых положительных чисел a1, a2, ..., aN – число ягод черники, растущее на соответствующем кусте. Все ai не превосходят 1000.

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
4
1 2 3 4		 9
3
1 2 3		 6
================================================ FILE: ping/Ping.java ================================================ package ping; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class Ping { public static void main(String[] args) throws IOException { ArrayList packets = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); String ip = sc.nextLine().substring(5); for (int i = 0; i < 4; i++) { packets.add(sc.nextLine()); } int received, lost = 0, percentLost = 0; int minimum = 10000, maximum = 0, average, timeSum = 0; for (String packet : packets) { if (packet.equals("Time out")) { lost++; percentLost += 25; } else { int time = Integer.parseInt(packet.substring(packet.lastIndexOf("=")+1)); timeSum += time; if (time < minimum) { minimum = time; } if (time > maximum) { maximum = time; } } } PrintWriter out = new PrintWriter(System.out); received = 4 - lost; out.println("Ping statistics for " + ip + ":"); out.println("Packets: Sent = 4 Received = " + received + " Lost = " + lost + " (" + percentLost + "% loss)"); if (lost < 4) { average = Math.round((float) timeSum / received); out.println("Approximate round trip times:"); out.println("Minimum = " + minimum + " Maximum = " + maximum + " Average = " + average); } out.flush(); } } ================================================ FILE: ping/README.md ================================================

Степенные числа (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

Вася получает доступ в Интернет с помощью мобильного телефона. Однако такая связь очень нестабильна, поэтому каждый раз после подключения ему приходиться проверять подключение. Для этого он просто в командной строке набирает примерно следующую фразу: «ping name», где name – это имя удаленного сервера, который точно находится в сети. Затем идет обмен пакетами с сервером и выдается статистика. Однако у Васи недавно сломался модуль, отвечающий за подсчет и вывод статистики. Вам надо будет помочь Васе – написать аналогичный модуль.

После вызова команды «ping» на удаленный сервер по очереди посылаются 4 пакета по 32 байта. Как только удаленный сервер получил пакет, он отвечает на него. Если пакет не уложился в определенное время (он должен дойти до удаленного сервера и вернуться обратно) в силу тех или иных причин (низкая скорость, отсутствие подключения и т.д.), он считается утерянным.

Дана информация обо всех 4 пакетах. Требуется определить количество потерянных пакетов, максимальное, минимальное и среднее время обмена одного пакета.

Формат ввода

Входной файл input.txt содержит ровно 5 строк. В первой строке находится фраза «ping name», где name – это имя сервера. Имя сервера представляет собой IP адрес. IP-адрес – это 4 однобайтных числа (т.е. числа от 0 до 255), отделенные друг от друга точкой. В каждой из следующих 4 строк содержится либо фраза «Time out», если пакет считается утерянным, либо «Reply from name Time=number», где name – это имя удаленного сервера, а number – время за которое вернулся пакет (number – целое число, 0 ≤ number ≤ 104).

Формат вывода

В выходной файл output.txt выведите статистику по обмену пакетами с удаленным сервером. Следуйте формату, приведенному в примере. Среднее время округлите до целого числа по математическим правилам. Если все 4 пакета утеряны, то выведите только первые две строки.

Примеры

Ввод Вывод
ping 209.85.135.147
Time out
Reply from 209.85.135.147 Time=100
Reply from 209.85.135.147 Time=300
Reply from 209.85.135.147 Time=200		 Ping statistics for 209.85.135.147:
Packets: Sent = 4 Received = 3 Lost = 1 (25% loss)
Approximate round trip times:
Minimum = 100 Maximum = 300 Average = 200
================================================ FILE: pizza/Pizza.java ================================================ package pizza; import java.util.*; import java.io.*; public class Pizza { private static int cutCount; private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); cutCount = sc.nextInt(); } public static void main(String[] argv) throws IOException{ getData(); int d = 1; // Насколько увеличивается количество кусков при следующем разрезе for(int i = 1; i < cutCount; i++){ d = d + i; } int pieceCount = cutCount + d; // Всего количество кусков PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(pieceCount)); pw.close(); } } ================================================ FILE: pizza/README.md ================================================

Пицца (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

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

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

Формат ввода

Входной файл input.txt содержит натуральное число N – число прямых разрезов пиццы (N ≤ 1000).

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
2 4
3 7
================================================ FILE: playing_dice/PlayingDice.java ================================================ package playing_dice; import java.io.*; import java.util.*; public class PlayingDice { public static void main(String[] args) throws IOException { long minSecond; // Минимальное количество баллов второго игрока long maxSecond ; // Максимальное количепство баллов второго игрока String result; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); long pointFirst = Long.valueOf(sc.nextLine()); maxSecond = pointFirst * 6; if(pointFirst >= 6){ minSecond = (pointFirst % 6 == 5) ? pointFirst / 6 + 2 : (pointFirst % 6 == 4) ? pointFirst / 6 + 3 : (pointFirst % 6 == 3) ? pointFirst / 6 + 4 : (pointFirst % 6 == 2) ? pointFirst / 6 + 5 : (pointFirst % 6 == 1) ? pointFirst % 6 * (pointFirst / 6) + 6 : pointFirst / 6; }else{ minSecond = (pointFirst % 5 == 0) ? 2 : (pointFirst % 4 == 0) ? 3 : (pointFirst % 3 == 0) ? 4 : (pointFirst % 2 == 0) ? 5 : 6; } result = minSecond + " " + maxSecond; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: playing_dice/README.md ================================================

Игральные кубики (15%)

Время: 1 сек.
Память: 16 Мб
Сложность: 15%

Юный математик Матвей интересуется теорией вероятностей, и по этой причине у него всегда есть с собой несколько стандартных шестигранных игральных кубиков. Стандартный шестигранный кубик имеет три противолежащих пары граней, которые размечены таким образом, что напротив грани с числом 1 находится грань с числом 6, напротив грани с числом 2 — грань с числом 5 и напротив грани с числом 3 — грань с числом 4.

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

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

Матвей рассказал об этой игре своему другу, юному информатику Фоме, и они начали играть в неё через Интернет. Поскольку Фома не видит результат броска и не знает, сколько кубиков бросает Матвей как первый игрок, то о набранных каждым игроком очках он узнает только от Матвея. Чтобы проверить достоверность этой информации, Фома решил узнать, какое минимальное и максимальное количество очков мог получить он, как второй игрок, если известно, сколько очков набрал Матвей.

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

Формат ввода

Входной файл input.txt содержит одно натуральное число n — количество очков, которые получил первый игрок (n ≤ 1010).

Формат вывода

В выходной файл output.txt выведите два разделенных пробелом целых числа: минимальное и максимальное количество очков соответственно, которые мог набрать второй игрок при таком броске кубиков.

Примеры

Ввод Вывод
2 5 12
36 6 216
================================================ FILE: playing_with_matches/PlayingWithMatches.java ================================================ package playing_with_matches; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class PlayingWithMatches { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int countMatches = sc.nextInt(); String result = countMatches % 3 == 0 ? "2" : "1"; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: playing_with_matches/README.md ================================================

Игра со спичками (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Двое играют в следующую игру. Из кучки спичек за один ход игрок вытягивает либо 1, либо 2, либо 1000 спичек. Выигрывает тот, кто забирает последнюю спичку. Кто выигрывает при правильной игре?

Формат ввода

В единственной строке входного файла input.txt записано одно натуральное число — N (1 ≤ N ≤ 10000) начальное количество спичек в кучке.

Формат вывода

В единственную строку выходного файла output.txt нужно вывести 1, если выигрывает первый игрок (тот, кто ходит первым), или 2, если выигрывает второй игрок.

Примеры

Ввод Вывод
2 1
3 2
================================================ FILE: playing_with_pawn/PlayingWithPawn.java ================================================ package playing_with_pawn; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class PlayingWithPawn { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int n, b; n = Integer.parseInt(sc.nextLine()); int[][] points = new int[n][n]; String[] line = sc.nextLine().split(" "); for(int i = 0; i < n; ++i){ points[i][i] = Integer.parseInt(line[i]); } if(n % 2 == 0) for(int i = 1; i < n; ++i){ if(i % 2 == 0) for(int j = i, t = 0; j < n; ++j, ++t){ points[j][t] = Math.min(points[j - 1][t], points[j][t + 1]); } else{ for(int j = i, t = 0; j < n; ++j, ++t){ points[j][t] = Math.max(points[j - 1][t], points[j][t + 1]); } } } else for(int i = 1; i < n; ++i){ if(i % 2 == 0) for(int j = i, t = 0; j < n; ++j, ++t){ points[j][t] = Math.max(points[j - 1][t], points[j][t + 1]); } else{ for(int j = i, t = 0; j < n; ++j, ++t){ points[j][t] = Math.min(points[j - 1][t], points[j][t + 1]); } } } int i = n - 1; int j = 0; b = 0; while(i != j){ if(b % 2 == 0){ if(points[i - 1][j] > points[i][j + 1]) --i; else ++j; } else{ if(points[i - 1][j] > points[i][j + 1]) ++j; else --i; } ++b; } PrintWriter out = new PrintWriter(System.out); out.println(points[i][j]); out.flush(); } } ================================================ FILE: playing_with_pawn/README.md ================================================

Игра с пешкой (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

В левой нижней клетке шахматной доски размера N×N стоит пешка. Двое игроков по очереди двигают её, причём каждый может подвинуть её на одну клетку вверх или на одну клетку вправо. На диагонали доски написаны числа a1, a2, …, aN. Когда пешка попадает на диагональ, игра кончается и выигрыш первого игрока равен значению числа, написанного в клетке с остановившейся пешкой. Напишите программу определения гарантированного выигрыша первого игрока.

Формат ввода

В первой строке входного файла INPUT.TXT записано число N (1 ≤ N ≤ 100). Во второй строке записаны натуральные числа a1, a2, …, aN (1 ≤ ai ≤ 100).

Формат вывода

В выходной файл OUTPUT.TXT выведите одно число – выигрыш первого игрока.

Примеры

Ввод Вывод
8
3 1 4 1 5 9 2 6		 5
================================================ FILE: playing_with_pebbles/PlayingWithPebbles.java ================================================ package playing_with_pebbles; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Arrays; import java.util.Scanner; public class PlayingWithPebbles { public static void main(String[] args) throws IOException { int n = new Scanner(new FileReader("input.txt")).nextInt(); int[] results = new int[n+1]; for (int i = 3; i <= n; i++) { for (int j = 1; j <= (i-1)/2; j++) { if (results[i - j] == 0) { results[i] = 1; break; } } } PrintWriter out = new PrintWriter(System.out); if (results[n] == 0) { out.println(0); } else { for (int i = 1; i <= n; i++) { if (results[n-i] == 0) { out.println(i); break; } } } out.flush(); } } ================================================ FILE: playing_with_pebbles/README.md ================================================

Игра с камешками (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

В начале игры имеем N камешков. Играют двое. За один ход нужно разделить кучку на две неравные и забрать себе меньшую. Проиграл тот, кто не смог этого сделать.

Сколько камешков взяли бы Вы первым ходом, если рассчитываете на победу и ходите первым?

Формат ввода

В единственной строке входного файла INPUT.TXT записано одно число - число камушков в кучке N (1 ≤ N ≤ 106).

Формат вывода

В выходной файл OUTPUT.TXT выведите одно число - количество взятых Вами первым ходом камушков, либо 0, если выигрышного хода нет.

Примеры

Ввод Вывод
7 3
================================================ FILE: poker/Poker.java ================================================ package poker; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class Poker { public static void main(String[] args) throws IOException { ArrayList num = new ArrayList<>(); String[] data = new Scanner(new FileReader("input.txt")).nextLine().split(" "); for (String number: data) { num.add(Integer.parseInt(number)); } Collections.sort(num); PrintWriter out = new PrintWriter(System.out); if (num.get(0).equals(num.get(4))) { out.println("Impossible"); } else if (num.get(0).equals(num.get(3)) || num.get(1).equals(num.get(4))) { out.println("Four of a Kind"); } else if (num.get(0).equals(num.get(1)) && num.get(2).equals(num.get(4)) || num.get(0).equals(num.get(2)) && num.get(3).equals(num.get(4))) { out.println("Full House"); } else if (num.get(0)+1 == num.get(1) && num.get(1)+1 == num.get(2) && num.get(2)+1 == num.get(3) && num.get(3)+1 == num.get(4)) { out.println("Straight"); } else if (num.get(0).equals(num.get(2)) || num.get(1).equals(num.get(3)) || num.get(2).equals(num.get(4))) { out.println("Three of a Kind"); } else if (num.get(0).equals(num.get(1)) && num.get(2).equals(num.get(3)) || num.get(0).equals(num.get(1)) && num.get(3).equals(num.get(4)) || num.get(1).equals(num.get(2)) && num.get(3).equals(num.get(4))) { out.println("Two Pairs"); } else if (num.get(0).equals(num.get(1)) || num.get(1).equals(num.get(2)) || num.get(2).equals(num.get(3)) || num.get(3).equals(num.get(4))) { out.println("One Pair"); } else { out.println("Nothing"); } out.flush(); } } ================================================ FILE: poker/README.md ================================================

Покер (33%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 33%

Имеется 5 целых чисел. Среди них:

  • если одинаковы 5, то вывести "Impossible", иначе
  • если одинаковы 4, то вывести "Four of a Kind", иначе
  • если одинаковы 3 и 2, то вывести "Full House", иначе
  • если есть 5 последовательных, то вывести "Straight", иначе
  • если одинаковы 3, то вывести "Three of a Kind", иначе
  • если одинаковы 2 и 2, то вывести "Two Pairs", иначе
  • если одинаковы 2, то вывести "One Pair", иначе
  • вывести "Nothing".

Формат ввода

Входной файл INPUT.TXT содержит 5 целых чисел от 1 до 13, разделенных пробелом.

Формат вывода

В выходной файл OUTPUT.TXT следует вывести результат анализа.

Примеры

Ввод Вывод
1 3 9 3 2 One Pair
1 5 5 4 4 Two Pairs
1 5 2 4 3 Straight
10 11 12 13 1 Nothing
================================================ FILE: pow_string/PowString.java ================================================ package pow_string; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class PowString { /** * @param out Стандартный вывод * @param pow Степень * @param stringChar Символы строки * @param resultMaxLength Максимальная длина строки * */ private static void plusPow(PrintWriter out, int pow, char[] stringChar, int resultMaxLength) { int charCount = 0; boolean finish = false; for (int i = 0; i < pow; i++) { for (char c : stringChar) { if (charCount < resultMaxLength) { out.print(c); } else { finish = true; break; } charCount++; } if (finish) { break; } } } /** * @param out Стандартный вывод * @param stringChar Строка посимвольно * @param stringInput Исходная строка * @param pow Степень * */ private static void minusPow(PrintWriter out, char[] stringChar, String stringInput, int pow) { StringBuilder section = new StringBuilder(); for (char c : stringChar) { if (section.length() == 0 || c != section.charAt(0)) { section.append(c); } else { if (stringInput.replaceAll(String.valueOf(section), "").length() == 0) { break; } else { section.append(c); } } } int sectionCount = (stringInput.length() - stringInput.replace(section, "").length()) / section.length(); if (stringInput.length() % pow == 0 && sectionCount >= Math.abs(pow) && sectionCount % Math.abs(pow) == 0) { for (int i = 0; i < stringChar.length/Math.abs(pow); i++) { out.print(stringChar[i]); } } else { out.print("NO SOLUTION"); } } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String stringInput = sc.nextLine(); char[] stringChar = stringInput.toCharArray(); int pow = sc.nextInt(); int resultMaxLength = 1023; PrintWriter out = new PrintWriter(System.out); if (pow > 0) { plusPow(out, pow, stringChar, resultMaxLength); } else { minusPow(out, stringChar, stringInput, pow); } out.flush(); } } ================================================ FILE: pow_string/README.md ================================================

Степень строки (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Пусть задана строка s = s1s2...sn. Назовем ее k-ой (k > 0) степенью sk строку sk = s1s2 . . .sns1s2 . . .sn......s1s2...sn (k раз). Например, третьей степенью строки abc является строка abcabcabc.

Корнем k степени из строки s называется такая строка t (если она существует), что tk = s.

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

Формат ввода

Первая строка входного файла input.txt содержит строку s, она содержит только маленькие буквы английского алфавита и имеет ненулевую длину, не превосходящую 1000.

Вторая строка входного файла содержит целое число k ≠ 0, |k| < 100001. Если k > 0, то необходимо найти k-ую степень строки s, если k < 0, то необходимо найти корень степени |k| из s.

Формат вывода

В выходной файл output.txt выведите строку, являющуюся ответом на задачу. Если длина ответа превосходит 1023 символа, выведите только первые 1023 символа. Если искомой строки не существует — выведите NO SOLUTION.

Примеры

Ввод Вывод
abc
3		 abcabcabc
abcdabcd
-2		 abcd
abcd
-4		 NO SOLUTION
================================================ FILE: power_numbers/PowerNumbers.java ================================================ package power_numbers; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class PowerNumbers { /** * @param number Проверяемое число * @return true - если число степенное, false - иначе * */ private static boolean powerNumbers(long number) { long numberTemp = number; for (int divider = 2; divider <= Math.sqrt(numberTemp); divider++) { while (numberTemp > 1) { if (numberTemp % divider == 0) { numberTemp /= divider; } else { numberTemp = number; break; } } if (numberTemp == 1) { return true; } } return false; } public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); Scanner sc = new Scanner(new FileReader("input.txt")); sc.nextLine(); // считываем количество чисел String[] numbers = sc.nextLine().split(" "); for (String number : numbers) { if (powerNumbers(Long.parseLong(number))) { out.println("YES"); } else { out.println("NO"); } } out.flush(); } } ================================================ FILE: power_numbers/README.md ================================================

Степенные числа (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

Число n называется степенным, если его можно получить из некоторого числа умножением на себя хотя бы один раз. Например, 4 степенное число, так как 4=2•2, 27 тоже степенное число, так как 27=3•3•3, а 28 не является степенным числом. Определить являются ли заданные числа степенными.

Формат ввода

Первая строка входного файла input.txt содержит натуральное число n - количество исследуемых чисел (1 ≤ n ≤ 10). Во второй строке через пробел записаны n чисел - исследуемые числа. Каждое из них больше 1 и меньше 109.

Формат вывода

В выходной файл output.txt выведите n строк. В i-й строке должно быть записано «YES», если i-е число является степенным и «NO» в противном случае.

Примеры

Ввод Вывод
2
27 28		 YES
NO
================================================ FILE: premium/Premium.java ================================================ package premium; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.math.BigInteger; import java.util.Scanner; import java.util.StringTokenizer; public class Premium { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int index = 0, n = 0; String k = ""; StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ if(index == 0){ n = Integer.valueOf(st.nextToken()); }else { k = st.nextToken(); } index++; } int numberSystem = n % 10 + 2; BigInteger result = new BigInteger(k, numberSystem); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: premium/README.md ================================================

Премия (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Несмотря на кризис, компания Soft-Soft работает успешно. Директор компании принял решение выплатить сотрудникам премии. На следующий день был обнародован список счастливчиков. Чтобы не разглашать размер выплат, в списке напротив фамилий красовались странные цифры и даже буквы. Сотрудники быстро догадались, что размер премий записан в различных системах счисления. Но где и какая система счисления используется, сообразила только секретарша Танечка, которая вспомнила, что директор просил ее принести информацию о возрасте сотрудников. Она поняла, что директор отбрасывал десятки из числа, указывающего возраст, а к оставшимся единицам добавлял число 2. Полученное значение служило основанием для представления начисленной премии.

Помогите любопытной Танечке узнать размер премий в десятичной системе счисления. Известно, что размер премий не превышает 100000 рублей в десятичной системе счисления.

Формат ввода

В первой строке входного файла input.txt записаны два целых числа N и K – возраст и размер премии, разделенные пробелом. Возраст не превышает 100, размер премии указан в некоторой системе счисления (запись числа не содержит незначащих нулей, использует арабские цифры и заглавные английские буквы).

Формат вывода

В выходной файл output.txt выведите одно число – размер премии в десятичной системе счисления.

Примеры

Ввод Вывод
28 2800 2800
30 101 5
================================================ FILE: prime_factorization/PrimeFactorization.java ================================================ package prime_factorization; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class PrimeFactorization { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); long number = sc.nextLong(); StringBuilder result = new StringBuilder(); int n = 2; while (n <= Math.sqrt(number)){ if(number % n == 0){ result.append(n); number /= n; if (number > 1) result.append("*"); }else n++; } if(number > 1)result.append(number); System.out.println(result); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: prime_factorization/README.md ================================================

Разложение на простые множители (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Требуется вывести представление целого числа N в виде произведения простых чисел.

Формат ввода

Входной файл input.txt содержит натуральное число N (2 ≤ N ≤ 231-1).

Формат вывода

В выходной файл output.txt выведите список простых множителей числа N в порядке неубывания, разделенных знаком «*».

Примеры

Ввод Вывод
5 5
30 2*3*5
================================================ FILE: prince_and_dragon/PrinceAndDragon.java ================================================ package prince_and_dragon; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class PrinceAndDragon { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ data.add(Long.valueOf(st.nextToken())); } long bladeCutCount = data.get(0); //n long dragonHeadCount = data.get(1); //m long regenerationHeadCount = data.get(2); //k int duelCount = 0; if(bladeCutCount >= dragonHeadCount){ duelCount = 1; }else if(bladeCutCount + regenerationHeadCount < dragonHeadCount){ duelCount = Math.toIntExact((dragonHeadCount - bladeCutCount - 1) / (bladeCutCount - regenerationHeadCount) + 2); } String result = (duelCount == 0) ? "NO" : String.valueOf(duelCount); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: prince_and_dragon/README.md ================================================

Принц и дракон (22%)

Время: 1 сек.
Память: 16 Мб
Сложность: 21%

Волшебник Мерлин продает волшебные мечи принцам, желающим убить дракона. Основная характеристика меча – число драконьих голов, которые он срубает за удар. Основная характеристика дракона – число голов, которые он может отрастить за сеанс регенерации. Бои принцев с драконами всегда протекают одинаково – принц атакует, и прячется за щитом; дракон атакует огненным дыханием и регенерирует; так продолжается до тех пор, пока после очередного удара у дракона не кончатся головы. Ясно, впрочем, что не каждым мечом можно победить каждого дракона. Заказ, поступающий Мерлину, всегда содержит число голов дракона и скорость его регенерации. Подсчитайте по известной атакующей силе меча, сможет ли принц убить такого дракона таким мечом и, если да, то сколько ударов потребуется.

Формат ввода

Единственная строка входного файла input.txt содержит число N – число голов, которые меч срубает одним ударом. Далее идет число M – число голов дракона. За ним идет K – число голов, которые дракон регенерирует за раз (1 ≤ N, M, K ≤ 105). Все числа разделены пробелом.

Формат вывода

В выходной файл output.txt выведите число ударов, которые необходимо нанести принцу, чтобы убить дракона, если это возможно. Если таким мечом убить дракона нельзя, то следует вывести «NO».

Примеры

Ввод Вывод
3 6 2 4
4 4 5 1
5 10 6 NO
================================================ FILE: professor/Professor.java ================================================ package professor; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class Professor { private static int getWordsCount(String lecture, int m){ Map wordSpace = new HashMap<>(); char[] words = lecture.toCharArray(); StringBuffer temp = new StringBuffer(); for(int i = 0; i < words.length; i++){ if(i < m){ temp.append(String.valueOf(words[i])); }else { if(temp.length() == m){ wordSpace.put(String.valueOf(temp), 0); temp.delete(0, 1); temp.append(String.valueOf(words[i])); } } if(temp.length() == m){ wordSpace.put(String.valueOf(temp), 0); } } return wordSpace.size(); } public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String line = sc.nextLine(); StringTokenizer st = new StringTokenizer(line, " "); while (st.hasMoreTokens()){ data.add(st.nextToken()); } } int m = Integer.valueOf(data.get(1)); String lecture = data.get(2); int wordCount = getWordsCount(lecture, m); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(wordCount)); out.close(); } } ================================================ FILE: professor/README.md ================================================

Профессор (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

В одном очень известном университете один очень известный профессор очень быстро произносил свои лекции, так, что ничего невозможно было разобрать. Но недавно студент Вилли решил провести исследование по изучению словарного запаса профессора. С этой целью он даже посетил одну лекцию и записал всё сказанное на ней на диктофон. Затем, прокручивая дома запись с десятикратным замедлением, Вилли смог записать всё, что сказал профессор.

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

Формат ввода

Первая строка входного файла input.txt содержит два числа n и m (1 ≤ m ≤ n ≤ 100) – длина лекции и длина слова. Вторая строка содержит n английских символов - текст лекции профессора.

Формат вывода

В выходной файл output.txt выведите одно число – количество слов длины m, которые профессор мог использовать в своей лекции.

Примеры

Ввод Вывод
3 1
abc		 3
10 3
bbaabbbabb		 6
================================================ FILE: program_template/ProgramTemplate.java ================================================ package program_template; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class ProgramTemplate { private static int wordEnergy(int position) { if (position < 10) { return position; } return position/10 + position%10; } public static void main(String[] args) throws IOException { int energy = 0; String words = "abcdefghijklmnopqrstuvwxyz"; Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()) { char[] symbols = sc.nextLine().toCharArray(); for (char character : symbols) { String symbol = String.valueOf(character); if (words.contains(symbol.toLowerCase())) { energy += wordEnergy(words.indexOf(symbol.toLowerCase())+1); if (!symbol.toLowerCase().equals(symbol)) { energy += 10; } } else if (symbol.equals(" ")) { energy += 4; } else if (symbol.equals(".")) { energy += 5; } else if (symbol.equals(";")) { energy += 7; } else if (symbol.equals(",")) { energy += 2; } else if ("=+-'\"".contains(symbol)) { energy += 3; } else if ("()".contains(symbol)) { energy += 1; } else if ("{}[]<>".contains(symbol)) { energy += 8; } else if (symbol.matches("\\d")) { energy += 13 - Integer.parseInt(symbol); } } } PrintWriter out = new PrintWriter(System.out); out.println(energy); out.flush(); } } ================================================ FILE: program_template/README.md ================================================

Шаблон программы (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Многие команды, участвующие в командных соревнованиях по программированию, используют так называемый «шаблон программы». Он набирается в самом начале соревнования и содержит общее для всех решений - например, открытие и закрытие входных и выходных файлов.

Трехкратный чемпион мира по версии AMC команда Dream Team – не исключение. Во многом их успехи связаны с тем, что они очень тщательно готовятся к соревнованиям, продумывая даже очень мелкие детали. Например, перед последним финалом они во время пробного тура рассчитали, сколько джоулей энергии потратится на набор шаблона.

Организаторы финала использовали весьма странные клавиатуры — жесткость различных клавиш была различной. Таким образом, на нажатие разных клавиш требовалось различное количество энергии.

Эксперименты, проведенные командой Dream Team во время пробного тура, показали следующее. На набор строчной буквы английского алфавита требуется количество энергии, равное сумме цифр ее порядкового номера в алфавите (буквы нумеруются с единицы). На нажатие клавиши «Shift» требуется 10 джоулей энергии (таким образом набор заглавной буквы английского алфавита требует на 10 джоулей больше, чем набор соответствующей ей строчной буквы), нажатие клавиши «Пробел» требует 4 джоуля энергии. Набор цифры x требует (13 – x) джоулей энергии, набор точки – 5 джоулей, точки с запятой – 7 джоулей, запятой – 2 джоуля. Знак равенства, плюс, минус, одинарная и двойная кавычка требуют по 3 джоуля энергии. Закрывающая и открывающая круглые скобки требуют по 1 джоулю, а фигурные, квадратные и угловые (т.е. символы < и >) – по 8. При этом для всех упомянутых знаков препинания на клавиатуре, используемой на финале, существуют отдельные клавиши, и другой возможности набрать соответствующий символ нет. Нажатие клавиши «Enter» (перевод строки) оказалось настолько легким, что энергозатраты на него можно считать нулевыми.

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

Формат ввода

Входной файл input.txt содержит шаблон программы, энергетические затраты на набор которого необходимо вычислить. Он содержит только цифры, пробелы, строчные и заглавные буквы английского алфавита, точки, запятые, знаки равенства, плюсы, точки с запятыми, двойные кавычки ("), одинарные кавычки ('), закрывающие и открывающие круглые, фигурные и квадратные скобки. Его размер не превышает 20000 байт.

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
abCD '+=1;2,3."()[]{} 127
program solution;
uses
 sysutils, math;
begin
 assign(input, '.in');
 assign(output, '.out');
end.		 489
================================================ FILE: programmer_day/ProgrammerDay.java ================================================ package programmer_day; import java.io.*; import java.util.*; public class ProgrammerDay { public static void main(String[] args) throws IOException { ArrayList numbers = new ArrayList<>(Arrays.asList(31,28,31,30,31,30,31,31,30,31,30,31)); // Количество дней в каждом месяце String result; // Результат String dayS, monS, yearS; // Переменные для сборки итоговой строки int day = 255, month, year; // ПЕременные для расчетов FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); year = Integer.valueOf(sc.nextLine()); month = day / 31 + 1; if(year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)){ // Вычисление високосного года, замена количества дней в коллекции for(Integer i : numbers){ if(i == 28){ numbers.set(1, 29); } } } for (Integer number : numbers) { // Вычисляем день в месяце if (day - number > 0) { day = day - number; } } dayS = (day + 1) < 10 ? "0" + (day+1) : String.valueOf(day+1); // Вычисление дня monS = "0" + month; // Вычисление месяца yearS = (year < 10) ? "000" + year : // Вычисление года (year < 100) ? "00" + year: (year < 1000) ? "0" + year : String.valueOf(year); result = dayS + "/" + monS + "/" + yearS; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: programmer_day/README.md ================================================

День программиста (13%)

Время: 1 сек.
Память: 16 Мб
Сложность: 13%

День программиста отмечается в 255-й день года (при этом 1 января считается нулевым днем). Требуется написать программу, которая определит дату (месяц и число григорианского календаря), на которую приходится День программиста в заданном году.

В григорианском календаре високосным является:

  • год, номер которого делится нацело на 400
  • год, номер которого делится на 4, но не делится на 100

Формат ввода

В единственной строке входного файла input.txt записано целое число от 1 до 9999 включительно, которое обозначает номер года нашей эры.

Формат вывода

В единственную строку выходного файла OUTPUT.TXT нужно вывести дату Дня программиста в формате DD/MM/YYYY, где DD — число, MM — номер месяца (01 — январь, 02 — февраль, ..., 12 — декабрь), YYYY — год в десятичной записи.

Примеры

Ввод Вывод
2000 12/09/2000
2009 13/09/2009
================================================ FILE: puzzle_queens/PuzzleQueens.java ================================================ package puzzle_queens; import java.io.*; import java.util.*; public class PuzzleQueens { public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); int countQueen = Integer.valueOf(sc.nextLine()); int result = 0; for(int i = countQueen - 2; i > 0 ; i--){ // Перебираем варианты для одной стороны поля result += i; } result = result * 2; // Добавляем вторую сторону FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: puzzle_queens/README.md ================================================

Головоломка про ферзей (15%)

Время: 1 сек.
Память: 16 Мб
Сложность: 15%

Вероятно, что многие из вас играли в шахматы. Поэтому вы знаете, что ферзь может двигаться по горизонталям, вертикалям и диагоналям.

Вася недавно начал заниматься шахматами и где-то прочел головоломку, в которой нужно было расставить максимальное количество ферзей на доске 8х8 так, чтобы хотя бы одно поле оказалось небитым. Эта задача легко решается для доски 3х3, т.к. понятно, что более двух ферзей расставить таким образом на ней невозможно.

Помогите Васе решить эту задачу для доски N×N.

Формат ввода

В единственной строке входного файла input.txt записано натуральное число N – размеры шахматной доски N×N (1 ≤ N ≤ 100).

Формат вывода

В единственную строку выходного файла output.txt нужно вывести максимальное количество ферзей, которых можно расставить на шахматной доске N×N так, чтобы одна клетка оставалась небитой.

Примеры

Ввод Вывод
3 2
================================================ FILE: quadratic_equation/QuadraticEquation.java ================================================ package quadratic_equation; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; import java.util.StringTokenizer; public class QuadraticEquation { public static void main(String[] args) throws IOException { double a = 0, b = 0, c = 0; Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ a = Double.valueOf(st.nextToken()); b = Double.valueOf(st.nextToken()); c = Double.valueOf(st.nextToken()); } StringBuilder result = new StringBuilder(); double d = Math.pow(b, 2) - 4*a*c; if(a == 0 && b == 0 && c == 0){ result.append(-1); }else if(a == 0 && b == 0 || d < 0){ result.append(0); }else if(a == 0){ double x = (double)-c / b; result.append(1).append("\n"); result.append(x); }else if(d == 0){ double x = (double) -b/ (2*a); result.append(1).append("\n"); result.append(x); }else { double x1 = (-b - Math.sqrt(d))/ (2*a); double x2 = (-b + Math.sqrt(d))/ (2*a); result.append(2).append("\n"); result.append(x1).append("\n"); result.append(x2); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: quadratic_equation/README.md ================================================

Квадратное уравнение (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

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

Но программы, в которых решение уравнений является стандартной функцией, установлены не везде. Напишите программу, которая сможет решить уравнение ax2 + bx + c = 0 при заданных коэффициентах a, b и c.

Формат ввода

Единственная строка входного файла input.txt содержит три целых числа a, b и c, каждое из которых не превосходит по модулю 30000. Числа разделяются пробелами.

Формат вывода

На первой строке выходного файла output.txt выведите число различных действительных корней заданного уравнения. Затем выведите сами корни по одному на строке с ошибкой, не превосходящей 10-4. Если для заданных коэффициентов корней бесконечно много, на единственной строке выходного файла выведите -1.

Примеры

Ввод Вывод
1 -3 2 2
1.000000
2.000000
0 -1 6 1
6.000000
================================================ FILE: queue/Queue.java ================================================ package queue; import java.util.*; import java.io.*; public class Queue { private static int peopleInQueue; private static String result; private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); peopleInQueue = sc.nextInt(); } private static void timeInQueue(){ // Расчет времени в очереди int queue; int hour, minute, allminute; boolean sucsess = true; if(peopleInQueue % 2 == 0){ // 1 очередь queue = peopleInQueue / 2 - 1; allminute = queue * 10; hour = allminute / 60; minute = allminute - hour * 60 + 5; if(minute >= 60){ hour = hour + 1; minute = minute + 5 - 60; } if(hour > 11 || (hour == 11 && minute > 55)){ sucsess = false; } }else{ // 2 очередь queue = peopleInQueue / 2; allminute = queue * 10; hour = allminute / 60; minute = allminute - hour * 60; if(minute >= 60){ hour = hour + 1; minute = minute - 60; } if((hour == 12 && minute !=0) || hour > 12){ sucsess = false; } } result = (!sucsess) ? "NO" : hour + " " + minute; // Ответ на задачу } public static void main(String[] argv) throws IOException{ getData(); timeInQueue(); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: queue/README.md ================================================

Очередь (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

Студент Василий живет в общежитии. Отделение банка, в котором он производит оплату за проживание, имеет всего две кассы, поэтому почти всегда длинная очередь к ним. Первая касса открывается в 8.00, вторая – в 8.05. Последний клиент будет принят в 20.00. Очередь единая, и очередной клиент обслуживается, как только освобождается одна из касс. На обслуживание одного клиента уходит ровно 10 минут. Василий приходит ровно в 8.00 и видит, сколько человек стоит перед ним. Требуется определить, сколько времени ему придется простоять в очереди, и вообще обслужат ли его сегодня.

Формат ввода

Входной файл input.txt содержит единственное натурально число K – номер Василия в очереди (K < 250).

Формат вывода

В выходной файл output.txt выводится строка «NO», если Василий сегодня заплатить уже не успеет, и время его ожидания (в формате «X Y», где X – количество целых часов, которые простоит в очереди Василий, и Y – количество минут), если все же успеет заплатить.

Примеры

Ввод Вывод
1 0 0
20 1 35
235 NO
================================================ FILE: rally/README.md ================================================

Соревнование картингистов (18%)

Время: 1 сек.
Память: 16 Мб
Сложность: 18%

После очередного этапа чемпионата мира по кольцевым автогонкам на автомобилях с открытыми колесами Формула-А гонщики собрались вместе в кафе, чтобы обсудить полученные результаты. Они вспомнили, что в молодости соревновались не на больших болидах, а на картах – спортивных автомобилях меньших размеров.

Друзья решили выяснить победителя в одной из гонок на картах. Победителем гонки являлся тот гонщик, у которого суммарное время прохождения всех кругов трассы было минимальным.

Поскольку окончательные результаты не сохранились, то каждый из n участников той гонки вспомнил и выписал результаты прохождения каждого из m кругов трассы. К сожалению, по этой информации гонщикам было сложно вычислить победителя той гонки. В связи с этим они попросили сделать это вас.

Требуется написать программу, которая вычислит победителя гонки на картах, о которой говорили гонщики.

Формат ввода

Первая строка входного файла input.txt содержит два целых числа n и m (1 ≤ n, m ≤ 100). Последующие 2∙n строк описывают прохождение трассы каждым из участников. Описание прохождения трассы участником состоит из двух строк. Первая строка содержит имя участника с использованием только английских букв (строчных и заглавных). Имена всех участников различны, строчные и заглавные буквы в именах различаются.

Вторая строка содержит m положительных целых чисел, где каждое число – это время прохождения данным участником каждого из m кругов трассы (каждое из этих чисел не превосходит 1000). Длина каждой строки с именем участника не превышает 255 символов.

Формат вывода

В выходной файл output.txt необходимо вывести имя победителя гонки на картах. Если победителей несколько, требуется вывести имя любого из них.

Примеры

Ввод Вывод
5 3
Sumaher
2 1 1
Barikelo
2 1 2
Olonso
1 2 1
Vasya
1 1 1
Fedya
1 1 1		 Vasya
================================================ FILE: rally/Rrally.java ================================================ package rally; import java.util.*; import java.io.*; public class Rrally { private static ArrayList data = new ArrayList<>(); // Коллекция с исходными данными private static ArrayList allPoint = new ArrayList<>(); // Коллекция с суммой очков каждого участника private static String result; // Ответ на задачу private static void getData() throws IOException{ // Получить данные FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(st.nextToken()); } } } private static void allPoints(){ // Сложить все очки каждого участника int j = 0; for(int i = 0; i < data.size(); i++){ if(i != 0 && i != 1){ if(data.get(i).matches("^-?\\d+$")){ j += Integer.valueOf(data.get(i)); }else{ allPoint.add(String.valueOf(j)); j = 0; allPoint.add(data.get(i)); } } } allPoint.add(String.valueOf(j)); } private static void winner(){ // Вычисление победителя с наименьшим кол-вом очков int minTime = 0; int minTimeIndex = 0; for(int i = 0; i < allPoint.size(); i++){ if(i != 0){ if(i % 2 == 0 && i + 2 < allPoint.size()){ if(i == 2){ minTime = Integer.valueOf(allPoint.get(i)); minTimeIndex = i; } if(Integer.valueOf(allPoint.get(i + 2)) < minTime){ minTime = Integer.valueOf(allPoint.get(i + 2)); minTimeIndex = i; } } } } result = allPoint.get(minTimeIndex+1); } public static void main(String[] argv) throws IOException{ getData(); allPoints(); winner(); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: rect/README.md ================================================

Прямоугольники (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

Найдите количество невырожденных прямоугольников со сторонами, параллельными осям координат, вершины которых лежат в точках с целыми координатами внутри или на границе прямоугольника, противоположные углы которого находятся в точках (0, 0) и (W, Н).

Формат ввода

Входной файл INPUT.TXT содержит два натуральных числа W и Н, не превосходящих 1000.

Формат вывода

В выходной файл OUTPUT.TXT выведите ответ на задачу.

Примеры

Ввод Вывод
1 1 1
2 1 3
2 2 9
================================================ FILE: rect/Rect.java ================================================ package rect; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class Rect { public static void main(String[] args) throws IOException { String[] sides = new Scanner(new FileReader("input.txt")).nextLine().split(" "); int w = Integer.parseInt(sides[0]); int h = Integer.parseInt(sides[1]); long res = 0; for (int i = 1; i <= w; i++) { for (int j = 1; j <= h; j++) { res += i*j; } } PrintWriter out = new PrintWriter(System.out); out.print(res); out.flush(); } } ================================================ FILE: rectangle_two/README.md ================================================

Прямоугольник - 2 (27%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Заданы координаты трех вершин прямоугольника. Необходимо определить координаты четвертой вершины.

Формат ввода

Во входном файле input.txt записаны через пробел координаты трех вершин прямоугольника в произвольном порядке в формате x1 y1 x2 y2 x3 y3. Все числа целые, не превосходящие 1000 по абсолютной величине.

Формат вывода

В выходной файл output.txt нужно вывести через пробел координаты четвертой вершины прямоугольника.

Примеры

Ввод Вывод
0 3 0 0 5 0 5 3
1 4 8 3 7 6 2 1
================================================ FILE: rectangle_two/RectangleTwo.java ================================================ package rectangle_two; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class RectangleTwo { public static void main(String[] args) throws IOException { Scanner scan = new Scanner(new FileReader("input.txt")); ArrayList x = new ArrayList<>(); ArrayList y = new ArrayList<>(); int sideOne, sideTwo, sideThree; StringTokenizer elements = new StringTokenizer(scan.nextLine(), " "); int count = elements.countTokens(); for (int i = 0; i < count; i++){ int elem = Integer.valueOf(elements.nextToken()); if(i % 2 == 0){ x.add(elem); }else { y.add(elem); } } sideOne = (int) Math.sqrt(Math.pow(x.get(0) - x.get(1), 2) + Math.pow(y.get(0) - y.get(1), 2)); sideTwo = (int) Math.sqrt(Math.pow(x.get(1) - x.get(2), 2) + Math.pow(y.get(1) - y.get(2), 2)); sideThree = (int) Math.sqrt(Math.pow(x.get(0) - x.get(2), 2) + Math.pow(y.get(0) - y.get(2), 2)); int hypotenuseSide = (sideOne > sideTwo && sideOne > sideThree) ? 1 : (sideTwo > sideOne && sideTwo > sideThree) ? 2 : 3; int x4 = 0, y4 = 0, xOneDiagonalSum, yOneDiagonalSum; switch (hypotenuseSide){ case (1): xOneDiagonalSum = x.get(0) + x.get(1); yOneDiagonalSum = y.get(0) + y.get(1); x4 = xOneDiagonalSum - x.get(2); y4 = yOneDiagonalSum - y.get(2); break; case (2): xOneDiagonalSum = x.get(1) + x.get(2); yOneDiagonalSum = y.get(1) + y.get(2); x4 = xOneDiagonalSum - x.get(0); y4 = yOneDiagonalSum - y.get(0); break; case (3): xOneDiagonalSum = x.get(0) + x.get(2); yOneDiagonalSum = y.get(0) + y.get(2); x4 = xOneDiagonalSum - x.get(1); y4 = yOneDiagonalSum - y.get(1); break; } String result = x4 + " " + y4; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: repair/README.md ================================================

Ремонт (11%)

Время: 1 сек.
Память: 16 Мб
Сложность: 11%

Ваш любимый дядя – директор фирмы, которая делает евроремонты в офисах. В связи с финансово-экономическим кризисом, дядюшка решил оптимизировать свое предприятие.

Давно ходят слухи, что бригадир в дядюшкиной фирме покупает лишнее количество стройматериалов, а остатки использует для отделки своей новой дачи. Ваш дядя заинтересовался, сколько в действительности банок краски необходимо для покраски стен в офисе длиной L метров, шириной – W и высотой – H, если одной банки хватает на 16м2, а размерами дверей и окон можно пренебречь? Заказов много, поэтому дядя попросил написать программу, которая будет все это считать.

Формат ввода

Входной файл input.txt содержит три натуральных числа L, W, H – длину, ширину и высоту офиса в метрах соответственно, каждое из которых не превышает 1000.

Формат вывода

В выходной файл output.txt выведите одно целое число – минимальное количество банок краски, необходимых для покраски стен в офисе.

Примеры

Ввод Вывод
8 8 2 4
1 1 3 1
================================================ FILE: repair/Repair.java ================================================ package repair; import java.io.*; import java.util.*; public class Repair { public static void main(String[] args) throws IOException { ArrayList length = new ArrayList<>(); int result; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ length.add(Integer.valueOf(st.nextToken())); // Записать все элементы в коллекцию } result = (2 * (length.get(0) * length.get(2) + length.get(1) * length.get(2))) / 16; if((2 * (length.get(0) * length.get(2) + length.get(1) * length.get(2))) % 16 != 0){ result = result + 1; } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: reverse_permutation/README.md ================================================

Обратная перестановка (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

По заданной перестановке требуется определить обратную.

Перестановкой из N элементов называется упорядоченный набор из N различных чисел от 1 до N. Количество различных перестановок порядка N равно PN = N!

Пусть у нас есть упорядоченное множество из N элементов. Перестановка задает преобразование этого множества. А именно, она говорит, что на i место нужно поставить ai элемент множества, где ai - i-тый элемент перестановки.

Обратной перестановкой к перестановке π называется такая перестановка π-1, что ππ-1 = π-1π = ε, где ε – тождественная перестановка. То есть если применить сначала перестановку π, а потом обратную к ней π-1, то в итоге получится такой результат, как если бы мы эти перестановки не применяли вообще. Такой же результат получится, если сначала применить обратную перестановку π-1, а потом прямую π.

Формат ввода

В первой строке входного файла input.txt записано число 0 < N ≤ 20000 - порядок перестановки. Во второй строке записана сама перестановка.

Формат вывода

В выходной файл output.txt выведите обратную перестановку.

Примеры

Ввод Вывод
3
2 3 1		 3 1 2
================================================ FILE: reverse_permutation/ReversePermutation.java ================================================ package reverse_permutation; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class ReversePermutation { public static void main(String[] args) throws IOException { Map list = new TreeMap<>(); Scanner sc = new Scanner(new FileReader("input.txt")); int index = 0; int step = 1; while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ int number = Integer.valueOf(st.nextToken()); if(index != 0){ list.put(number, step); step++; } } index++; } StringBuilder result = new StringBuilder(); for (int i : list.keySet()){ result.append(list.get(i)).append(" "); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result).trim()); out.close(); } } ================================================ FILE: riddle/README.md ================================================

Загадка (18%)

Время: 1 сек.
Память: 16 Мб
Сложность: 18%

Петя и Катя – брат и сестра. Петя – студент, а Катя – школьница. Петя помогает Кате по математике. Он задумывает два натуральных числа X и Y (X,Y≤1000), а Катя должна их отгадать. Для этого Петя делает две подсказки. Он называет сумму этих чисел S и их произведение P. Помогите Кате отгадать задуманные Петей числа.

Формат ввода

Входной файл input.txt содержит два натуральных числа S и P, разделенных пробелом.

Формат вывода

В выходной файл output.txt выведите два числа Х и Y, загаданные Петей. Числа следует вывести в порядке неубывания своих значений, разделенные пробелом.

Примеры

Ввод Вывод
4 4 2 2
5 6 2 3
================================================ FILE: riddle/Riddle.java ================================================ package riddle; import java.util.*; import java.io.*; public class Riddle { private static ArrayList number = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ number.add(Integer.valueOf(st.nextToken())); } } public static void main(String[] argv) throws IOException{ getData(); int x, y; x = (int) ((number.get(0) - (Math.sqrt(Math.pow(number.get(0), 2) - 4 * number.get(1)))) / 2); // 1 число через систему уравнений y = (int) ((number.get(0) + (Math.sqrt(Math.pow(number.get(0), 2) - 4 * number.get(1)))) / 2); //2 число через систему уравнений String result = x + " " + y; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: ring/README.md ================================================

Кольцо (16%)

Время: 1 сек.
Память: 16 Мб
Сложность: 16%

Заданы площадь кольца и радиус внешней окружности. Требуется определить радиус внутренней окружности.

Формат ввода

Входной файл input.txt содержит два положительных вещественных числа: S и R1 – площадь кольца и радиус внешней окружности соответственно. Радиус внешней окружности не превышает 100.

Формат вывода

В выходной файл output.txt выведите радиус внутренней окружности R2 с точностью не худшей, чем 10-3.

Примеры

Ввод Вывод
50.265482 5.0 3.000
================================================ FILE: ring/Ring.java ================================================ package ring; import java.util.*; import java.io.*; public class Ring { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Double.valueOf(st.nextToken())); } } public static void main(String[] argv) throws IOException{ getData(); double r = Math.sqrt((Math.PI * Math.pow(data.get(1), 2) - data.get(0)) / Math.PI); // Используем формулу нахождения площади кольца String rformat = String.format("%.3f", r).replaceAll(",", "."); // Приводим число к нужному формату PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(rformat)); pw.close(); } } ================================================ FILE: road/README.md ================================================

Дороги (18%)

Время: 1 сек.
Память: 16 Мб
Сложность: 18%

В галактике «Milky Way» на планете «Snowflake» есть N городов, некоторые из которых соединены дорогами. Император галактики «Milky Way» решил провести инвентаризацию дорог на планете «Snowflake». Но, как оказалось, он не силен в математике, поэтому он просит вас сосчитать количество дорог. Требуется написать программу, помогающую императору сосчитать количество дорог на планете «Snowflake».

Формат ввода

В первой строке входного файла input.txt записано число N (0 ≤ N ≤ 100). В следующих N строках записано по N чисел, каждое из которых является единичкой или ноликом. Причем, если в позиции (i, j) квадратной матрицы стоит единичка, то i-ый и j-ый города соединены дорогами, а если нолик, то не соединены.

Формат вывода

В выходной файл output.txt необходимо вывести число, определяющее количество дорог на планете «Snowflake».

Примеры

Ввод Вывод
5
0 1 0 0 0
1 0 1 1 0
0 1 0 0 0
0 1 0 0 0
0 0 0 0 0		 3
================================================ FILE: road/Road.java ================================================ package road; import java.util.*; import java.io.*; public class Road { private static ArrayList number = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str; while (sc.hasNextLine()){ str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ number.add(Integer.valueOf(st.nextToken())); } } } public static void main(String[] argv) throws IOException{ getData(); int roadCount = 0; for(int i = 0; i < number.size(); i++){ if(i != 0){ if(number.get(i) == 1){ roadCount++; } } } roadCount = roadCount / 2; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(roadCount)); pw.close(); } } ================================================ FILE: robot_k79/README.md ================================================

Робот К-79 (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Петя написал программу движения робота К-79. Программа состоит из следующих команд:

  • S — сделать шаг вперед
  • L — повернуться на 90 градусов влево
  • R — повернуться на 90 градусов вправо

Напишите программу, которая по заданной программе для робота определит, сколько шагов он сделает прежде, чем впервые вернется на то место, на котором уже побывал до этого, либо установит, что этого не произойдет.

Формат ввода

Во входном файле input.txt записана одна строка из заглавных английских букв S, L, R, описывающая программу для робота. Общее число команд в программе от 1 до 200, при этом команд S — не более 50.

Формат вывода

В выходной файл output.txt выведите, сколько шагов будет сделано (то есть выполнено команд S) прежде, чем робот впервые окажется в том месте, через которое он уже проходил. Если такого не произойдет, выведите в выходной файл число –1.

Примеры

Ввод Вывод
SSLSLSLSSRSRS 5
LSSSS -1
================================================ FILE: robot_k79/RobotK79.java ================================================ package robot_k79; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class RobotK79 { public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); ArrayList points = new ArrayList<>(); String[] steps = new Scanner(new FileReader("input.txt")).nextLine().split(""); int x = 0, y = 0; // кординаты движения int directNumber = 0, stepCount = 0; boolean success = false; points.add(x + String.valueOf(y)); for (String step : steps) { if (step.equals("S")) { // шаг вперед stepCount++; switch (directNumber) { case 0: // навправо x++; break; case 1: // вверх y++; break; case 2: // налево x--; break; case 3: // вниз y--; break; } String coordinate = x + String.valueOf(y); if (points.contains(coordinate)) { out.println(stepCount); success = true; break; } points.add(coordinate); } else if (step.equals("L")) { // налево directNumber++; } else { // направо directNumber--; } if (directNumber > 3) { directNumber = 0; } else if (directNumber < 0) { directNumber = 3; } } if (!success) { out.println(-1); } out.flush(); } } ================================================ FILE: rook/README.md ================================================

Игра с ладьей (19%)

Время: 1 сек.
Память: 16 Мб
Сложность: 19%

На бесконечной вправо и вверх шахматной доске находится ладья. Два игрока передвигают ее по очереди. За один ход разрешено сдвинуть ладью вниз или влево на произвольное (ненулевое) количество клеток так, чтобы ладья не покинула доску. Цель игры – переместить ладью в левый нижний угол, то есть клетку с координатами (1,1). Известно, что оба игрока придерживаются оптимальной стратегии. Игрок №1 ходит первым, при этом он обязан совершить хотя бы один ход. Если первый ход сделать нельзя, то определить победителя также невозможно. Требуется написать программу, которая найдет номер победившего игрока, либо определит, что этого сделать нельзя.

Формат ввода

Входной файл input.txt содержит два натуральных числа, разделенных пробелами: X и Y – координаты ладьи перед первым ходом (X,Y ≤ 109).

Формат вывода

В выходной файл output.txt выведите одно число – номер победившего игрока. Если победителя определить невозможно, то следует вывести 0.

Примеры

Ввод Вывод
1 1 0
1 6 1
================================================ FILE: rook/Rook.java ================================================ package rook; import java.util.*; import java.io.*; public class Rook { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Long.valueOf(st.nextToken())); } } public static void main(String[] argv) throws IOException{ getData(); long x = data.get(0); long y = data.get(1); String result = (x == 1 && y == 1) ? "0" : (x == y) ? "2" : "1"; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: runeword/README.md ================================================

Рунные слова (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Руны — это древние магические знаки, которые наши предки использовали как буквы. Говорят, что рунные знаки обладают магическими свойствами, а при сложении рун в слова их магическая сила многократно возрастает. Если кузнец изготовит доспехи и начертит там определенные руны в определенном порядке, то доспехи будут наделены необычайными магическими силами.

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

Но так или иначе и в этом деле развелись жулики. По подозрениям ученых кузнец Игнатус Мошеникус изготавливал благородным воинам фальшивые рунные слова. Из древних преданий ученым стало достоверно известно, что каждая руна записывается из двух, трех или четырех английских букв. Причем первая буква рунного слова всегда записывается как заглавная, а все остальные являются маленькими. Ученые перевели несколько, выкованных этим кузнецом, рунных слов на английский язык и теперь нуждаются в Вашей помощи. Проверьте, является ли приведенное слово рунным.

Формат ввода

В единственной строке входного файла input.txt содержится слово. Оно представляет собой непустую строку, длиной не более 100000 символов, содержащую только большие и маленькие буквы английского алфавита.

Формат вывода

В выходной файл output.txt выведите «Yes», если слово является рунным и «No» в противном случае.

Примеры

Ввод Вывод
IoIsTheBest Yes
IoItIsWaste No
================================================ FILE: runeword/Runeword.java ================================================ package runeword; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class Runeword { public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String word = sc.nextLine(); boolean rune = true; char[] words = word.toCharArray(); int serialNumber = 0; if(words.length > 1){ for(int i = 0; i < words.length; i++){ String symbol = String.valueOf(words[i]); if(i == 0){ if(!symbol.equals(symbol.toUpperCase()) || String.valueOf(words[words.length-1]).equals(String.valueOf(words[words.length-1]).toUpperCase())){ rune = false; break; }else { serialNumber++; } } else { if(symbol.equals(symbol.toUpperCase())){ if (serialNumber == 1){ rune = false; break; }else { serialNumber = 1; } }else { if(serialNumber < 4){ serialNumber++; }else { rune = false; break; } } } } }else { rune = false; } String result = rune ? "Yes" : "No"; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: saddle_point/README.md ================================================

Седловые точки (28%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Задана матрица, содержащая N строк и M столбцов. Седловой точкой этой матрицы назовем элемент, который одновременно является минимумом в своей строке и максимумом в своем столбце.

Найдите количество седловых точек заданной матрицы.

Формат ввода

Входной файл input.txt в первой строке содержит целые числа N и M (1 ≤ N, M ≤ 750). Далее следуют N строк по M чисел в каждой. Элементы матрицы - целые числа, не превосходящие 1000 по абсолютной величине. Числа могут быть разделены несколькими пробелами.

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
2 2
0 0
0 0		 4
2 2
1 2
3 4		 1
================================================ FILE: saddle_point/SaddlePoint.java ================================================ package saddle_point; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class SaddlePoint { public static void main(String[] args) throws IOException { int[][] data = new int[0][]; int[] minRow = new int[0]; int[] maxColumn = new int[0]; int result = 0; Scanner scan = new Scanner(new FileReader("input.txt")); int line = -1; while (scan.hasNextLine()){ String[] tokens = scan.nextLine().split("( )+"); if(line == -1){ int row = Integer.valueOf(tokens[0]); int column = Integer.valueOf(tokens[1]); data = new int[row][column]; minRow = new int[row]; maxColumn = new int[column]; }else { for (int col = 0; col < tokens.length; col++) { int token = Integer.valueOf(tokens[col]); if(minRow[line] == 0 || minRow[line] > token){ minRow[line] = token; } if(maxColumn[col] == 0 || maxColumn[col] < token){ maxColumn[col] = token; } data[line][col] = token; } } line++; } for (int i = 0; i < data.length; i++) { for (int j = 0; j < data[i].length; j++) { if (data[i][j] == minRow[i]) { if (data[i][j] == maxColumn[j]) { result++; } } } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: salads/README.md ================================================

Салаты (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Как-то раз, придя домой со школы, Света обнаружила записку от мамы, в которой она просила сделать салат. Света знала, что салат – это смесь двух или более ингредиентов, поэтому ей не составило труда выполнить мамину просьбу.

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

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

Формат ввода

Входной файл input.txt содержит натуральное число N – количество имеющихся ингредиентов (N < 32).

Формат вывода

В выходной файл output.txt выведите количество различных салатов.

Примеры

Ввод Вывод
3 4
4 11
================================================ FILE: salads/Salads.java ================================================ package salads; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.math.BigInteger; import java.util.Scanner; public class Salads { private static long combination(int numeric, int elementCount){ BigInteger first = BigInteger.valueOf(1); BigInteger second = BigInteger.valueOf(1); BigInteger third = BigInteger.valueOf(1); int difference = numeric - elementCount; for ( ; numeric > 0; first = first.multiply(BigInteger.valueOf((numeric--)))); for ( ; elementCount > 0; second = second.multiply(BigInteger.valueOf((elementCount--)))); for ( ; difference > 0; third = third.multiply(BigInteger.valueOf((difference--)))); BigInteger finish = first.divide(second.multiply(third)); return Long.valueOf(String.valueOf(finish)); } public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); int ingredientCount = sc.nextInt(); long result = 0; if(ingredientCount > 1){ for(int i = 2; i <= ingredientCount; i++){ int ingredientUsed = ingredientCount - i; long combination = combination(ingredientCount, ingredientUsed); result += combination; } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: salary/README.md ================================================

Зарплата (4%)

Время: 1 сек.
Память: 16 Мб
Сложность: 4%

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

Формат ввода

В единственной строке входного файла input.txt записаны размеры зарплат всех сотрудников через пробел. Каждая заработная плата – это натуральное число, не превышающее 105.

Формат вывода

В выходной файл output.txt необходимо вывести одно целое число — разницу между максимальной и минимальной зарплатой.

Пример 1

Ввод Вывод
100 500 1000 900
36 11 20 25
================================================ FILE: salary/Salary.java ================================================ package salary; import java.util.*; import java.io.*; public class Salary { public static void main(String[] args) throws IOException { ArrayList list = new ArrayList<>(); // Записываем все зп в коллекцию int difference; // Максимальная разница в зп int count; // Количество зарплат String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ list.add(Integer.valueOf(st.nextToken())); } Collections.sort(list); // Сортируем коллекцию count = list.size(); // Получаем размер коллекции difference = list.get(count-1) - list.get(0); // Из максимальной зп вычитаем минимальную FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(difference)); fileOut.close(); } } ================================================ FILE: same_numbers/README.md ================================================

Общие цифры (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Заданы натуральные числа A, B, C. Требуется написать программу, которая найдет общие цифры в этих числах.

Формат ввода

Входной файл input.txt содержит три натуральных числа A, B, C (1 ≤ A, B, C ≤ 1080). Числа разделены одним пробелом.

Формат вывода

Выходной файл output.txt должен содержать в первой строке количество общих цифр, а во второй строке в порядке возрастания через один пробел общие цифры.

Примеры

Ввод Вывод
1 2 3 0
12 13 14 1
1
1234 2345 3456 2
3 4
================================================ FILE: same_numbers/SameNumbers.java ================================================ package same_numbers; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class SameNumbers { public static void main(String[] args) throws IOException { Set a = new HashSet<>(); Set b = new HashSet<>(); Set c = new HashSet<>(); Scanner sc = new Scanner(new FileReader("input.txt")); int lineNumber = 0; while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ char[] ch = st.nextToken().toCharArray(); for (char symbol : ch){ if (lineNumber == 0){ if(a.size() <= 10){ a.add(symbol); }else break; }else if(lineNumber == 1){ if(b.size() <= 10){ b.add(symbol); }else break; }else if(lineNumber == 2){ if(c.size() <= 10){ c.add(symbol); }else break; } } lineNumber++; } } StringBuilder result = new StringBuilder(); ArrayList same = new ArrayList<>(); if(a.size() == b.size() && b.size() == c.size()){ for(char symbol : a){ if(b.contains(symbol) && c.contains(symbol)){ same.add(String.valueOf(symbol)); } } }else { int maxSize = a.size() >= b.size() && a.size() >= c.size() ? a.size(): b.size() >= a.size() && b.size() >= c.size() ? b.size() : c.size(); Set maxSet = a.size() == maxSize ? a : b.size() == maxSize ? b : c; for(char symbol : maxSet){ if(a.contains(symbol) && b.contains(symbol) && c.contains(symbol)){ same.add(String.valueOf(symbol)); } } } result.append(same.size()).append("\n"); for(String symbol : same){ result.append(symbol).append(" "); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: sapper/README.md ================================================

Сапер (28%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Мальчику Васе очень нравится известная игра "Сапер" ("Minesweeper").

В "Сапер" играет один человек. Игра идет на клетчатом поле (далее будем называть его картой) N×M (N строк, M столбцов). В K клетках поля стоят мины, в остальных клетках записано либо число от 1 до 8 — количество мин в соседних клетках, либо ничего не написано, если в соседних клетках мин нет. Клетки являются соседними, если они имеют хотя бы одну общую точку, в одной клетке не может стоять более одной мины. Изначально все клетки поля закрыты. Игрок за один ход может открыть какую-нибудь клетку. Если в открытой им клетке оказывается мина — он проигрывает, иначе игроку показывается число, которое стоит в этой клетке, и игра продолжается. Цель игры — открыть все клетки, в которых нет мин.

У Васи на компьютере есть эта игра, но ему кажется, что все карты, которые в ней есть, некрасивые и неинтересные. Поэтому он решил нарисовать свои. Однако фантазия у него богатая, а времени мало, и он хочет успеть нарисовать как можно больше карт. Поэтому он просто выбирает N, M и K и расставляет мины на поле, после чего все остальные клетки могут быть однозначно определены. Однако на определение остальных клеток он не хочет тратить свое драгоценное время. Помогите ему!

По заданным N, M, K и координатам мин восстановите полную карту.

Формат ввода

В первой строке входного файла input.txt содержатся числа N, M и K (1 ≤ N ≤ 200, 1 ≤ M ≤ 200, 0 ≤ K ≤ N×M). Далее идут K строк, в каждой из которых содержится по два числа, задающих координаты мин. Первое число в каждой строке задает номер строки клетки, где находится мина, второе число — номер столбца. Левая верхняя клетка поля имеет координаты (1,1), правая нижняя — координаты (N,M).

Формат вывода

Выходной файл output.txt должен содержать N строк по M символов — соответствующие строки карты. j-й символ i-й строки должен содержать символ ‘*‘ (звездочка) если в клетке (i,j) стоит мина, цифру от 1 до 8, если в этой клетке стоит соответствующее число, либо ‘.‘ (точка), если клетка (i,j) пустая.

Примеры

Ввод Вывод
10 9 23
1 8
2 3
3 2
3 3
4 3
5 7
6 7
7 1
7 2
7 3
7 4
7 5
7 6
7 7
7 8
8 1
8 3
8 5
8 7
9 3
9 5
9 6
9 7		 .111..1*1
13*2..111
1**3.....
13*2.111.
.111.2*2.
233335*41
********1
*6*7*8*41
13*4***2.
.1122321.
================================================ FILE: sapper/Sapper.java ================================================ package sapper; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class Sapper { private static StringBuilder minefield(int[][] field){ StringBuilder out = new StringBuilder(); for(int i = 0; i < field.length; i++){ for (int j = 0; j < field[i].length; j++){ int count = 0; if(field[i][j] == 1){ out.append("*"); }else { if(i-1 >= 0){ count += field[i-1][j]; } if(i+1 < field.length){ count += field[i+1][j]; } if(j-1 >= 0){ count += field[i][j-1]; } if(j+1 < field[i].length){ count += field[i][j+1]; } if(i-1 >= 0 && j-1 >= 0){ count += field[i-1][j-1]; } if(i-1 >= 0 && j+1 < field[i].length){ count += field[i-1][j+1]; } if(i+1 < field.length && j-1 >= 0){ count += field[i+1][j-1]; } if(i+1 < field.length && j+1 < field[i].length){ count += field[i+1][j+1]; } if(count == 0){ out.append("."); }else { out.append(count); } } } out.append("\n"); } return out; } public static void main(String[] args) throws IOException { int row, column; int[][] field = new int[0][]; Scanner sc = new Scanner(new FileReader("input.txt")); int index = 0; while (sc.hasNextLine()){ String[] arg = sc.nextLine().split(" "); if(index == 0){ row = Integer.valueOf(arg[0]); column = Integer.valueOf(arg[1]); field = new int[row][column]; index = 1; }else { int x = Integer.valueOf(arg[0])-1; int y = Integer.valueOf(arg[1])-1; field[x][y] = 1; } } StringBuilder result = minefield(field); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result).trim()); out.close(); } } ================================================ FILE: school_algebra/README.md ================================================

Двоякие числа (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Трёхчлен a + bx + сy от двух переменных x и y однозначно определяется коэффициентами a, b и c. Написать программу, которая по заданным a, b и c выводит соответствующий трёхчлен, записанный с использованием алгебраических соглашений:

  • коэффициент при члене, содержащем переменную, опускается, если его модуль равен единице;
  • член, коэффициент при котором равен нулю, опускается (кроме случая, когда все коэффициенты равны нулю, тогда трехчлен состоит из одной цифры 0);
  • знак "+" опускается, если он предшествует отрицательному коэффициенту;
  • знак "+" опускается, если он стоит в начале выражения (так называемый унарный плюс);
  • знак умножения между коэффициентом и переменной опускается.

При этом запрещено менять местами члены.

Формат ввода

Во входном файле input.txt через пробел записаны целые коэффициенты a, b и с, каждое из которых не превосходит 30000 по абсолютной величине.

Формат вывода

Выходной файл output.txt должен содержать трехчлен, записанный с использованием алгебраических соглашений.

Примеры

Ввод Вывод
0 2 -1 2x-y
3 0 -2 3-2y
================================================ FILE: school_algebra/SchoolAlgebra.java ================================================ package school_algebra; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; import java.util.StringTokenizer; public class SchoolAlgebra { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); int a = 0, b = 0, c = 0; while (st.hasMoreTokens()){ a = Integer.valueOf(st.nextToken()); b = Integer.valueOf(st.nextToken()); c = Integer.valueOf(st.nextToken()); } StringBuilder result = new StringBuilder(); if(a != 0){ result.append(a); } if(b != 0){ if(b == 1){ if(result.length() > 0){ result.append("+"); } result.append("x"); }else if(b == -1){ result.append("-").append("x"); }else { if(b > 0){ if(result.length() > 0){ result.append("+"); } result.append(b).append("x"); }else { result.append(b).append("x"); } } } if(c != 0){ if(c == 1){ if(result.length() > 0){ result.append("+"); } result.append("y"); }else if(c == -1){ result.append("-").append("y"); }else { if(c > 0){ if(result.length() > 0){ result.append("+"); } result.append(c).append("y"); }else { result.append(c).append("y"); } } } if(result.length() == 0){ result.append(0); } System.out.println(result); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: scoring/README.md ================================================

Подсчет баллов (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Решение каждой задачи заочного тура проверяется на наборе заранее заготовленных тестов. По результатам работы программы на каждом тесте участнику либо начисляются баллы за этот тест (когда программа выдала правильный ответ), либо не начисляются (когда во время работы программы произошли ошибки или выданный ответ не верен). Тесты могут иметь разную стоимость.

Дополнительные баллы начисляются участнику, если его программа прошла все тесты.

Участник может исправлять свое решение, и посылать его на проверку повторно (при этом решение проверяется на том же наборе тестов). При этом за каждую попытку из количества набранных по задаче баллов вычитается штраф, который равен 0 при 1-й попытке, а при каждой следующей возрастает на 2 (то есть 2 при второй, 4 — при третьей, 6 — при четвертой и т.д.).

Из баллов, полученных участником за каждую из попыток (с учетом начисленных штрафов), выбирается максимальный результат, который и засчитывается как результат данного участника по этой задаче. Это нужно, в частности, для того, чтобы последующие попытки не ухудшали уже полученный участником результат по задаче.

Например, если участник делает первую попытку и набирает 10 баллов, его результат по задаче равен 10 баллов. Пусть на второй попытке участник посылает решение, которое набирает 8 баллов. С учетом штрафа за эту попытку участник имеет 6 баллов, однако результат команды по задаче остается равным 10. Пусть с 3-й попытки решение набрало 20 баллов, тогда (с учетом штрафа) результат участника по задаче становится равен 16 баллам. Наконец, пусть с 4-й попытки решение проходит все тесты, тогда участник получает сумму баллов за все тесты, плюс призовые баллы за прохождение всех тестов, минус 6 баллов штрафа (если, конечно, эта величина не меньше 16 баллов, которые уже были у данного участника).

Напишите программу, которая определяет результат данного участника по этой задаче.

Формат ввода

Во входном файле input.txt записано сначала число N — количество тестов, на которых проверяются решения данной задачи (1≤N≤100). Далее идет N натуральных чисел, не превышающих 100, — баллы, которые начисляются за прохождение каждого из тестов. Далее идет целое число из диапазона от 0 до 100 — количество баллов, которое дополнительно начисляется за прохождение всех тестов.

Далее идет натуральное число M — количество попыток сдачи задачи (1≤M≤100). После чего идет M наборов по N чисел в каждом, задающих результаты проверки каждой из M попыток сдачи задачи на тестах. 0 обозначает, что соответствующий тест не пройден, 1 — пройден.

Формат вывода

В выходной файл output.txt выведите M чисел. i-ое число должно соответствовать результату участника после совершения им первых i попыток.

Примеры

Ввод Вывод
4
1 2 3 4
5
3
0 0 0 0
1 1 1 1
0 1 0 1		 0
13
13
================================================ FILE: scoring/Scoring.java ================================================ package scoring; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class Scoring { public static void main(String[] args) throws IOException { StringBuilder result = new StringBuilder(); ArrayList testsPoints = new ArrayList<>(); int bonus = 0; Scanner sc = new Scanner(new FileReader("input.txt")); int index = 0; int penalty = 0; int max = 0; boolean isPoints = false; while (sc.hasNextLine()){ String line = sc.nextLine(); if(index == 2){ bonus = Integer.valueOf(line); }else if(index != 0 && index != 3){ StringTokenizer st = new StringTokenizer(line, " "); int successTests = 0, successTotal = 0; int i = 0; while (st.hasMoreTokens()){ int number = Integer.valueOf(st.nextToken()); if(index == 1){ testsPoints.add(number); }else { isPoints = true; successTests += number; successTotal += number * testsPoints.get(i); i++; } } if(isPoints){ if(successTests == testsPoints.size()){ successTotal += bonus; } successTotal -= penalty; if(successTotal < 0){ successTotal = 0; } max = successTotal > max ? successTotal : max; result.append(max).append("\n"); penalty += 2; } } index++; } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: sea_battle_two/README.md ================================================

Морской бой - 2 (21%)

Время: 1 сек.
Память: 16 Мб
Сложность: 21%

«Морской бой» - игра для двух участников, в которой игроки по очереди называют координаты на неизвестной им карте соперника. Если у соперника по этим координатам имеется корабль, то корабль или его часть «топится», а попавший получает право сделать еще один ход. Цель игрока - первым поразить все корабли противника.

«Морской бой» очень популярен среди учеников одной физико-математической школы. Ребята очень любят в него играть на переменах. Вот и сейчас ученики Иннокентий и Емельян начали новую партию.

Правила, по которым ребята расставляют корабли перед началом партии, несколько отличаются от классических. Во-первых, игра происходит на поле размером N×M, а не 10×10. Во-вторых, число кораблей, их размер и форма выбираются ребятами перед партией - так играть намного интереснее.

Емельян уже расставил все свои корабли, кроме одного однопалубного. Такой корабль занимает ровно одну клетку.

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

Формат ввода

Первая строка входного файла input.txt содержит два числа: N и M (1 ≤ N, M ≤ 100). Последующие N строк описывают игровое поле - каждая из них содержит M символов. Символом «.» (точка) обозначена свободная клетка, символом «*» (звездочка) - занятая кораблем.

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
4 4
****
**..
*...
*...		 4
4 3
***
...
...
***		 0
================================================ FILE: sea_battle_two/SeaBattleTwo.java ================================================ package sea_battle_two; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class SeaBattleTwo { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ data.add(sc.nextLine()); } int row = 0, column = 0; StringTokenizer st = new StringTokenizer(data.get(0), " "); while (st.hasMoreTokens()){ row = Integer.valueOf(st.nextToken()); column = Integer.valueOf(st.nextToken()); } data.remove(0); String[] arrData = data.toArray(new String[0]); String[][] arrayReady = new String[row][column]; for(int i = 0; i < row; i++){ char[] ch = arrData[i].toCharArray(); for(int j = 0; j < column; j++){ arrayReady[i][j] = String.valueOf(ch[j]); } } int count = 0; if(row > 2 || column > 2){ for(int i = 0; i < row; i++){ for(int j = 0; j < column; j++){ if(arrayReady[i][j].equals(".")){ if( ((i == 0 && arrayReady[i+1][j].equals(".") || ((i-1 > -1 && arrayReady[i-1][j].equals(".")) && (i+1 < row && (arrayReady[i+1][j].equals("."))))) || (i == row-1 && arrayReady[i-1][j].equals("."))) && ((j == 0 && arrayReady[i][j+1].equals(".")) || ((j-1 > -1 && arrayReady[i][j-1].equals(".") && (j+1 < column && arrayReady[i][j+1].equals(".")))) || (j == column-1 && arrayReady[i][j-1].equals("."))) ) { count++; } } } } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(count)); out.close(); } } ================================================ FILE: season/README.md ================================================

Время года (10%)

Время: 1 сек.
Память: 16 Мб
Сложность: 10%

По заданному номеру месяца в году требуется определить время года.

Формат ввода

Входной файл input.txt содержит натуральное число N (N≤100) – номер месяца.

Формат вывода

В выходной файл output.txt выведите для летних месяцев значение «Summer», для зимних – «Winter», для весенних – «Spring», для осенних – «Autumn». Если число не соответствует возможному значению месяца, то в этом случае следует вывести «Error».

Примеры

Ввод Вывод
3 Spring
15 Error
================================================ FILE: season/Season.java ================================================ package season; import java.io.*; import java.util.*; public class Season { public static void main(String[] args) throws IOException { String season; String str; int month; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); month = Integer.valueOf(str); season = (month == 1 || month == 2 || month == 12) ? "Winter" : (month == 3 || month == 4 || month == 5) ? "Spring" : (month == 6 || month == 7 || month == 8) ? "Summer" : (month == 9 || month == 10 || month == 11) ? "Autumn" : "Error"; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(season); fileOut.close(); } } ================================================ FILE: sequence_conversion_two/README.md ================================================

Преобразование последовательности - 2 (29%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 29%

Задана последовательность, содержащая n целых чисел. Необходимо найти число, которое встречается в этой последовательности наибольшее количество раз, а если таких чисел несколько, то найти минимальное из них, и после этого переместить все такие числа в конец заданной последовательности. Порядок расположения остальных чисел должен остаться без изменения.

Например, последовательность 1, 2, 3, 2, 3, 1, 2 после преобразования должна превратиться в последовательность 1, 3, 3, 1, 2, 2, 2.

Требуется написать программу, которая решает данную задачу.

Формат ввода

Первая строка входного файла input.txt содержит число n — количество чисел во входной последовательности (3 ≤ n ≤ 100). Следующая строка содержит входную последовательность, состоящую из n целых чисел, не превышающих по модулю 100. Все числа в строке разделены пробелом.

Формат вывода

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

Примеры

Ввод Вывод
7
1 2 3 2 3 1 2		 1 3 3 1 2 2 2
================================================ FILE: sequence_conversion_two/SequenceConversionTwo.java ================================================ package sequence_conversion_two; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class SequenceConversionTwo { private static int listContainsNumberCount (ArrayList list, int number) { int count = 0; for (int item: list) { if (item == number) { count++; } } return count; } public static void main(String[] args) throws IOException { ArrayList inputNumbers = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()) { String[] numbers = sc.nextLine().split(" "); for (String number: numbers) { inputNumbers.add(Integer.parseInt(number)); } } inputNumbers.remove(0); ArrayList maxCountNumbers = new ArrayList<>(); // числа с максимальным повторением int maxCount = 0; // количество повторений числа for (int number: inputNumbers) { if (maxCountNumbers.size() == 0) { maxCountNumbers.add(number); maxCount++; } else { int countInputNumbers = listContainsNumberCount(inputNumbers, number); // кол-во в исходном массиве if (maxCount < countInputNumbers) { maxCountNumbers.clear(); maxCountNumbers.add(number); maxCount = countInputNumbers; } else if (maxCount == countInputNumbers && !maxCountNumbers.contains(number)) { maxCountNumbers.add(number); } } } int minNumber = Collections.min(maxCountNumbers); PrintWriter out = new PrintWriter(System.out); for (int number: inputNumbers) { if (number != minNumber) { out.print(number + " "); } } for (int index = 0; index < maxCount; index++) { out.print(minNumber + " "); } out.flush(); } } ================================================ FILE: sequence_two/README.md ================================================

Последовательность - 2 (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

Вася написал на доске n целых чисел ai и ушел. Пришел Петя и, увидев Васину последовательность, решил ее немного изменить. Для этого он решил, что может стирать с доски лишь те числа, у которых имеются слева и справа элементы, превосходящие их. Формально, Петя может стереть число ak, если существуют значения ai и aj такие, что ai > ak и aj > ak и i < k < j. Когда на доске не осталось чисел, которые мог стереть Петя, он ушел.

Пришел Вася и очень удивился увиденному. Напишите программу, которая выводит последовательность, которую увидел Вася.

Формат ввода

Первая строка входного файла INPUT.TXT содержит целое число n (1 ≤ n ≤ 10 000) - количество чисел. Следующая строка содержит n разделенных пробелом целых чисел ai (-106 ≤ ai ≤ 106) - записанные на доске числа.

Формат вывода

В первой строке выходного файла OUTPUT.TXT выведите целое число k - количество оставшихся на доске чисел. На следующей строке выведите k чисел bi - оставшиеся на доске числа.

Примеры

Ввод Вывод
12
1 2 3 2 4 1 3 4 2 3 2 1		 8
1 2 3 4 4 3 2 1
================================================ FILE: sequence_two/SequenceTwo.java ================================================ package sequence_two; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class SequenceTwo { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int n = Integer.parseInt(sc.nextLine()); String[] line = sc.nextLine().split(" "); ArrayList numbers = new ArrayList<>(); for (String number : line) { numbers.add(Integer.parseInt(number)); } int leftMax = -1000000; for (int i = 0; i < numbers.size(); i++) { if (leftMax < numbers.get(i)) { leftMax = numbers.get(i); } if (i > 0 && i+1 < numbers.size()) { for (int k = i+1; k < numbers.size(); k++) { if (numbers.get(i) < leftMax && numbers.get(i) < numbers.get(k)) { numbers.remove(i); i--; break; } } } } PrintWriter out = new PrintWriter(System.out); out.println(numbers.size()); for (int number : numbers) { out.print(number + " "); } out.flush(); } } ================================================ FILE: shelf/README.md ================================================

Полка (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

У Андрея есть младший брат Ванечка, который очень любит смотреть мультики. Ванечка вечно разбрасывал по дому и терял свои DVD с мультиками. Поэтому на день рождения Андрей подарил брату длинную полку для того, чтобы Ванечка ставил на нее свои диски. Чтобы на полке был порядок, Андрей просил Ванечку соблюдать простой порядок:

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

И теперь Андрей хочет узнать, выполнил Ванечка его инструкции или нет.

Формат ввода

В первой строке входного файла input.txt указано целое число N (1 ≤ N ≤ 10000) - количество операций, которые выполнил Ванечка. Далее в N строках находится информация об операциях. Каждая операция постановки диска на полку описывается парой чисел. Первое из них (1 или 2) показывает, что диск ставится с левого края или с правого края соответственно. Второе целое число (от 0 до 10000) обозначает номер диска. Операции снятия диска с полки описывается одним числом 3 или 4, обозначающим с левого и правого края полки соответственно снимается диск.

В начальный момент полка пуста. Гарантируется, что последовательность операций корректна, нет команд снятия диска с пустой полки.

Формат вывода

В выходной файл output.txt для каждой операции снятия диска с полки выведите его номер.

Примеры

Ввод Вывод
5
1 1
2 2
1 3
3
4		 3 2
2
1 1
3		 1
================================================ FILE: shelf/Shelf.java ================================================ package shelf; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayDeque; import java.util.Scanner; public class Shelf { public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); ArrayDeque discs = new ArrayDeque<>(); Scanner sc = new Scanner(new FileReader("input.txt")); int index = 0; while (sc.hasNextLine()) { String line = sc.nextLine(); if (index != 0) { String[] actions = line.split(" "); if (actions.length == 2 && actions[0].equals("1")) { discs.addFirst(actions[1]); } else if (actions.length == 2 && actions[0].equals("2")) { discs.addLast(actions[1]); } else if (actions[0].equals("3")) { out.print(discs.getFirst() + " "); discs.removeFirst(); } else { out.print(discs.getLast() + " "); discs.removeLast(); } } index++; } out.flush(); } } ================================================ FILE: shift_permutation/README.md ================================================

Сдвиг перестановки (24%)

Время: 1 сек.
Память: 16 Мб
Сложность: 24%

Перестановкой порядка n называется последовательность из попарно различных целых положительных чисел p1, p2, ... , pn, где каждое 1 ≤ pi ≤ n. Будем говорить, что перестановка q1, q2, ... , qn лексикографически меньше перестановки p1, p2, . . . , pn, если существует такое i, что qi < pi, а для любого j < i pj = qj.

Циклическим сдвигом на k перестановки p1, p2, ... , pn называется последовательность, pk+1, pk+2, ... , pn, p1, ... , pk. Отметим, что любой циклический сдвиг перестановки также является перестановкой.

Ваша задача состоит в том, чтобы найти наименьший лексикографически циклический сдвиг заданной перестановки.

Формат ввода

Первая строка входного файла input.txt содержит порядок n (1 ≤ n ≤ 105) заданной перестановки. Вторая строка содержит числа p1, p2, ... , pn, отделенные друг от друга пробелами.

Формат вывода

В выходной файл output.txt выведите перестановку, являющуюся наименьшим лексикографически циклическим сдвигом перестановки, заданной во входном файле.

Примеры

Ввод Вывод
3
3 2 1		 1 3 2
================================================ FILE: shift_permutation/ShiftPermutation.java ================================================ package shift_permutation; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class ShiftPermutation { public static void main(String[] args) throws IOException { ArrayList list = new ArrayList<>(); int min = 0; Scanner sc = new Scanner(new FileReader("input.txt")); int index = 0; while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ int number = Integer.valueOf(st.nextToken()); if(index == 0){ min = number; }else { if(min > number){ min = number; } list.add(number); } } index++; } StringBuilder result = new StringBuilder(); boolean start = false; for(int i = 0; i < list.size(); i++){ if(list.get(i) == min){ start = true; } if(start){ result.append(list.get(i)).append(" "); list.remove(i); i--; } } if(list.size() != 0){ for(int i : list){ result.append(i).append(" "); } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result).trim()); out.close(); } } ================================================ FILE: shift_text/README.md ================================================

Сдвиг текста (31%)

Ссылка на задачу

Время: 0,5 сек.
Память: 16 Мб
Сложность: 31%

Мальчик Кирилл написал однажды на листе бумаги строчку, состоящую из больших и маленьких английских букв, а после этого ушел играть в футбол. Когда он вернулся, то обнаружил, что его друг Дима написал под его строкой еще одну строчку такой же длины. Дима утверждает, что свою строчку он получил циклическим сдвигом строки Кирилла направо на несколько шагов (циклический сдвиг строки abcde на 2 позиции направо даст строку deabc). Однако Дима известен тем, что может случайно ошибиться в большом количестве вычислений, поэтому Кирилл в растерянности - верить ли Диме? Помогите ему!

По данным строкам выведите минимально возможный размер сдвига вправо или -1, если Дима ошибся.

Формат ввода

Первые две строки входного файла INPUT.TXT содержат строки Кирилла и Димы соответственно. Строки состоят только из английских символов. Длины строк одинаковы, не превышают 10000 и не равны 0.

Формат вывода

В выходной файл OUTPUT.TXT выведите единственное число - ответ на поставленную задачу.

Примеры

Ввод Вывод
abcde
deabc		 2
================================================ FILE: shift_text/ShiftText.java ================================================ package shift_text; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class ShiftText { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String firstLine = sc.nextLine(); String secondLine = sc.nextLine(); int result = -1; int index = 0; for (char symbol: secondLine.toCharArray()) { if (firstLine.indexOf(symbol) == 0) { String head = secondLine.substring(index); String tail = secondLine.substring(0, index); if ((head + tail).equals(firstLine)) { result = index; break; } } index++; } PrintWriter out = new PrintWriter(System.out); out.println(result); out.flush(); } } ================================================ FILE: shooter/README.md ================================================

Стрелок (28%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Стрелок стоит в центре стрельбища. На стрельбище несколько мишеней. Пули стрелка пробивают мишени насквозь, не теряя скорости, и могут поразить все мишени, стоящие на одной линии.

Будем считать, что стрелок стоит в центре начала координат. Известны координаты всех мишеней (для простоты будем считать их геометрические размеры пренебрежимо малыми). Определите минимальное число выстрелов, необходимых стрелку для поражения всех мишеней.

Формат ввода

Первая строка входного файла input.txt содержит натуральное число N – количество мишеней (N ≤ 20). Далее идет N строк с информацией о координатах каждой мишени, при этом в каждой строке указывается два целых числа через пробел X и Y (-10 ≤ X, Y ≤ 10).

Формат вывода

В выходной файл output.txt выведите одно целое число – наименьшее количество выстрелов, необходимых для поражения всех мишеней.

Примеры

Ввод Вывод
4
2 2
-2 2
-2 -2
2 -2		 4
6
2 2
-2 2
-2 -2
2 -2
1 1
-1 3		 5
================================================ FILE: shooter/Shooter.java ================================================ package shooter; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class Shooter { /** * @param onePoint Первая точка * @param twoPoint Вторая точка * @return Точки лежат на одной прямой включая начало координат, false - иначе * */ private static boolean onOneStraightLine(int[] onePoint, int[] twoPoint) { return onePoint[0] * twoPoint[1] - twoPoint[0] * onePoint[1] == 0; } /** * @param onePoint Первая точка * @param twoPoint Вторая точка * @return true - точки лежат в одной четвети, false - иначе * */ private static boolean pointsOneDirection (int[] onePoint, int[] twoPoint) { boolean shotPossible = false; // 1 четверть if (onePoint[0] > 0 && onePoint[1] >= 0 && twoPoint[0] > 0 && twoPoint[1] >= 0) { shotPossible = true; } // 2 четверть if (onePoint[0] <= 0 && onePoint[1] > 0 && twoPoint[0] <= 0 && twoPoint[1] > 0) { shotPossible = true; } // 3 четверть if (onePoint[0] < 0 && onePoint[1] <= 0 && twoPoint[0] < 0 && twoPoint[1] <= 0) { shotPossible = true; } // 4 четверть if (onePoint[0] >= 0 && onePoint[1] < 0 && twoPoint[0] >= 0 && twoPoint[1] < 0) { shotPossible = true; } return shotPossible; } public static void main(String[] args) throws IOException { ArrayList points = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()) { String[] lineArray = sc.nextLine().split(" "); if (lineArray.length == 2) { int[] point = new int[2]; point[0] = Integer.parseInt(lineArray[0]); point[1] = Integer.parseInt(lineArray[1]); points.add(point); } } // количество выстрелов int shotCount = points.size(); for (int i = 0; i < points.size(); i++) { for (int j = i + 1; j < points.size(); j++) { // проверка первой точки if (pointsOneDirection (points.get(i),points.get(j)) && onOneStraightLine(points.get(i), points.get(j))) { points.remove(j); j--; shotCount--; // проверка остальных точек for (int k = j+1; k < points.size(); k++) { if (pointsOneDirection (points.get(i),points.get(k)) && onOneStraightLine(points.get(i), points.get(k))) { points.remove(k); k--; shotCount--; } } } } } PrintWriter out = new PrintWriter(System.out); out.println(shotCount); out.flush(); } } ================================================ FILE: shooting_championship/README.md ================================================

Чемпионат по стрельбе (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

Победитель школьного этапа олимпиады по информатике нашел дома в старых бумагах результаты чемпионата страны по стрельбе из лука, в котором участвовал его папа. К сожалению, листок с результатами сильно пострадал от времени, и разобрать фамилии участников было невозможно. Остались только набранные каждым участником очки, причем расположились они в том порядке, в котором участники чемпионата выполняли стрельбу.

Расспросив папу, школьник выяснил, что количество очков, которое набрал папа, заканчивается на 5, хотя бы один из победителей чемпионата стрелял раньше, а папин друг, который стрелял сразу после папы, набрал меньше очков. Теперь он заинтересовался, какое самое высокое место мог занять его папа на том чемпионате.

Будем считать, что участник соревнования занял k-е место, если ровно (k – 1) участников чемпионата набрали строго больше очков, чем он. При этом победителями считались все участники чемпионата, занявшие первое место.

Требуется написать программу, которая по заданным результатам чемпионата определяет, какое самое высокое место на чемпионате мог занять папа победителя школьного этапа олимпиады по информатике.

Формат ввода

Первая строка входного файла INPUT.TXT содержит целое число n — количество участников чемпионата страны по стрельбе (3 ≤ n ≤ 105). Вторая строка содержит n положительных целых чисел, каждое из которых не превышает 1000, — очки участников чемпионата, приведенные в том порядке, в котором они выполняли стрельбу.

Формат вывода

В выходном файле OUTPUT.TXT должно содержаться одно целое число — самое высокое место, которое мог занять папа школьника. Если не существует ни одного участника чемпионата, который удовлетворяет, описанным выше условиям, выведите в выходной файл число 0.

Примеры

Ввод Вывод
7
10 20 15 10 30 5 1		 6
3
15 15 10		 1
3
10 15 20		 0
================================================ FILE: shooting_championship/ShootingChampionship.java ================================================ package shooting_championship; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Comparator; import java.util.Scanner; public class ShootingChampionship { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String n = sc.nextLine(); ArrayList data = new ArrayList<>(); String[] dataArr = sc.nextLine().split(" "); int winnerPoints = 0; for (String number : dataArr) { int numberInt = Integer.parseInt(number); if (winnerPoints < numberInt) { winnerPoints = numberInt; } data.add(numberInt); } int pointsFather = -1; boolean wasFirst = false; for (int i = 0; i < data.size(); i++) { if (wasFirst && data.get(i) % 10 == 5 && i+1 < data.size() && data.get(i) > data.get(i+1) && pointsFather < data.get(i)) { pointsFather = data.get(i); } if (data.get(i) == winnerPoints) { wasFirst = true; } } data.sort(Comparator.reverseOrder()); int position = 0; if (pointsFather > -1) { for (int number : data) { position++; if (number == pointsFather) { break; } } } PrintWriter out = new PrintWriter(System.out); out.println(position); out.flush(); } } ================================================ FILE: short_sequence/README.md ================================================

Короткая последовательность (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Дано целое число N. Рассмотрим последовательность S1S2S3...Sk..., где каждая группа цифр Sk состоит из записанных одно за другим чисел от 1 до k. Например, первые 75 цифр последовательности выглядят так:

112123123412345123456123456712345678123456789123456789101234567891011123456.

Требуется написать программу, которая определит: какая цифра находится на N-ой позиции в построенной последовательности.

Формат ввода

Входной файл input.txt содержит одно число N (0 < N < 32768).

Формат вывода

В выходной файл output.txt выведите цифру, которая стоит на N-ой позиции в последовательности.

Примеры

Ввод Вывод
3 2
20 5
================================================ FILE: short_sequence/ShortSequence.java ================================================ package short_sequence; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class ShortSequence { public static void main(String[] args) throws IOException { StringBuilder string = new StringBuilder(); Scanner sc = new Scanner(new FileReader("input.txt")); int number = sc.nextInt(); int start = 1; StringBuilder memory = new StringBuilder(); while (string.length() <= number){ memory.append(start); string.append(memory); start++; } String result = String.valueOf(string.charAt(number-1)); FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: similar_arrays/README.md ================================================

Похожие массивы (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Два массива называются похожими, если совпадают множества чисел, встречающихся в этих массивах.

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

Формат ввода

Выходной файл output.txt должен содержать 1, если массивы похожи и 0 иначе.

Формат вывода

В выходной файл output.txt выведите an.

Примеры

Ввод Вывод
4 3
1 2 3 2
1 2 3		 1
2 3
1 2
2 3 1		 0
================================================ FILE: similar_arrays/SimilarArrays.java ================================================ package similar_arrays; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.HashSet; import java.util.Scanner; import java.util.Set; import java.util.StringTokenizer; public class SimilarArrays { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int i = 0; Set firstSet = new HashSet<>(); Set secondSet = new HashSet<>(); while (sc.hasNextLine()){ String str = sc.nextLine(); if(i != 0){ StringTokenizer st = new StringTokenizer(str, " "); if(i == 1){ while (st.hasMoreTokens()){ firstSet.add(Integer.valueOf(st.nextToken())); } }else { while (st.hasMoreTokens()){ secondSet.add(Integer.valueOf(st.nextToken())); } } } i++; } String result = firstSet.equals(secondSet) ? "1" : "0"; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: simple_again/README.md ================================================

Снова про простые числа (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Найдите простое число из отрезка [a, b] с максимальной суммой цифр. Если таких чисел несколько, выберите из них максимальное.

Напомним, что простым называется натуральное число, большее единицы и делящееся только на единицу и на само себя.

Формат ввода

Входной файл input.txt содержит два целых числа: a и b (1 ≤ a ≤ b ≤ 108, b−a ≤ 1000).

Формат вывода

В выходной файл output.txt выведите ответ на задачу. Если указанный отрезок не содержит простых чисел, выведите в выходной файл -1.

Примеры

Ввод Вывод
1 13 7
900 1000 997
8 10 -1
================================================ FILE: simple_again/SimpleAgain.java ================================================ package simple_again; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class SimpleAgain { private static boolean simple(long number){ double sqrt = Math.sqrt(number); if(number == 1 || number == 2) return true; if(number % 2 == 0) return false; for(long i = 3; i <= sqrt; i += 2){ if(number % i == 0) return false; } return true; } private static long sum(long number){ long sum = 0; while (number > 0){ sum += number % 10; number /= 10; } return sum; } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); StringTokenizer st = new StringTokenizer(sc.nextLine()," "); long start = Integer.valueOf(st.nextToken()); long finish = Long.valueOf(st.nextToken()); long maxSum = -1; long maxSimpleNumber = -1; for(long i = start+1; i <= finish; i++){ if(simple(i)){ long sum = sum(i); if(sum > maxSum){ maxSimpleNumber = i; maxSum = sum; } if(sum == maxSum){ maxSimpleNumber = (i > maxSimpleNumber) ? i : maxSimpleNumber; } } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(maxSimpleNumber)); out.close(); } } ================================================ FILE: simple_calculation/README.md ================================================

Несложное вычисление (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Задано натуральное число n. Необходимо перевести его в k-ичную систему счисления и найти разность между произведением и суммой его цифр в этой системе счисления.

Например, пусть n = 239, k = 8. Тогда представление числа n в восьмеричной системе счисления — 357, а ответ на задачу равен 3 × 5 × 7 − (3 + 5 + 7) = 90.

Формат ввода

Входной файл input.txt содержит два натуральных числа: n и k (1 ≤ n ≤ 109, 2 ≤ k ≤ 10). Оба этих числа заданы в десятичной системе счисления.

Формат вывода

В выходной файл output.txt выведите ответ на задачу (в десятичной системе счисления).

Примеры

Ввод Вывод
239 8 90
1000000000 7 -34
================================================ FILE: simple_calculation/SimpleCalculation.java ================================================ package simple_calculation; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class SimpleCalculation { private static int difference(long numberOfSystem){ int sum = 0; int multi = 1; while (numberOfSystem > 0){ long number = numberOfSystem % 10; sum += number; multi *= number; numberOfSystem /= 10; } return multi - sum; } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); long numberIn = sc.nextLong(); int numberSystem = sc.nextInt(); long numberOfSystem = Long.parseLong(Long.toString(numberIn, numberSystem)); long result = difference(numberOfSystem); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: simple_number/README.md ================================================

Необходимо вывести все простые числа от M до N включительно. (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Найдите количество чисел из отрезка [L, R], которые делятся на произведение своих цифр.

Формат ввода

Входной файл input.txt содержит два натуральных числа M и N, разделенных пробелом (2 ≤ M ≤ N ≤ 106)

Формат вывода

В выходной файл output.txt выведите все простые числа от M до N в порядке возрастания, по одному в строке. Если таковых чисел нет, то следует вывести «Absent».

Примеры

Ввод Вывод
2 5 2
3
5
4 4 Absent
================================================ FILE: simple_number/SimpleNumber.java ================================================ package simple_number; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class SimpleNumber { private static StringBuilder sieve(int m, int n){ //Решето Эратосфена StringBuilder result = new StringBuilder(); int[] numbers = new int[n+1]; for(int k = 2; k <= n; k++){ numbers[k] = k; } for (int k = 2; k*k <= n; k++){ if(numbers[k] == k){ for(int j = k * k ; j <= n; j += k){ numbers[j] = 0; } } } for(int i = 0; i < numbers.length; i++){ if(numbers[i] >= m){ result.append(i).append("\n"); } } return result; } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] line = sc.nextLine().split(" "); int m = Integer.valueOf(line[0]); int n = Integer.valueOf(line[1]); StringBuilder result = sieve(m, n); if(result.length() == 0) { result.append("Absent"); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result).trim()); out.close(); } } ================================================ FILE: simple_numbers_two/README.md ================================================

Простые числа - 2 (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Знаете ли вы, что такое простое число? Простое число – это натуральное число, имеющее ровно два различных натуральных делителя: единицу и самого себя. Все остальные числа, кроме единицы, называются составными. Например, числа 2, 3, 5, 7, 11 являются простыми. А числа 4, 6, 10 – составными.

Требуется из заданного набора чисел выбрать одно, имеющее максимальное количество простых делителей. Например, 30 имеет три простых делителя (2, 3 и 5), а 40 – только два (2 и 5).

Формат ввода

Первая строка входного файла input.txt содержит число N – количество чисел в наборе. Во второй строке теста содержится N чисел, разделенных пробелом. Все числа во входных данных целые, принимающие значения от 2 до 1024.

Формат вывода

В выходной файл output.txt выведите число с максимальным количеством простых делителей. Если таких чисел несколько, выведите наименьшее из них.

Примеры

Ввод Вывод
10
3 5 7 9 11 13 15 17 19 21		 15
11
2 4 6 8 10 13 39 105 200 201 143		 105
================================================ FILE: simple_numbers_two/SimpleNumbersTwo.java ================================================ package simple_numbers_two; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class SimpleNumbersTwo { /** * @param divider Делитель числа * @return true, если делитель простое число, false в противном случае * */ private static boolean isSimple(int divider){ if(divider == 2) return true; if (divider % 2 == 0) return false; for(int i = 3; i < divider / 2; i += 2){ if(divider % i == 0){ return false; } } return true; } /** * @param number Проверяемое число из исходных данных * @return Массив с количеством простых делителей и исходным числом * */ private static int [] getDividers(int number){ int numberCopy = number; Set dividers = new HashSet<>(); int index = 2; while (numberCopy != 1){ if(numberCopy % index == 0){ if(isSimple(index)){ dividers.add(index); } numberCopy /= index; }else index++; } return new int[]{dividers.size(), number}; } public static void main(String[] args) throws IOException { ArrayList array = new ArrayList<>(); TreeMap dividers = new TreeMap<>(); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()){ String[] arr = sc.nextLine().split(" "); for(String elem : arr){ array.add(Integer.valueOf(elem)); } } array.remove(0); for(int number : array){ int[] dividersSimple = getDividers(number); if(dividers.containsKey(dividersSimple[0])){ if(dividers.get(dividersSimple[0]) > dividersSimple[1]){ dividers.put(dividersSimple[0], dividersSimple[1]); } }else { dividers.put(dividersSimple[0], dividersSimple[1]); } } String[] resultArr = String.valueOf(dividers.pollLastEntry()).split("="); String result = resultArr[1]; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: simple_radical/README.md ================================================

Простой цифровой корень (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

Определим простой цифровой корень (ПЦК) натурального числа N следующим образом. Если N - простое число, то ПЦК(N) = N. Если число однозначное, но не простое (то есть 1, 4, 6, 8 или 9), то ПЦК(N) = 0. В остальных случаях ПЦК(N) = ПЦК(S(N)), где S(N) - сумма цифр числа N.

Формат ввода

Во входном файле input.txt записано число N (1 ≤ N ≤ 231-1).

Формат вывода

Запишите в файл output.txt простой цифровой корень числа N.

Примеры

Ввод Вывод
1 0
3 3
128 11
================================================ FILE: simple_radical/SimpleRadical.java ================================================ package simple_radical; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class SimpleRadical { /** * Проверка числа на простоту * */ private static boolean simple(BigInteger number) { if (number.equals(BigInteger.ONE)) { // по условию return false; } if (number.equals(BigInteger.TWO)) { return true; } if (number.mod(BigInteger.TWO).equals(BigInteger.ZERO)) { return false; } for (BigInteger a = new BigInteger("3"); ; a = a.add(BigInteger.ONE)) { if (a.compareTo(number.sqrt()) > 0) { break; } if (number.mod(a).equals(BigInteger.ZERO)) { return false; } } return true; } /** * Проверка суммы цифр числа на простоту * Сложение до тнех пор, пока не получится простое число или непростое не более 10 * */ private static BigInteger sumCharacterSimple(BigInteger number) { BigInteger sumCharacter = sumCharacter(number); while (!simple(sumCharacter) && sumCharacter.compareTo(new BigInteger("10")) > 0) { sumCharacter = sumCharacter(sumCharacter); } if (sumCharacter.compareTo(new BigInteger("10")) < 0 && !(simple(sumCharacter))) { return BigInteger.ZERO; } else { return sumCharacter; } } /** * Сумма цифр числа * */ private static BigInteger sumCharacter(BigInteger number) { BigInteger sum = BigInteger.ZERO; while (!number.equals(BigInteger.ZERO)) { sum = sum.add(number.mod(new BigInteger("10"))); number = number.divide(new BigInteger("10")); } return sum; } public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); String number = new Scanner(new FileReader("input.txt")).nextLine(); BigInteger numberInt = new BigInteger(number); if (simple(numberInt)) { out.println(number); } else if (!simple(numberInt) && number.length() == 1) { out.println(0); } else { out.println(sumCharacterSimple(numberInt)); } out.flush(); } } ================================================ FILE: simple_series/README.md ================================================

Простой ряд (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Простым числом называется натуральное число (большее 1), которое делится нацело только на 1 и на само себя. Например, числа 2, 3, 5, 7, 11 и 23 - простые . Назовем простым рядом последовательность цифр, полученную следующим образом: подряд идущие по возрастанию простые числа (начиная с 2) записываются друг за другом. Начало данного ряда выглядит так: 23571113171923… Необходимо найти цифру, стоящую в простом ряду на указанном месте. Нумерация позиций начинается с единицы.

Формат ввода

В первой строке входного файла input.txt записано натуральное число M – количество тестов. Во второй строке записано M чисел через пробел, каждое число – номер позиции в простом ряду (1 ≤ M ≤ 1000, 1 ≤ номер позиции ≤ 10000).

Формат вывода

В выходной файл output.txt для каждой позиции выведите цифру из простого ряда, стоящую на этой позиции. Вывести следует M цифр в одной строке, не разделяя цифры пробелами.

Примеры

Ввод Вывод
3
1 4 11		 271
5
2 5 6 8 12		 31139
================================================ FILE: simple_series/SimpleSeries.java ================================================ package simple_series; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class SimpleSeries { private static String numbers(int number){ StringBuilder out = new StringBuilder(); out.append(23); int i = 3; while (out.length() < number){ i++; boolean simple = true; for(int j = i-1; j > 1; j--){ if(i % j == 0){ simple = false; break; } } if(simple){ out.append(i); } } return String.valueOf(out); } public static void main(String[] args) throws IOException { int max = 0; ArrayList positions = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ int pos = Integer.valueOf(st.nextToken()); if (pos > max) max = pos; positions.add(pos); } } positions.remove(0); String str = numbers(max); StringBuilder result = new StringBuilder(); for(int i : positions){ result.append(str.charAt(i-1)); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: simple_sorting/README.md ================================================

Несложная сортировка (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Пусть x – целое положительное число, а k – натуральное число от 1 до 10. Пусть s(x, k) равно сумме цифр числа x, представленного в системе счисления по основанию k.

Задано n чисел a1, a2, ..., an. Необходимо вычислить последовательность bi по формуле bi = s(ai, k1) • s(ai, k2), после чего отсортировать последовательность bi по неубыванию.

Формат ввода

Первая строка входного файла input.txt содержит три целых числа: n, k1, k2 (1 ≤ n ≤ 1000, 2 ≤ k1, k2 ≤ 10). Вторая строка содержит n целых чисел: ai (1 ≤ ai ≤ 109).

Формат вывода

В выходной файл output.txt выведите n чисел – bi в требуемом порядке.

Примеры

Ввод Вывод
9 10 10
1 2 3 4 5 6 7 9 8		 1 4 9 16 25 36 49 64 81
10 2 2
1 2 4 8 16 32 64 128 256 512		 1 1 1 1 1 1 1 1 1 1
================================================ FILE: simple_sorting/SimpleSorting.java ================================================ package simple_sorting; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; import java.util.StringTokenizer; public class SimpleSorting { private static long sum(long number, long system){ int sum = 0; while (number > 0){ sum += number % system; number /= system; } return sum; } public static void main(String[] args) throws IOException { long n = 0, k = 0, m = 0; ArrayList data = new ArrayList<>(); Scanner scan = new Scanner(new FileReader("input.txt")); int index = 0; while (scan.hasNextLine()){ StringTokenizer token = new StringTokenizer(scan.nextLine(), " "); if(index == 0){ k = Integer.valueOf(token.nextToken()); m = Integer.valueOf(token.nextToken()); }else { while (token.hasMoreTokens()){ data.add(Long.valueOf(token.nextToken())); } } index++; } for(int i = 0; i < data.size(); i++){ long newNumber = sum(data.get(i), k) * sum(data.get(i), m); data.set(i, newNumber); } Collections.sort(data); StringBuilder result = new StringBuilder(); for(long number : data){ result.append(String.valueOf(number)).append(" "); } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result).trim()); out.close(); } } ================================================ FILE: single_nod/README.md ================================================

Единичный НОД (23%)

Время: 1 сек.
Память: 16 Мб
Сложность: 23%

Заданы два натуральных числа в десятичной системе счисления, состоящие из единиц. В первом числе ровно N единиц, а во втором их ровно M. Требуется найти НОД этих чисел.

Напомним, что НОД (наибольший общий делитель) двух чисел a и b — это такое максимальное число c, что b делится на c и a делится на c.

Формат ввода

В единственной строке входного файла input.txt записаны два целых числа N и M (1 ≤ N, M ≤ 2000).

Формат вывода

В выходной файл output.txt выведите ответ без ведущих нулей.

Примеры

Ввод Вывод
5
4 4 1 5 4		 9:9
1
1234		 1234:0
================================================ FILE: single_nod/SingleNod.java ================================================ package single_nod; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class SingleNod { public static void main(String[] args) throws IOException { ArrayList numbers = new ArrayList<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ numbers.add(Integer.valueOf(st.nextToken())); } int oneNumber = numbers.get(0); int twoNumber = numbers.get(1); while(oneNumber != twoNumber){ if(oneNumber > twoNumber) oneNumber = oneNumber - twoNumber; else twoNumber = twoNumber - oneNumber; } int result = oneNumber; StringBuilder outNumber = new StringBuilder(); for(int i = 0; i < result; i++){ outNumber.append("1"); } System.out.println(outNumber); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(outNumber)); out.close(); } } ================================================ FILE: smallest_number_system/README.md ================================================

Наименьшая система счисления (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Известно, что основанием позиционной системы счисления называют количество различных символов, используемых для записи чисел в данной системе счисления. Также известно, что любое число x в b-ичной системе счисления имеет вид x=a0∙b0+a1∙b1+…+an∙bn, где b ≥ 2 и 0 ≤ ai < b.

Для записи чисел в b-ичной системе счисления, где b ≤ 36, могут быть использованы первые b символов из следующего списка 0,1,…, 9, A, B, …, Z. Например, для записи чисел в троичной системы используются символы 0, 1, 2, а в двенадцатеричной - 0,1,…, 9, A, B.

Требуется написать программу, которая по входной строке S определит, является ли данная строка записью числа в системе счисления, с основанием не большим 36, и, если является, определит минимальное основание этой системы счисления.

Формат ввода

Входной файл input.txt содержит в единственной строке входную непустую строку. Длина строки не превышает 255. Все символы строки имеют коды от 32 до 127.

Формат вывода

Выходной файл output.txt должен содержать одно число. Если строка является записью числа в некоторой системе счисления, то нужно вывести минимальное основание такой системы счисления. Иначе вывести -1.

Примеры

Ввод Вывод
123 4
ABCDEF 16
AD%AF -1
03025 6
abc -1
================================================ FILE: smallest_number_system/SmallestNumberSystem.java ================================================ package smallest_number_system; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Map; import java.util.Scanner; import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.IntStream; public class SmallestNumberSystem { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String number = sc.nextLine(); int result = -1; Map numberSystem = IntStream.rangeClosed('A', 'Z') .boxed() .collect(Collectors.toMap( x -> (char) x.intValue(), x -> x + (11 - 'A'))); for(int i = 1; i <10 ; i++){ numberSystem.put(Character.forDigit(i, 10), i+1); } if(Pattern.matches("\\w+", number) && number.toUpperCase().equals(number) && number.replaceAll("_", "").equals(number) ){ char max = '!'; char[] ch = number.toCharArray(); for(char symbol : ch){ if(max == '!'){ max = symbol; }else { if(max < symbol){ max = symbol; } } } if(max == '0'){ result = 2; }else { result = numberSystem.get(max); } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: sorting_count/README.md ================================================

Сортировка подсчетом (29%)

Ссылка на задачу

Время: 2 сек.
Память: 128 Мб
Сложность: 29%

На планете «Аурон» атмосфера практически отсутствует, поэтому она известна своими перепадами температур в различных точках. Известно, что эти перепады колеблются от -100 до 100 градусов. Нашим специалистам удалось выяснить значения температур в N точках этой планеты. К сожалению, эти значения вычислены с большими погрешностями, поэтому их решили округлить до целых чисел. Хотелось бы наглядно видеть участки с повышенной и пониженной температурой. Вам требуется помочь. Вы должны упорядочить температуры участков по неубыванию.

Формат ввода

В первой строке входного файла input.txt задано натуральное число N - количество участков (N ≤ 106). Во второй строке через пробел записаны целые значения температур этих участков, не превосходящие 100 по абсолютной величине.

Формат вывода

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

Примеры

Ввод Вывод
3
9 -20 14		 -20 9 14
10
12 7 92 5 18 4 32 48 11 74		 4 5 7 11 12 18 32 48 74 92
================================================ FILE: sorting_count/SortingCount.java ================================================ package sorting_count; import java.io.BufferedInputStream; import java.io.FileInputStream; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; public class SortingCount { public static void main(String[] args) throws IOException { ArrayList inputArray = new ArrayList<>(); // Считываем данные в коллекцию BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("input.txt")); int i; int index = -1; StringBuilder numberString = new StringBuilder(); while((i = bufferedInputStream.read())!= -1){ if (i == 13 || i == 32) { if (numberString.length() > 0) { int number = Integer.parseInt(numberString.toString()); if (index != -1) { inputArray.add(number); } numberString = new StringBuilder(); index++; } } else if (i != 10) { numberString.append((char) i); } } // Записываем последнее число if (numberString.length() > 0) { int number = Integer.parseInt(numberString.toString()); inputArray.add(number); } // Формирукем вспомогательный массив с кол-вом возможных значений int[] helpArray = new int[201]; // Записываем данные на определенное место for (int value : inputArray) { helpArray[value + 100] = helpArray[value + 100] + 1; } // Считываем данные, вычисляем место в массиве PrintWriter out = new PrintWriter(System.out); int number = -100; for (int value : helpArray) { for (int k = 0; k < value; k++) { out.print(number + " "); } number++; } out.flush(); } } ================================================ FILE: spelling/README.md ================================================

Орфография (13%)

Время: 1 сек.
Память: 16 Мб
Сложность: 13%

У студента-филолога Васи есть замечательный друг Петя. И Петя никак не может выучить английский язык. Английский текст Петя еще кое-как читает, но пишет с ужасными ошибками, причем чаще всего он вставляет в слова лишние буквы.

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

Формат ввода

Входной файл input.txt содержит целое число K - номер лишней буквы, а затем через один или несколько пробелов записано слово S, состоящее из английских букв верхнего регистра. Гарантируется, что номер буквы не превышает длину слова. Длина слова не более 80 символов.

Формат вывода

В выходной файл output.txt выведите исправленное слово.

Примеры

Ввод Вывод
4 MISTSPELL MISSPELL
2 ABC AC
================================================ FILE: spelling/Spelling.java ================================================ package spelling; import java.io.*; import java.util.*; public class Spelling { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); ArrayList dataOut = new ArrayList<>(); int firstNumber; StringBuilder result = null; String str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(st.nextToken()); } String line = data.get(1); // Разбираем второй элемент коллекции посимвольно char[] ch = line.toCharArray(); // Записывавем символы в массив data.remove(1); // Удаляем второй элемент коллекции for (char aCh : ch) { // Перебрать массив по символам data.add(String.valueOf(aCh)); } firstNumber = Integer.valueOf(data.get(0)); // Какая буква лишняя в слове for(int i = 0; i < data.size(); i++){ if(i != 0 && firstNumber != i){ // Выкинуть лишние символы из строки dataOut.add(data.get(i)); } } if(!dataOut.isEmpty()){ for(String lines : dataOut){ if(result != null){ result.append(lines); // Добавить следующие элементы коллекции в строку }else{ result = new StringBuilder(lines); // Добавить первый элемент коллекции в строку } } }else{ result = new StringBuilder(""); } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: split_parts/README.md ================================================

Разбиение на части (21%)

Время: 1 сек.
Память: 16 Мб
Сложность: 21%

Необходимо представить целое число N в виде суммы M примерно равных целых чисел. Будем считать, что числа примерно равны, если они отличаются друг от друга не более чем на единицу.

Формат ввода

Во входном файле input.txt записаны два натуральных числа N и M через пробел, каждое из которых не превосходит 30000.

Формат вывода

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

Примеры

Ввод Вывод
13 4 3 3 3 4
72 8 9 9 9 9 9 9 9 9
================================================ FILE: split_parts/SplitParts.java ================================================ package split_parts; import java.util.*; import java.io.*; public class SplitParts { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } public static void main(String[] argv) throws IOException{ getData(); int number = data.get(0); int numbersSumm = data.get(1); int part = number/numbersSumm; StringBuilder result = new StringBuilder(); if(number % numbersSumm == 0){ while (numbersSumm > 0){ result.append(part).append(" "); numbersSumm--; } }else{ int remainder = number % numbersSumm; ArrayList numbers = new ArrayList<>(); while (numbersSumm > 0){ if(remainder > 0){ numbers.add(part+1); remainder--; }else{ numbers.add(part); } numbersSumm--; } Collections.sort(numbers); for(Integer line : numbers){ result.append(line).append(" "); } } PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: srange_lottery/README.md ================================================

Странная лотерея (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

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

После продолжительных минут радости ребята бросились узнавать сумму выигрыша, но как оказалось, узнать это не так уж просто. Дело в том, что сумма выигрыша отчасти определяется самим владельцем или владельцами (если их несколько) следующим образом. На обратной стороне билета есть определенная секция, стерев слой защитного покрытия, можно увидеть целое положительное число N. После чего, каждый из владельцев билета должен зачеркнуть ровно по одной цифре данного числа N, полученное число и является суммой выигрыша.

Ниже приведен пример с N равным 995051.

Максимальное число, которое может быть получено из данного N посредством вычеркивания двух цифр является 9955. Помогите Пете и Вове в этой непростой, но очень актуальной для них задачей.

Формат ввода

В единственной строке входного файла input.txt находится число N (100 ≤ N < 10250). Число не содержит лидирующих нулей. Строка входного файла заканчивается переводом строки и не содержит символов отличных от "0"-"9".

Формат вывода

В выходной файл output.txt выведите одно число – максимальное значение, которое может быть получено из N посредством вычеркивания из него ровно двух цифр.

Примеры

Ввод Вывод
102 2
995051 9955
================================================ FILE: srange_lottery/SrangeLottery.java ================================================ package srange_lottery; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.math.BigInteger; import java.util.Scanner; public class SrangeLottery { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String number = sc.nextLine(); char[] ch = number.toCharArray(); BigInteger min = new BigInteger("0"); for(int i = 1; i < ch.length; i++){ if(i + 1 <= number.length()){ String strOne = number.substring(0, i) + number.substring(i+1); if(!strOne.substring(0,1).equals("0")){ for(int j = 0; j < strOne.length(); j++){ String strTwo = (strOne.substring(0, j) + strOne.substring(j+1)); if(!strTwo.substring(0,1).equals("0")){ BigInteger str = new BigInteger(strTwo); if(min.compareTo(str) < 0){ min = str; } } } } } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(min)); out.close(); } } ================================================ FILE: stairs/README.md ================================================

Лестница (21%)

Время: 1 сек.
Память: 16 Мб
Сложность: 21%

Мальчик Петя строит из кубиков лестницу. Лестница представляет собой несколько строящихся рядом башенок из кубиков, каждая из которых ровно на один кубик выше предыдущей. Требуется по имеющемуся у мальчика Пети числу кубиков определить, какой в кубиках будет высота последней ступеньки.

Формат ввода

Входной файл input.txt содержит число К – количество кубиков у мальчика Пети (1 ≤ K ≤ 106).

Формат вывода

В выходной файл output.txt выведите количество кубиков в последней ступеньке у максимально высокой лестницы, которую можно построить из K кубиков.

Примеры

Ввод Вывод
1 1
4 2
6 3
================================================ FILE: stairs/Stairs.java ================================================ package stairs; import java.util.*; import java.io.*; public class Stairs { private static int cubeCount; private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); cubeCount = sc.nextInt(); } public static void main(String[] argv) throws IOException{ getData(); int result = (int) (Math.abs(1 - Math.sqrt(1 + 4 * (2 * cubeCount))) / 2); PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(result)); pw.close(); } } ================================================ FILE: state_machine/README.md ================================================

Конечные автоматы (11%)

Время: 1 сек.
Память: 16 Мб
Сложность: 11%

Однажды известный профессор обнаружил описания k конечных автоматов. По его мнению, нетривиальность конечного автомата, имеющего n состояний и m переходов, можно описать целым числом d = 19m + (n + 239)*(n + 366) / 2 . Чем больше d, тем больший интерес для науки представляет изучение его свойств.

Помогите профессору вычислить нетривиальность имеющихся у него автоматов.

Формат ввода

Первая строка входного файла input.txt содержит целое число k (1 ≤ k ≤ 10000) – количество конечных автоматов. Следующие k строк содержат по два целых числа ni (0 ≤ ni ≤ 1000) и mi (0 ≤ mi ≤ 26ni2) – число состояний и переходов i-го автомата.

Формат вывода

Выходной файл output.txt должен состоять из k строк. На i-й строке выходного файла выведите одно число – нетривиальность i-го автомата.

Примеры

Ввод Вывод
4
2 0
13 20
5 23
18 6		 44344
48134
45699
49458
2
15 20
1000 26000		 48767
1340237
================================================ FILE: state_machine/stateMachine.java ================================================ package state_machine; import java.io.*; import java.text.MessageFormat; import java.util.*; public class stateMachine { private static String resultOut; public static void main(String[] args) throws IOException { ArrayList number = new ArrayList<>(); // Для данных из файла ArrayList result = new ArrayList<>(); // Для данных, полученных в результате вычислений int resultInt; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); while (sc.hasNextLine()){ str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ number.add(st.nextToken()); // Записать все элементы в коллекцию } } int j = 1; for(int i = 0; i < number.size(); i++){ if(i != 0 && j < number.size()){ int n = Integer.valueOf(number.get(j)); int m = Integer.valueOf(number.get(j + 1)); j = j + 2; resultInt = 19* m + (n + 239)*(n + 366) / 2; // Формула из задачи result.add(String.valueOf(resultInt)); } } for(String line : result) if (resultOut != null) { resultOut = String.format("%s%s", resultOut, MessageFormat.format("{0}\n", line)); // Записываем результат со второй строки } else { resultOut = line + "\n"; // Записываем результат в 1 строку } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(resultOut); fileOut.close(); } } ================================================ FILE: statistics/README.md ================================================

Статистика (15%)

Время: 1 сек.
Память: 16 Мб
Сложность: 15%

Вася не любит английский язык, но каждый раз старается получить хотя бы четверку за четверть, чтобы оставаться ударником. В текущей четверти Вася заметил следующую закономерность: по нечетным дням месяца он получал тройки, а по четным – четверки. Так же он помнит, в какие дни он получал эти оценки. Поэтому он выписал на бумажке все эти дни для того, чтобы оценить, сколько у него троек и сколько четверок. Помогите Васе это сделать, расположив четные и нечетные числа в разных строчках. Вася может рассчитывать на оценку 4, если четверок не меньше, чем троек.

Формат ввода

В первой строке входного файла input.txt записано единственное число N – количество элементов целочисленного массива (1 ≤ N ≤ 100). Вторая строка содержит N чисел, представляющих заданный массив. Каждый элемент массива – натуральное число от 1 до 31. Все элементы массива разделены пробелом.

Формат вывода

В первую строку выходного файла output.txt нужно вывести числа, которые соответствуют дням месяцев, в которые Вася получил тройки, а во второй строке соответственно расположить числа месяца, в которые Вася получил четверки. В третьей строке нужно вывести «YES», если Вася может рассчитывать на четверку и «NO» в противном случае. В каждой строчке числа следует выводить в том же порядке, в котором они идут во входных данных. При выводе, числа отделяются пробелом.

Примеры

Ввод Вывод
5
4 16 19 31 2		 19 31
4 16 2
YES
8
29 4 7 12 15 17 24 1		 29 7 15 17 1
4 12 24
NO
================================================ FILE: statistics/Statistics.java ================================================ package statistics; import java.io.*; import java.util.*; public class Statistics { private static ArrayList data = new ArrayList<>(); // Данные построчно private static ArrayList day = new ArrayList<>(); // Все дни недели private static ArrayList even = new ArrayList<>(); // Четные дни private static ArrayList odd = new ArrayList<>(); // Нечетные дни private static void getData() throws IOException{ // Получаем данные FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ data.add(sc.nextLine()); } StringTokenizer st = new StringTokenizer(data.get(1), " "); while (st.hasMoreTokens()){ day.add(Integer.valueOf(st.nextToken())); } } private static void evenOdd(){ // Определяем четное или нечетное число, записываем в соответствующую коллекцию for(Integer line : day){ if(line % 2 == 0){ even.add(line); }else{ odd.add(line); } } } public static void main(String[] args) throws IOException { getData(); evenOdd(); // Преобразовываем данные для вывода в файл String four = (odd.size() <= even.size()) ? "YES" : "NO"; String oddString = String.valueOf(odd).replaceAll(", ", " ").replaceAll("^\\[|]$", ""); String evenString = String.valueOf(even).replaceAll(", ", " ").replaceAll("^\\[|]$", ""); String result = oddString + "\n" + evenString + "\n" + four; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: step_happiness/README.md ================================================

В одном шаге от счастья (16%)

Время: 1 сек.
Память: 16 Мб
Сложность: 16%

Вова купил билет в трамвае 13-го маршрута и сразу посчитал суммы первых трёх цифр и последних трёх цифр номера билета (номер у билета шестизначный). Оказалось, что суммы отличаются ровно на единицу. «Я в одном шаге от счастья», — подумал Вова, — «или предыдущий или следующий билет точно счастливый». Прав ли он?

Формат ввода

Входной файл input.txt содержит в первой строке число K – количество тестов. В следующих K строках записаны номера билетов. Количество тестов не больше 10. Номер состоит ровно из шести цифр, среди которых могут быть и нули. Гарантируется, что Вова умеет считать, то есть суммы первых трех цифр и последних трех цифр отличаются ровно на единицу.

Формат вывода

Выходной файл output.txt должен содержать K строк, в каждой из которых для соответствующего теста следует указать "Yes", если Вова прав, и "No", если нет.

Примеры

Ввод Вывод
3
715068
445219
012200		 Yes
No
Yes
================================================ FILE: step_happiness/StepHappiness.java ================================================ package step_happiness; import java.io.*; import java.util.*; public class StepHappiness { private static int numberCount; private static String number; private static int numberLeftNext; private static int numberLeftPrev; private static int numberRightNext; private static int numberRightPrev; private static void numberTicketPlus(String line){ // Проверка следующего билета numberCount = Integer.valueOf(line) + 1; number = String.valueOf(numberCount); number = (number.length() == 1) ? "00000"+number: // Дописываем нули вперед (number.length() == 2) ? "0000" + number: (number.length() == 3) ? "000" + number: (number.length() == 4) ? "00" + number: (number.length() == 5) ? "0" + number : number; char[] ch = number.toCharArray(); numberLeftNext = (ch[0] - '0') + (ch[1] - '0') + (ch[2] - '0'); numberRightNext = (ch[3] - '0') + (ch[4] - '0') + (ch[5] - '0'); } private static void numberTicketMinus(String line){ // Проверка предыдущего билета numberCount = Integer.valueOf(line) - 1; number = String.valueOf(numberCount); number = (number.length() == 1) ? "00000"+number: // Дописываем нули вперед (number.length() == 2) ? "0000" + number: (number.length() == 3) ? "000" + number: (number.length() == 4) ? "00" + number: (number.length() == 5) ? "0" + number : number; char[] ch2 = number.toCharArray(); numberLeftPrev = (ch2[0] - '0') + (ch2[1] - '0') + (ch2[2] - '0'); numberRightPrev = (ch2[3] - '0') + (ch2[4] - '0') + (ch2[5] - '0'); } public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); ArrayList happiniessTicket = new ArrayList<>(); String result; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ data.add(sc.nextLine()); } for(String line : data){ numberCount = line.length(); // Определить длину данных в коллекции if(numberCount == 6){ // Если это номер билета numberTicketPlus(line); numberTicketMinus(line); if (numberLeftNext == numberRightNext || numberLeftPrev == numberRightPrev) { // Если предыдущий или следующий билет счастливый happiniessTicket.add("Yes"); } else { happiniessTicket.add("No"); } } } result = String.valueOf(happiniessTicket).replaceAll(", ", "\n").replaceAll("^\\[|]$", ""); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: strawberry/README.md ================================================

Сбор земляники (6%)

Время: 1 сек.
Память: 16 Мб
Сложность: 6%

Маша и Миша собирали землянику. Маше удалось сорвать X ягод, а Мише – Y ягод. Поскольку ягода была очень вкусной, то ребята могли какую то часть ягод съесть. По нашим подсчетам вместе они съели Z ягод.

Требуется определить: сколько ягод ребята собрали в результате, при этом следует проверить, не ошиблись ли мы в расчетах, подсчитывая количество съеденных ягод (их не должно было получиться больше, чем сорванных ягод).

Формат ввода

Входной файл input.txt содержит три натуральных числа X, Y и Z, не превышающих 1000. Все числа расположены в первой строке файла и разделены пробелом.

Формат вывода

В выходной файл output.txt выведите количество собранных ягод, если наши подсчеты оказались правдоподобными, либо слово «Impossible» в противном случае.

Примеры

Ввод Вывод
3 2 1 4
12 13 5 20
2 5 9 Impossible
================================================ FILE: strawberry/Strawberry.java ================================================ package strawberry; import java.util.*; import java.io.*; public class Strawberry { public static void main(String[] args) throws IOException { ArrayList berry = new ArrayList<>(); int numberBerry; String berryOut; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while(st.hasMoreTokens()){ berry.add(Integer.valueOf(st.nextToken())); } numberBerry = berry.get(0) + berry.get(1) - berry.get(2); berryOut = (numberBerry >= 0) ? String.valueOf(numberBerry) : "Impossible"; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(berryOut); fileOut.close(); } } ================================================ FILE: string_book/README.md ================================================

Строки в книге (13%)

Время: 1 сек.
Память: 16 Мб
Сложность: 13%

В книге на одной странице помещается K строк. Таким образом, на 1-й странице печатаются строки с 1-й по K-ю, на второй — с (K+1)-й по (2∙K)-ю и т.д. Напишите программу, которая по номеру строки в тексте определяет номер страницы, на которой будет напечатана эта строка, и порядковый номер этой строки на странице.

Формат ввода

Входной файл input.txt содержит число K – количество строк, которое печатается на странице, и число N – номер строки (1 ≤ K ≤ 200, 1 ≤ N ≤ 20000).

Формат вывода

В выходной файл output.txt выведите два числа – номер страницы, на которой будет напечатана эта строка и номер строки на странице.

Примеры

Ввод Вывод
50 1 1 1
20 25 2 5
15 43 3 13
================================================ FILE: string_book/StringBook.java ================================================ package string_book; import java.io.*; import java.util.*; public class StringBook { public static void main(String[] args) throws IOException { ArrayList numberIn = new ArrayList<>(); ArrayList numberOut = new ArrayList<>(); StringBuilder result = null; String str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ numberIn.add(Integer.valueOf(st.nextToken())); } if(numberIn.get(1) % numberIn.get(0) != 0){ // Если это не последняя строка на странице numberOut.add(numberIn.get(1) / numberIn.get(0) + 1); // Расчет страницы numberOut.add(numberIn.get(1) % numberIn.get(0)); // Расчет строки }else{ // Если последняя numberOut.add(numberIn.get(1) / numberIn.get(0)); // Расчет страницы numberOut.add(numberIn.get(1) / numberOut.get(0)); // Расчет строки } for (Integer aNumberOut : numberOut) { if (result != null) { result.append(String.valueOf(aNumberOut)); // Вторая цифра } else { result = new StringBuilder(String.valueOf(aNumberOut) + " "); // Пробел после 1 цифры } } System.out.println(result); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: subarray_array/README.md ================================================

Подмассив массива (15%)

Время: 1 сек.
Память: 16 Мб
Сложность: 15%

Пусть задан массив целых чисел а1, а2, ..., аn. Назовем его подмассивом f(i,j) массив, составленный из чисел массива аi, ai+1,..., aj-1, aj. Напишите программу, которая будет выводить подмассивы массива a.

Формат ввода

Первая строка входного файла input.txt содержит число n (1 ≤ n ≤ 1000) - количество элементов в массиве а. Во второй строке содержатся числа a1, a2, … , аn разделенные пробелом. Все аi находятся в диапазоне от -231 до 231 - 1. В третьей строке находится m (1 ≤ m ≤ 100) — количество подмассивов, которые необходимо вывести. Следующие m строк содержат пары чисел ik, jk (1 ≤ ik ≤ jk ≤ n).

Формат вывода

В выходной файл output.txt для каждой пары (ik,jk) в отдельной строке выведите подмассив f(ik,jk).

Примеры

Ввод Вывод
6
1 2 3 4 5 6
5
1 1
2 6
3 4
5 6
2 4		 1
2 3 4 5 6
3 4
5 6
2 3 4
================================================ FILE: subarray_array/SubarrayArray.java ================================================ package subarray_array; import java.io.*; import java.util.*; public class SubarrayArray { private static ArrayList data = new ArrayList<>(); // Исходные данные private static ArrayList arrMain = new ArrayList<>(); // Главный массив, из которого получаем подмассивы private static ArrayList arrSub = new ArrayList<>(); // Начальные и конечные элементы подмассивов private static ArrayList arrSubOut = new ArrayList<>(); // Коллекция со всеми подмассивами private static ArrayList arrSubOutBuild = new ArrayList<>(); // Коллекция для сборки подмассива private static void getData() throws IOException { // Получение данных из файла и предварительная обработка FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ data.add(sc.nextLine()); } StringTokenizer st = new StringTokenizer(data.get(1), " "); while (st.hasMoreTokens()){ arrMain.add(st.nextToken()); } for(int i = 3; i < data.size(); i++){ StringTokenizer add = new StringTokenizer(data.get(i), " "); while (add.hasMoreTokens()){ arrSub.add(add.nextToken()); } } } private static void buildSubArr(){ // Формирование подмассивов на основе данных из файла for(int j = 0; j < arrSub.size(); j++){ if(j+1 < arrSub.size()){ String start = arrSub.get(j); // Начало подмассива String finish = arrSub.get(j+1); // Конец подмассива if(!start.equals(finish)){ // Если начало и конец подмассива не равны for (int i = 0; i < arrMain.size(); i++){ if(arrMain.get(i).equals(start) && arrSubOutBuild.isEmpty()){ // Если элемент совпадает с началом и при этом массив не пустой while (!arrMain.get(i).equals(finish)){ if(i == 0){ // Добавляем 1 символ подмассива arrSubOutBuild.add(arrMain.get(i)); }else if(!arrMain.get(i).equals(arrMain.get(i-1))){ // Проверяем остальные символы массива на одинаковость arrSubOutBuild.add(arrMain.get(i)); } i++; if(i == arrMain.size()){ // Если индекс массива больше длины массива break; } } arrSubOutBuild.add(finish); } } arrSubOut.add(String.valueOf(arrSubOutBuild).replaceAll(",", "").replaceAll("^\\[|]$", "")); // Заменяем запятые на пробелы, убираем лишнее arrSubOutBuild.clear(); }else{ arrSubOut.add(start); } } j++; } } private static void removeSameElements(){ // Удаление одинаковых подмассивов for(int i = 0; i < arrSubOut.size(); i++){ // Удаление одинаковых подмассивов при выводе конечного ответа String compare = arrSubOut.get(i); int j; for(j = i + 1; j < arrSubOut.size(); j++){ if(compare.equals(arrSubOut.get(j))){ arrSubOut.remove(j); j--; } } } } public static void main(String[] args) throws IOException { getData(); buildSubArr(); removeSameElements(); String result = String.valueOf(arrSubOut).replaceAll(", ", "\n").replaceAll("^\\[|]$", ""); // Формирование строки с конечным результатом FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); // Выавод результата fileOut.close(); } } ================================================ FILE: substrings_identical_letters/README.md ================================================

Подстроки из одинаковых букв (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

В заданной строке, состоящей из малых английских букв, необходимо найти пару самых длинных подстрок, состоящих из одних и тех же букв (возможно, в разном порядке). Например, в строке twotwow это будут подстроки wotwo и otwow.

Формат ввода

Входной файл INPUT.TXT содержит исходную строку, длиной от 1 до 100 символов.

Формат вывода

Выходной файл OUTPUT.TXT должен содержать единственное число – длину подстрок в максимальной паре, или 0, если таких подстрок в строке нет.

Примеры

Ввод Вывод
abcde 0
abcdea 5
================================================ FILE: substrings_identical_letters/SubstringsIdenticalLetters.java ================================================ package substrings_identical_letters; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class SubstringsIdenticalLetters { public static void main(String[] args) throws IOException { int result = 0; String line = new Scanner(new FileReader("input.txt")).nextLine(); char[] chars = line.toCharArray(); for (char symbol : chars) { if (line.indexOf(symbol) != line.lastIndexOf(symbol)) { int diffs = line.lastIndexOf(symbol) - line.indexOf(symbol); if (diffs > result) { result = diffs; } } } PrintWriter out = new PrintWriter(System.out); out.println(result); out.flush(); } } ================================================ FILE: sudoku/README.md ================================================

Судоку (27%)

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Судоку размера n называется квадрат со стороной n2, разделенный на n2 средних квадратов со стороной n, каждый из которых разделен на n2 маленьких квадратов. В каждом маленьком квадрате записано число от 1 до n2.

Судоку называется правильным, если в каждом столбце, каждой строке и каждом среднем квадрате встречаются все числа от 1 до n2.

Недавно Вася нарисовал Судоку размера n. Ваша задача – помочь ему определить правильный ли он.

Формат ввода

В первой строке входного файла input.txt содержится число n (1 ≤ n ≤ 10). В следующих n2 строчках содержится по n2 чисел, задающих нарисованный Васей Судоку.

Все числа во входном файле натуральные и не превосходят 100 по модулю.

Формат вывода

Если Судоку правильный, то выведите в выходной файл output.txt слово «Correct», иначе выведите «Incorrect».

Примеры

Ввод Вывод
3
1 3 2 5 4 6 9 8 7
4 6 5 8 7 9 3 2 1
7 9 8 2 1 3 6 5 4
9 2 1 4 3 5 8 7 6
3 5 4 7 6 8 2 1 9
6 8 7 1 9 2 5 4 3
5 7 6 9 8 1 4 3 2
2 4 3 6 5 7 1 9 8
8 1 9 3 2 4 7 6 5		 Correct
1 10 Incorrect
================================================ FILE: sudoku/Sudoku.java ================================================ package sudoku; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class Sudoku { private static boolean differentNumbers(Map> map, int countSymbols){ for(int i : map.keySet()){ if(map.get(i).size() != countSymbols){ return false; }else { int index = 1; for(int j : map.get(i)){ if(j != index){ return false; } index++; } } } return true; } private static Set getSet(Map> square, int symbol, int key){ Set set; if(square.containsKey(key)){ set = square.get(key); set.add(symbol); }else { set = new HashSet<>(); set.add(symbol); } return set; } private static boolean correctSquare(int n, int[][] fields, int countSymbols){ Map> square = new HashMap<>(); for(int i = 0; i < n*n; i++){ for(int j = 0; j < n*n; j++){ int squareNumber = (i/n)*10 + j/n; int symbol = fields[i][j]; square.put(squareNumber, getSet(square, symbol, squareNumber)); } } return differentNumbers(square, countSymbols); } public static void main(String[] args) throws IOException { boolean isCorrect = true; int row = -1; int column = 0; int n = 0; int[][] fields = new int[0][]; Map check = new HashMap<>(); Map> checkColumn = new TreeMap<>(); int sum = 0; Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()){ if(row == -1){ n = Integer.valueOf(sc.nextLine()); fields = new int[n*n][n*n]; for(int i = 1; i <= n*n; i++){ check.put(i, false); sum += i; } }else { StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); column = 0; Map checkRowCopy = new HashMap<>(check); while (st.hasMoreTokens()){ int columnVal = Integer.valueOf(st.nextToken()); if(checkRowCopy.containsKey(columnVal)){ if(checkRowCopy.get(columnVal)){ isCorrect = false; break; }else { checkRowCopy.put(columnVal, true); } }else { isCorrect = false; break; } fields[row][column] = columnVal; column++; checkColumn.put(column, getSet(checkColumn, columnVal, column)); } } row++; } if(isCorrect){ if(n*n == row && n*n == column){ isCorrect = correctSquare(n, fields, check.size()); }else isCorrect = false; } if(isCorrect){ isCorrect = differentNumbers(checkColumn, check.size()); } String result = isCorrect ? "Correct" : "Incorrect"; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: sum/README.md ================================================

Сумма(19%)

Время: 1 сек.
Память: 16 Мб
Сложность: 19%

Требуется посчитать сумму целых чисел, расположенных между числами 1 и N включительно.

Формат ввода

В единственной строке входного файла input.txt записано единственное целое число N, не превышающее по абсолютной величине 104.

Формат вывода

В единственную строку выходного файла output.txt нужно вывести одно целое число — сумму чисел, расположенных между 1 и N включительно.

Примеры

Ввод Вывод
5 15
================================================ FILE: sum/Sum.java ================================================ package sum; import java.util.*; import java.io.*; public class Sum { private static int data; private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); data = sc.nextInt(); } public static void main(String[] argv) throws IOException{ getData(); int sum = 0; if(data > 0){ for(int i = 0; i <= data; i++){ sum += i; } }else{ for(int i = 1; i >= data; i--){ sum += i; } } PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(sum)); pw.close(); } } ================================================ FILE: sum_max_min/README.md ================================================

Сумма максимума и минимума (26%)

Время: 1 сек.
Память: 16 Мб
Сложность: 26%

Задана последовательность целых чисел. Числа нумеруются по порядку следования, начиная с единицы.

Требуется написать программу, которая найдет сумму максимума из чисел с четными номерами и минимума из чисел с нечетными номерами – max{a2, a4, …}+min{a1, a3, …}.

Формат ввода

Входной текстовый файл input.txt содержит в единственной строке последовательность от 2 до 2×105 целых чисел, которые по модулю не превышают 10000.

Формат вывода

Выходной текстовый файл output.txt должен содержать одно целое число - сумму максимума из чисел с четными номерами и минимума из чисел с нечетными номерами.

Примеры

Ввод Вывод
1 2 3
1 -2 3 -4 5 -1
================================================ FILE: sum_max_min/SumMaxMin.java ================================================ package sum_max_min; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class SumMaxMin { public static void main(String[] args) throws IOException { ArrayList allNumeric = new ArrayList<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ allNumeric.add(Integer.valueOf(st.nextToken())); } int min = 0; int max = 0; for(int i = 0; i < allNumeric.size(); i++){ if(i == 0){ min = allNumeric.get(i); }else if(i == 1){ max = allNumeric.get(i); }else { if(i % 2 == 0){ min = (allNumeric.get(i) < min) ? allNumeric.get(i) : min ; }else { max = (allNumeric.get(i) > max) ? allNumeric.get(i) : max; } } } int sum = min + max; FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(sum)); out.close(); } } ================================================ FILE: sum_n_digit_numbers/README.md ================================================

Сумма n-значных чисел (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

По заданному n найти сумму всех n-значных чисел.

Формат ввода

В единственной строке входного файла INPUT.TXT записано одно натуральное число n (1 ≤ n ≤ 100).

Формат вывода

В единственную строку выходного файла OUTPUT.TXT нужно вывести все цифры суммы всех n-значных чисел.

Примеры

Ввод Вывод
1 45
2 4905
================================================ FILE: sum_n_digit_numbers/SumNDigitNumbers.java ================================================ package sum_n_digit_numbers; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class SumNDigitNumbers { public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); Scanner sc = new Scanner(new FileReader("input.txt")); int n = sc.nextInt(); if (n == 1) { out.println(45); } else if (n == 2) { out.println(4905); } else { out.print(494); int x = n-2; for (int i = 0; i < x-1; i++) { out.print(9); } out.print(55); for (int i = 0; i < x; i++) { out.print(0); } } out.flush(); } } ================================================ FILE: symmetry/README.md ================================================

Симметрия (19%)

Время: 1 сек.
Память: 16 Мб
Сложность: 19%

Многие из вас, вероятно, знакомы с понятием симметрии относительно прямой. Пусть на плоскости расположена прямая L и точка A. Точка B называется симметричной точке A относительно прямой L, если отрезок АВ перпендикулярен прямой L и делится пополам точкой пересечения с ней. В частности, если точка А лежит на прямой L, то точка B совпадает с точкой А.

Задана прямая L, параллельная одной из осей координат, и точка А. Найдите точку В, симметричную А относительно L.

Формат ввода

Первая строка входного файла input.txt содержит 4 числа: x1, y1, x2, y2 – координаты двух различных точек, через которые проходит прямая L. Вторая строка входного файла содержит 2 числа xA и yA – координаты точки А. Все числа во входном файле целые и не превосходят 108 по модулю.

Формат вывода

В выходной файл output.txt выведите числа xB и yB – координаты точки B.

Примеры

Ввод Вывод
0 0 0 1
10 10		 -10 10
0 0 1 0
10 101		 10 -10
================================================ FILE: symmetry/Symmetry.java ================================================ package symmetry; import java.util.*; import java.io.*; public class Symmetry { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Long.valueOf(st.nextToken())); } } } public static void main(String[] argv) throws IOException{ getData(); long x, y; if(data.get(0).equals(data.get(2))){ // Если прямая параллельна y x = data.get(0) + (data.get(2) - data.get(4)); y = data.get(5); }else{ // Если прямая параллельна x x = data.get(4); y = data.get(1) + (data.get(3) - data.get(5)); } String result = x + " " + y; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: task_of_josephus/README.md ================================================

Задача Иосифа Флавия (29%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 29%

Существует легенда, что Иосиф Флавий - известный историк первого века - выжил и стал известным благодаря математической одаренности. В ходе иудейской войны он в составе отряда из 41 иудейского воина был загнан римлянами в пещеру. Предпочитая самоубийство плену, воины решили выстроиться в круг и последовательно убивать каждого третьего из живых до тех пор, пока не останется ни одного человека. Однако Иосиф наряду с одним из своих единомышленников счел подобный конец бессмысленным - он быстро вычислил спасительные места в порочном круге, на которые поставил себя и своего товарища. И лишь поэтому мы знаем его историю…

В нашем варианте мы начнем с того, что выстроим в круг N человек, пронумерованных числами от 1 до N, и будем исключать каждого k-ого до тех пор, пока не уцелеет только один человек.

Например, если N=10, K=3, то сначала умрет 3-й, потом 6-й, затем 9-й, затем 2-й, затем 7-й, потом 1-й, потом 8-й, за ним - 5-й, и потом 10-й. Таким образом, уцелеет 4-й.

Требуется написать программу, которая по заданным N и K будет определять номер уцелевшего человека.

Формат ввода

Входной файл input.txt содержит два натуральных числа N и K. Ограничения: N ≤ 500, K ≤ 100.

Формат вывода

В выходной файл output.txt нужно вывести номер уцелевшего человека.

Примеры

Ввод Вывод
10 3 4
================================================ FILE: task_of_josephus/TaskOfJosephus.java ================================================ package task_of_josephus; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class TaskOfJosephus { public static void main(String[] args) throws IOException { String[] data = new Scanner(new FileReader("input.txt")).nextLine().split(" "); int n = Integer.parseInt(data[0]); int k = Integer.parseInt(data[1]); ArrayList items = new ArrayList<>(); for (int index = 0; index < n; index++) { items.add(index + 1); } int index = 1; int step = 1; while (items.size() > 1) { if (index == k) { items.remove(step - 1); index = 0; step--; } if (step == items.size()) { step = 0; } index++; step++; } PrintWriter out = new PrintWriter(System.out); out.println(items.get(0)); out.flush(); } } ================================================ FILE: tax/README.md ================================================

Налоги (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

В некотором государстве действует N фирм, конкурирующих между собой. У каждой фирмы есть некоторая прибыль в год, равная V[i] американских рублей. У царя есть любимые фирмы, а есть нелюбимые. Соответственно, налог для всех фирм разный и назначается царем в индивидуальном порядке. Налог на i-ую фирму равен p[i] процентов.

Собиратели статистики решили посчитать, с какой фирмы в государственную казну идет наибольший доход (в казну идут все налоги). К сожалению, они не учили в детстве ни математику, ни информатику (так что учитесь, дети!), и их задача резко осложняется.

Помогите им в этой нелегкой задаче.

Формат ввода

Во входном файле input.txt сначала записано число N - число фирм (0 < N ≤ 100). Далее идет N целых неотрицательных чисел, не превышающих 154 - доходы фирм, а затем еще N целых чисел от 0 до 100 - налоги фирм в процентах.

Формат вывода

В выходной файл output.txt выведите одно число - номер фирмы, от которой государство получает наибольший налог. Если таких фирм несколько, выведите фирму с наименьшим номером.

Примеры

Ввод Вывод
1
1
1		 1
2
1 2
3 2		 2
3
100 1 50
0 100 3		 3
================================================ FILE: tax/Tax.java ================================================ package tax; import java.util.*; import java.io.*; public class Tax { private static ArrayList dataAll = new ArrayList<>(); // Данные построчно private static ArrayList profit = new ArrayList<>(); // Прибыль private static ArrayList taxPercent = new ArrayList<>(); // Процент от прибыли private static ArrayList taxSumm = new ArrayList<>(); // Сумма налога private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ dataAll.add(sc.nextLine()); } for(int i = 0; i < dataAll.size(); i++){ if(i == 1){ StringTokenizer st = new StringTokenizer(dataAll.get(i), " "); while (st.hasMoreTokens()){ profit.add(Double.valueOf(st.nextToken())); } } if(i == 2){ StringTokenizer st = new StringTokenizer(dataAll.get(i), " "); while (st.hasMoreTokens()){ taxPercent.add(Double.valueOf(st.nextToken())); } } } } public static void main(String[] argv) throws IOException{ getData(); for(int j = 0; j < profit.size(); j++){ double tax = profit.get(j) * taxPercent.get(j) / 100.0; taxSumm.add(tax); } int numberOfFirm = 0; double maxTax = 0; for(int k = 0; k < taxSumm.size(); k++){ if(maxTax < taxSumm.get(k)){ maxTax = taxSumm.get(k); numberOfFirm = k; } } numberOfFirm++; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(numberOfFirm)); pw.close(); } } ================================================ FILE: tea/README.md ================================================

Кипячение чая (14%)

Время: 1 сек.
Память: 16 Мб
Сложность: 14%

В эту субботу у Васи день рождения и через 15 минут к нему придут гости. Ему срочно надо вскипятить чай, для того чтобы напоить им гостей. У Васи дома есть много литровых чайников (можно считать, что их бесконечное количество), а розетка всего одна. Т.к. вода кипятится очень долго, за 15 минут она успеет вскипятиться максимум один раз. Но Вася – мальчик не промах, он достал из кладовки N тройников, в i-том тройнике ai разъемов. Теперь Вася ломает голову: как ему соединить тройники и воткнуть эту систему в розетку, чтобы максимизировать количество чайников, которые он сможет поставить кипятить.

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

Формат ввода

В первой строке входного файла input.txt содержится число N (1 ≤ N ≤ 105) – количество тройников. Во второй строке через пробел перечислены числа ai (1 ≤ ai ≤ 1000, 1 ≤ i ≤ N) – информация о тройниках.

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
1
1		 1
3
2 5 4		 9
================================================ FILE: tea/Tea.java ================================================ package tea; import java.io.*; import java.util.*; public class Tea { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); // Входные данные ArrayList tee = new ArrayList<>(); // Тройники int maxKettleCount = 0; int result = 0; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ data.add(sc.nextLine()); } StringTokenizer st = new StringTokenizer(data.get(1), " "); while (st.hasMoreTokens()){ tee.add(Integer.valueOf(st.nextToken())); } for(Integer i : tee){ maxKettleCount = maxKettleCount + i; } tee.sort(Collections.reverseOrder()); if(Integer.valueOf(data.get(0)) == 1){ // Если тройник один result = maxKettleCount; }else { // Если тройников несколько for(Integer i : tee){ result += i - 1; } result = result + 1; } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: teleportation/README.md ================================================

Телепортация (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Вова попал на космическом корабле на бесконечную плоскую планету в точку с координатами (x1, y1). Вова, управляя кораблем, имеет возможность за одну секунду телепортироваться из точки (x, y) в одну из точек (x+C, y+C), (x+C, y-C), (x-C, y+C), (x-C, y-C), где C - произвольное натуральное число, которое можно изменять на каждом ходу.

Требуется написать программу, которая определит, через какое минимальное время Вове удастся достичь точки (x2, y2).

Формат ввода

Входной файл input.txt содержит в первой строке числа x1, y1, во второй – x2, y2. Все числа целые от нуля до 106. Точки (x1, y1) и (x2, y2) не совпадают.

Формат вывода

Выходной файл output.txt должен содержать одно число – минимальное время телепортации. Если такая телепортация невозможна, то вывести 0.

Примеры

Ввод Вывод
0 0
0 2		 2
================================================ FILE: teleportation/Teleportation.java ================================================ package teleportation; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class Teleportation { public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); Scanner sc = new Scanner(new FileReader("input.txt")); String[] start = sc.nextLine().split(" "); String[] finish = sc.nextLine().split(" "); int x1 = Integer.parseInt(start[0]); int y1 = Integer.parseInt(start[1]); int x2 = Integer.parseInt(finish[0]); int y2 = Integer.parseInt(finish[1]); // считаем ходы слона if (Math.abs(x2-x1) == Math.abs(y2-y1)) { out.println(1); } else if ((x1+y1) % 2 == (x2+y2) % 2) { out.println(2); } else { out.println(0); } out.flush(); } } ================================================ FILE: temporary_key/README.md ================================================

Временной ключ (20%)

Время: 1 сек.
Память: 16 Мб
Сложность: 20%

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

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

Знаменитая компания "Gold&Silver Soft" решилась на революционный шаг – было решено разработать принципиально новый способ динамической генерации активационного ключа. В данном алгоритме ключ зависит от времени и меняется каждую минуту, что существенно затрудняет взлом.

Будем считать, что активационным ключом является обычное целое положительное число. В данной версии алгоритма значение ключа на следующей минуте целиком и полностью зависит от значения ключа в текущий момент. Если в данный момент ключ равен N, то через минуту он будет равен N + S(N), где S(N) – это число, называемое контрольной суммой числа N и равняется количеству единиц в двоичной записи числа N. То есть если N = 6, то в следующую минуту значение ключа будет равно 8, если быть точнее, то N’ = N + S(N) = 6 + S(6) = 610 + S(1102) = 6 + 2 = 8.

Будем считать, что на данный момент времени значение ключа равно N, вашей задачей является вычислить значение ключа через одну минуту.

Формат ввода

В первой и единственной строке входного файла input.txt находится одно натуральное число – N (1 ≤ N ≤ 2×109).

Формат вывода

В выходной файл output.txt выведите одно число – значение активационного ключа на следующей минуте, учитывая, что на данный момент времени значение ключа равно N.

Примеры

Ввод Вывод
2 3
6 8
27 31
================================================ FILE: temporary_key/TemporaryKey.java ================================================ package temporary_key; import java.util.*; import java.io.*; public class TemporaryKey { private static int number; private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); number = Integer.valueOf(sc.nextLine()); } public static void main(String[] argv) throws IOException{ getData(); int n = number; // Исходное число int s = 0; // Добавочное число while (number > 0){ if(number % 2 == 1){ s++; } number = number / 2; } int newKey = n + s; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(String.valueOf(newKey)); pw.close(); } } ================================================ FILE: thaw/README.md ================================================

Оттепель (17%)

Время: 1 сек.
Память: 16 Мб
Сложность: 17%

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

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

Формат ввода

Во входном файле input.txt сначала записано число N – общее количество рассматриваемых дней (1 ≤ N ≤ 100). В следующей строке через пробел располагается N целых чисел, разделенных пробелами. Каждое число – среднесуточная температура в соответствующий день. Температуры – целые числа и лежат в диапазоне от –50 до 50.

Формат вывода

В выходной файл output.txt требуется вывести одно число – длину самой продолжительной оттепели, то есть наибольшее количество последовательных дней, на протяжении которых среднесуточная температура превышала 0 градусов. Если температура в каждый из дней была неположительной, выведите 0.

Примеры

Ввод Вывод
6
-20 30 -40 50 10 -10		 2
8
10 20 30 1 -10 1 2 3		 4
5
-10 0 -10 0 -10		 0
================================================ FILE: thaw/Thaw.java ================================================ package thaw; import java.util.*; import java.io.*; public class Thaw { private static ArrayList data = new ArrayList<>(); private static ArrayList temp = new ArrayList<>(); private static ArrayList tempPlus = new ArrayList<>(); private static void getData() throws IOException{ FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ data.add(sc.nextLine()); } StringTokenizer st = new StringTokenizer(data.get(1), " "); while (st.hasMoreTokens()){ temp.add(Integer.valueOf(st.nextToken())); } } public static void main(String[] argv) throws IOException{ getData(); int j = 0; for(Integer i : temp){ if(i > 0){ j++; }else{ tempPlus.add(j); j = 0; } } tempPlus.add(j); tempPlus.sort(Collections.reverseOrder()); String result = (!tempPlus.isEmpty()) ? String.valueOf(tempPlus.get(0)) : "0"; PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(result); pw.close(); } } ================================================ FILE: thimble/README.md ================================================

Напёрстки (15%)

Время: 1 сек.
Память: 16 Мб
Сложность: 15%

Шулер показывает следующий трюк. Он имеет три одинаковых наперстка. Под первый (левый) он кладет маленький шарик. Затем он очень быстро выполняет ряд перемещений наперстков, каждое из которых – это одно из трех перемещений - A, B, C:

  • A - обменять местами левый и центральный наперстки,
  • B - обменять местами правый и центральный наперстки,
  • C - обменять местами левый и правый наперстки.

Необходимо определить, под каким из наперстков окажется шарик после всех перемещений.

Формат ввода

В единственной строке входного файла input.txt записана строка длиной от 1 до 50 символов из множества {A, B, C} – последовательность перемещений.

Формат вывода

В единственную строку выходного файла output.txt нужно вывести номер наперстка, под которым окажется шарик после перемещений.

Примеры

Ввод Вывод
CBABCACCC 1
================================================ FILE: thimble/Thimble.java ================================================ package thimble; import java.io.*; import java.util.*; public class Thimble { private static ArrayList letter = new ArrayList<>(Arrays.asList(1,2,3)); // Порядковый номер наперстков private static int result = 0; // Переменная с результатом private static ArrayList actions = new ArrayList<>(); // Коллекция со всеми действиями private static void changeThimble(){ // Поменять наперстки местами for (String action : actions) { switch (action) { case "A": // Поменять левый и центральный // Промежуточная переменная int interim = letter.get(0); letter.set(0, letter.get(1)); letter.set(1, interim); break; case "B": // Поменять правый и центральный interim = letter.get(1); letter.set(1, letter.get(2)); letter.set(2, interim); break; default: // Поменять левый и правый interim = letter.get(0); letter.set(0, letter.get(2)); letter.set(2, interim); break; } } } private static void searchBall(){ // Ищем наперсток с шариком for(int i = 0; i < letter.size(); i++){ if(letter.get(i) == 1){ result = i+1; } } } public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); char[] ch = str.toCharArray(); for(char aCh : ch){ actions.add(String.valueOf(Character.valueOf(aCh))); } changeThimble(); searchBall(); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: three_fat_men/README.md ================================================

Три толстяка (7%)

Время: 1 сек.
Память: 16 Мб
Сложность: 7%

Три толстяка решили поспорить: кто из них самый тяжелый. После взвешивания оказалось, что их масса соответственно M1, M2 и M3 килограмм. Считается, что масса толстяка должна быть не менее 94 и не более 727 килограмм.

Помогите определить массу самого тяжелого из них, либо выяснить, что была допущена ошибка при взвешивании.

Формат ввода

Входной файл input.txt содержит три целых числа M1, M2 и M3, разделенные пробелом. Все числа целые и не превосходят 10 000 по абсолютной величине.

Формат вывода

В выходной файл output.txt выведите массу самого тяжелого толстяка в случае корректного взвешивания, либо слово «Error» в противном случае.

Примеры

Ввод Вывод
98 106 214 214
100 100 100 100
93 500 1000 Error
================================================ FILE: three_fat_men/threeFatMen.java ================================================ package three_fat_men; import java.io.*; import java.util.*; public class threeFatMen { public static void main(String[] args) throws IOException { ArrayList weight = new ArrayList<>(); boolean error = false; String out; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while(st.hasMoreTokens()){ weight.add(Integer.valueOf(st.nextToken())); } for (Integer aWeight : weight) { if (aWeight < 94 || aWeight > 727) { error = true; } } weight.sort(Collections.reverseOrder()); // Сортировка в обратном порядке out = (error) ? "Error" : String.valueOf(weight.get(0)); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(out); fileOut.close(); } } ================================================ FILE: time_sort/README.md ================================================

Сортировка времени (23%)

Время: 1 сек.
Память: 16 Мб
Сложность: 23%

Требуется выполнить сортировку временных моментов, заданных в часах, минутах и секундах.

Формат ввода

Во входном файле input.txt в первой строке записано число N (1 ≤ N ≤ 100), а в последующих N строках N моментов времени. Каждый момент времени задается 3 целыми числами - часы (от 0 до 23), минуты (от 0 до 59) и секунды (от 0 до 59).

Формат вывода

В выходной файл output.txt выведите моменты времени, упорядоченные в порядке неубывания без ведущих нулей.

Примеры

Ввод Вывод
4
10 20 30
7 30 00
23 59 59
13 30 30 		7 30 0
10 20 30
13 30 30
23 59 59
================================================ FILE: time_sort/TimeSort.java ================================================ package time_sort; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class TimeSort { private static ArrayList time = new ArrayList<>(); private static void getData() throws FileNotFoundException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ time.add(sc.nextLine()); } time.remove(0); for(int i = 0; i < time.size(); i++){ StringBuilder newTime = new StringBuilder(); StringTokenizer st = new StringTokenizer(time.get(i), " "); while (st.hasMoreTokens()){ String str = st.nextToken(); if (str.length() == 2){ newTime.append(str).append(" "); }else if(str.length() == 1){ newTime.append("0").append(str).append(" "); } } time.set(i, String.valueOf(newTime).trim()); } } private static void deleteZero(){ for(int i = 0; i < time.size(); i++){ StringBuilder strOut = new StringBuilder(); StringTokenizer st = new StringTokenizer(time.get(i), " "); while (st.hasMoreTokens()){ int number = Integer.valueOf(st.nextToken()); strOut.append(String.valueOf(number)).append(" "); } time.set(i, String.valueOf(strOut).trim()); } } public static void main(String[] args) throws IOException { getData(); Collections.sort(time); deleteZero(); StringBuilder result = new StringBuilder(); for (String line : time){ result.append(line).append("\n"); } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: timer/README.md ================================================

Таймер (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

Таймер - это часы, которые умеют подавать звуковой сигнал по прошествии некоторого периода времени. Напишите программу, которая определяет, когда должен быть подан звуковой сигнал.

Формат ввода

В первой строке входного файла INPUT.TXT записано текущее время в формате ЧЧ:ММ:СС (с ведущими нулями). При этом оно удовлетворяет ограничениям: ЧЧ - от 00 до 23, ММ и СС - от 00 до 60.

Во второй строке записан интервал времени, который должен быть измерен. Интервал записывается в формате Ч:М:С (где Ч, М и С - от 0 до 109, без ведущих нулей). Дополнительно если Ч=0 (или Ч=0 и М=0), то они могут быть опущены. Например, 100:60 на самом деле означает 100 минут 60 секунд, что то же самое, что 101:0 или 1:41:0. А 42 обозначает 42 секунды. 100:100:100 - 100 часов, 100 минут, 100 секунд, что то же самое, что 101:41:40.

Формат вывода

В выходной файл OUTPUT.TXT выведите в формате ЧЧ:ММ:СС время, во сколько прозвучит звуковой сигнал. При этом если сигнал прозвучит не в текущие сутки, то дальше должна следовать запись + <кол во > days. Например, если сигнал прозвучит на следующий день – то +1 days.

Примеры

Ввод Вывод
01:01:01
48:0:0		 01:01:01+2 days
01:01:01
58:119		 02:01:00
23:59:59
1		 00:00:00+1 days
================================================ FILE: timer/Timer.java ================================================ package timer; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class Timer { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] time = sc.nextLine().split(":"); String[] addTime = sc.nextLine().split(":"); int hour = Integer.parseInt(time[0]); int minute = Integer.parseInt(time[1]); int seconds = Integer.parseInt(time[2]); int addHour = 0; int addMinute = 0; int addSecond; int addDays = 0; if (addTime.length == 3) { addHour = Integer.parseInt(addTime[0]); addMinute = Integer.parseInt(addTime[1]); addSecond = Integer.parseInt(addTime[2]); } else if (addTime.length == 2) { addMinute = Integer.parseInt(addTime[0]); addSecond = Integer.parseInt(addTime[1]); } else { addSecond = Integer.parseInt(addTime[0]); } if (seconds == 60) { seconds = 59; addSecond += 1; } if (minute == 60) { minute = 59; addMinute += 1; } seconds += addSecond; minute += addMinute; hour += addHour; if (seconds > 59) { minute += seconds / 60; seconds %= 60; } if (minute > 59) { hour += minute / 60; minute %= 60; } if (hour > 23) { addDays = hour / 24; hour %= 24; } PrintWriter out = new PrintWriter(System.out); if (hour < 10) { out.print("0"); } out.print(hour + ":"); if (minute < 10) { out.print("0"); } out.print(minute + ":"); if (seconds < 10) { out.print("0"); } out.print(seconds); if (addDays > 0) { out.print("+" + addDays + " days"); } out.flush(); } } ================================================ FILE: topcoder/README.md ================================================

TopCoder (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Некоторые из вас, наверное, слышали о сайте http://www.topcoder.com, на котором часто проводятся различные соревнования по программированию.

В некоторых из них участникам предлагаются три задачи, каждая из которых оценивается в некоторое количество баллов. В зависимости от того, насколько долго участник решал задачу, количество полученных им за нее баллов уменьшается. Как и в большинстве других соревнований, выигрывает участник, набравший наибольшее число баллов. Участники, набравшие одинаковое число баллов, считаются выступившими одинаково и их порядок в таблице итоговых результатов не важен. Из-за некоторых особенностей этих соревнований для предотвращения жульничества участники разделены в группы по 20 человек, называемые комнатами.

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

Формат ввода

Первая строка входного файла input.txt содержит целое число n (1 ≤ n ≤ 100) - число комнат. Далее следуют n описаний итоговых результатов в комнатах.

Результаты в i-ой комнате заданы в следующем формате. Первая строка содержит целое число ni (1 ≤ ni ≤ 20)- количество участников в i-ой комнате. Следующие ni строк содержат информацию о выступлениях участников. j+1-ая строка описания результатов в i-ой комнате содержит информацию об участнике, занявшем в i-ой комнате j-ое место: разделенные одним пробелом вещественное число totalij (-5000 ≤ totalij ≤ 10000) и строку nameij - соответственно количество набранных участником баллов и его имя. Имя участника имеет длину от 1 до 25 и может содержать только буквы английского алфавита, цифры и символ подчеркивания. При этом первый символ имени не является цифрой. Все вещественные числа заданы с двумя знаками после десятичной точки.

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

Формат вывода

На первой строке выходного файла output.txt выведите N - суммарное число участников. На следующих N строках выведите информацию о выступлении участников. (k+1)-ая строка описания суммарных результатов должна содержать информацию об участнике, занявшем k-ое место: разделенные одним пробелом вещественное число totalk с двумя знаками после десятичной точки и строку namek - соответственно количество набранных участником баллов и его имя.

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

Примеры

Ввод Вывод
2
6
909.94 Savior
439.51 tywok
130.52 LimberG
0.00 BryanChen
0.00 angsa
-75.00 The_Hedgehog
5
867.15 Ying
448.12 natori
195.32 aubergineanode
0.00 shalinmangar
-25.00 Excilus		 11
909.94 Savior
867.15 Ying
448.12 natori
439.51 tywok
195.32 aubergineanode
130.52 LimberG
0.00 angsa
0.00 shalinmangar
0.00 BryanChen
-25.00 Excilus
-75.00 The_Hedgehog
================================================ FILE: topcoder/TopCoder.java ================================================ package topcoder; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class TopCoder { public static void main(String[] args) throws IOException { Map> data = new TreeMap<>(Collections.reverseOrder()); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()){ String line = sc.nextLine(); if(line.contains(" ")){ StringTokenizer st = new StringTokenizer(line, " "); float points = Float.valueOf(st.nextToken()); String name = st.nextToken(); if(data.containsKey(points)){ ArrayList arr = data.get(points); arr.add(name); data.put(points, arr); }else { data.put(points, new ArrayList<>(Collections.singletonList(name))); } } } int count = 0; StringBuilder rating = new StringBuilder(); for(Float points : data.keySet()){ String formattedDouble = String.format("%.2f", points).replaceAll(",", "."); Collections.sort(data.get(points)); for(String name : data.get(points)){ rating.append(formattedDouble).append(" ").append(name).append("\n"); count++; } } String result = String.valueOf(count) + "\n" + String.valueOf(rating); FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: tourist/README.md ================================================

Турист (22%)

Время: 1 сек.
Память: 16 Мб
Сложность: 22%

Гена собирается на туристический слет учеников своей школы. В своем классе он был назначен ответственным за палатки. У себя дома он нашел 3 палатки: первая из них весит a1 килограмм и вмещает b1 человек, вторая весит a2 килограмм и вмещает b2 человек, третья весит a3 килограмм и вмещает b3 человек.

В классе Гены K человек. Выясните, может ли он выбрать палатки так, чтобы в них все могли поместиться. При этом учитывайте, что выбранные палатки должны суммарно весить не более W килограмм.

Формат ввода

Первая строка входного файла input.txt содержит два целых числа: K и W (1 ≤ K ≤ 15, 1 ≤ W ≤ 30). Вторая строка содержит шесть целых чисел: a1, b1, a2, b2, a3, b3 (1 ≤ a1, a2, a3 ≤ 10, 1 ≤ b1, b2, b3 ≤ 15).

Формат вывода

В выходной файл output.txt выведите YES, если палатки указанным образом выбрать можно, и NO в противном случае./p>

Примеры

Ввод Вывод
10 10
5 5 6 6 4 5 		YES
10 10
5 5 6 6 7 7 		NO
================================================ FILE: tourist/Tourist.java ================================================ package tourist; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class Tourist { private static int studentCount = 0; private static int weightMax = 0; private static Map tents = new HashMap<>(); private static void getData() throws FileNotFoundException { Queue data = new ArrayDeque<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(st.nextToken()); } } weightMax = Integer.valueOf(Objects.requireNonNull(data.poll())); studentCount = Integer.valueOf(Objects.requireNonNull(data.poll())); tents.put(Integer.valueOf(Objects.requireNonNull(data.poll())), Integer.valueOf(Objects.requireNonNull(data.poll()))); tents.put(Integer.valueOf(Objects.requireNonNull(data.poll())), Integer.valueOf(Objects.requireNonNull(data.poll()))); tents.put(Integer.valueOf(Objects.requireNonNull(data.poll())), Integer.valueOf(Objects.requireNonNull(data.poll()))); } public static void main(String[] args) throws IOException { getData(); int fitStudentsAlready = 0; int weightTentsAlready = 0; boolean success = false; for(int key : tents.keySet()){ fitStudentsAlready += key; weightTentsAlready += tents.get(key); if (fitStudentsAlready <= studentCount && weightMax <= weightTentsAlready){ success = true; } } String result = (success) ? "YES" : "NO"; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: traffic_lights/README.md ================================================

Светофорчики (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

В подземелье M тоннелей и N перекрестков, каждый тоннель соединяет какие-то два перекрестка. Мышиный король решил поставить по светофору в каждом тоннеле перед каждым перекрестком. Напишите программу, которая посчитает, сколько светофоров должно быть установлено на каждом из перекрестков. Перекрестки пронумерованы числами от 1 до N.

Формат ввода

Во входном файле input.txt записано два числа N и M (0 < N ≤ 100, 0 ≤ M ≤ N*(N-1)/2). В следующих M строках записаны по два числа i и j (1 ≤ i,j ≤ N), которые означают, что перекрестки i и j соединены тоннелем. Можно считать, что любые два перекрестка соединены не более, чем одним тоннелем. Нет тоннелей от перекрестка i до него самого.

Формат вывода

В выходной файл output.txt вывести N чисел: k-ое число означает количество светофоров на k-ом перекрестке.

Примеры

Ввод Вывод
7 10
5 1
3 2
7 1
5 2
7 4
6 5
6 4
7 5
2 1
5 3		 3 3 2 2 5 2 3
================================================ FILE: traffic_lights/TrafficLights.java ================================================ package traffic_lights; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class TrafficLights { public static void main(String[] args) throws IOException { Map data = new TreeMap<>(); Scanner sc = new Scanner(new FileReader("input.txt")); int index = 0; int step = 1; while (sc.hasNextLine()){ StringTokenizer st = new StringTokenizer(sc.nextLine(), " "); while (st.hasMoreTokens()){ int number = Integer.valueOf(st.nextToken()); if(index > 1){ if(data.containsKey(number)){ int val = data.get(number) + step; data.put(number, val); }else { data.put(number, step); } } index++; } } StringBuilder result = new StringBuilder(); if(data.size() == 0){ result.append("0"); }else { for(int number : data.keySet()){ result.append(data.get(number)).append(" "); } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result).trim()); out.close(); } } ================================================ FILE: traps/README.md ================================================

Ловушки (24%)

Время: 1 сек.
Память: 16 Мб
Сложность: 24%

Далеко не все в Тентуре имеют право носить малиновые штаны, и конечно, не все владеют пепелацем с гравицапой, зато один предприимчивый чатланин поставил несколько ловушек, захватывающих отваливающиеся детали с пролетающих мимо инопланетных кораблей. Каждое утро он их обходит, в надежде, что рано или поздно из этих запчастей ему удастся собрать какое-нибудь транспортное средство. Путь свой чатланин планирует по карте, на которой аккуратно отмечены ловушки, отсчитывая начало координат от собственного дома. Начинается обход от дома, и в нем же и заканчивается.

Требуется определить, какое расстояние проходит чатланин за день.

Формат ввода

В первой строке входного файла input.txt находится натуральное число N – количество ловушек, установленных чатланином (N ≤ 10), далее следуют N строк формата «X Y», описывающих координаты ловушек в порядке их обхода (-10 ≤ X,Y ≤ 10; X,Y – целые числа).

Формат вывода

В выходной файл output.txt выведите общее расстояние, которое пройдет чатланин, обойдя все ловушки в приведенном порядке и вернувшись в начало координат от последней ловушки, с точностью до трех знаков после запятой.

Примеры

Ввод Вывод
1
1 0		 2.000
2
1 0
1 1		 3.414
3
1 0
1 1
0 1		 4.000
================================================ FILE: traps/Traps.java ================================================ package traps; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Scanner; import java.util.StringTokenizer; public class Traps { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); Scanner sc = new Scanner(new FileReader("input.txt")); while (sc.hasNextLine()){ data.add(sc.nextLine()); } data.remove(0); data.add("0 0"); int x = 0, y = 0, xprev = 0, yprev = 0; double way = 0; for(String line : data){ StringTokenizer st = new StringTokenizer(line, " "); while (st.hasMoreTokens()){ x = Integer.valueOf(st.nextToken()); y = Integer.valueOf(st.nextToken()); } way += Math.sqrt(Math.pow(x - xprev, 2) + Math.pow(y - yprev, 2)); xprev = x; yprev = y; } String result = String.format("%.3f", way).replaceAll(",", "."); FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: treasure/README.md ================================================

Клад (287%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Найти закопанный пиратами клад просто: всё, что для этого нужно – это карта. Как известно, пираты обычно рисуют карты от руки и описывают алгоритм действий. Большая часть таких действий просто сводится к прохождению какого-то количества шагов в одном из восьми направлений (1 – север, 2 – северо-восток, 3 – восток, 4 – юго-восток, 5 – юг, 6 – юго-запад, 7 – запад, 8 – северо-запад) (см. рис). Длина шага в любом направлении равна 1.

Путешествие по такому пути обычно является прекрасным способом посмотреть окрестности, однако в наше время постоянной спешки ни у кого нет времени на это. Поэтому кладоискатели хотят идти напрямую в точку, где зарыт клад. Например, вместо того, чтобы проходить три шага на север, один шаг на восток, один шаг на север, три шага на восток, два шага на юг и один шаг на запад, можно пройти напрямую, использовав около 3.6 шага (см. рисунок).

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

Формат ввода

Первая строка входного файла input.txt содержит число N – число указаний (1≤N≤40). Последующие N строк содержат сами указания – номер направления (целое число от 1 до 8) и количество шагов (целое число от 1 до 1000). Числа разделены пробелами.

Формат вывода

В выходной файл output.txt выведите координаты X и Y точки (два вещественных числа, разделённые пробелом), где зарыт клад, считая, что ось OX направлена на восток, а ось OY – на север. В начале кладоискатель должен стоять в начале координат. Координаты необходимо вывести с точностью 10-3.

Примеры

Ввод Вывод
6
1 3
3 1
1 1
3 3
5 2
7 1		 3.000 2.000
1
8 10		 -7.071 7.071
================================================ FILE: treasure/Treasure.java ================================================ package treasure; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.*; public class Treasure { private static double[] startUpdate(double[] start, double[] way, int steps){ double x = start[0] + way[0] * steps; double y = start[1] + way[1] * steps; return new double[]{x, y}; } public static void main(String[] args) throws IOException { double diagonal = Math.sqrt(2)/2; Map coordinate = new HashMap<>(); coordinate.put(1, new double[]{0, 1}); coordinate.put(2, new double[]{diagonal, diagonal}); coordinate.put(3, new double[]{1, 0}); coordinate.put(4, new double[]{diagonal, -diagonal}); coordinate.put(5, new double[]{0, -1}); coordinate.put(6, new double[]{-diagonal, -diagonal}); coordinate.put(7, new double[]{-1, 0}); coordinate.put(8, new double[]{-diagonal, diagonal}); double[] start = new double[]{0, 0}; Scanner sc = new Scanner(new FileReader("input.txt")); int index = 0; while (sc.hasNextLine()){ String line = sc.nextLine(); if(index != 0){ StringTokenizer st = new StringTokenizer(line, " "); while (st.hasMoreTokens()){ int direction = Integer.valueOf(st.nextToken()); int steps = Integer.valueOf(st.nextToken()); start = startUpdate(start, coordinate.get(direction), steps); } } index = 1; } String x = String.format("%.3f", start[0]).replaceAll(",", "."); String y = String.format("%.3f", start[1]).replaceAll(",", "."); FileWriter out = new FileWriter("output.txt"); out.write(x + " " + y); out.close(); } } ================================================ FILE: turn/README.md ================================================

Разворот (9%)

Время: 1 сек.
Память: 16 Мб
Сложность: 9%

Дано натуральное число N и последовательность из N элементов. Требуется вывести эту последовательность в обратном порядке.

Формат ввода

В первой строке входного файла input.txt записано натуральное число N (N ≤ 103). Во второй строке через пробел идут N целых чисел, по модулю не превосходящих 103 - элементы последовательности.

Формат вывода

В выходной файл output.txt выведите заданную последовательность в обратном порядке.

Примеры

Ввод Вывод
3
1 2 3		 3 2 1
================================================ FILE: turn/Turn.java ================================================ package turn; import java.io.*; import java.util.*; public class Turn { public static void main(String[] args) throws IOException { ArrayList lines = new ArrayList<>(); ArrayList numbers = new ArrayList<>(); StringBuilder out = new StringBuilder(); String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); while (sc.hasNextLine()){ str = sc.nextLine(); lines.add(str); } StringTokenizer st = new StringTokenizer(lines.get(1), " "); while(st.hasMoreTokens()){ numbers.add(st.nextToken()); } Collections.reverse(numbers); for(String i : numbers){ out.append(i).append(" "); // Записать в переменную i и пробел } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(out.toString()); fileOut.close(); } } ================================================ FILE: twenty_five/README.md ================================================

Пятью пять - двадцать пять! (8%)

Время: 1 сек.
Память: 16 Мб
Сложность: 8%

Вася и Петя учатся в школе в одном классе. Недавно Петя поведал Васе о хитром способе возведения в квадрат натуральных чисел, оканчивающихся на цифру 5. Теперь Вася может с легкостью возводить в квадрат двузначные (и даже некоторые трехзначные) числа, оканчивающиеся на 5. Способ заключается в следующем: для возведения в квадрат числа, оканчивающегося на 5 достаточно умножить число, полученное из исходного вычеркиванием последней пятерки на следующее по порядку число, затем остается лишь приписать «25» к получившемуся результату справа. Например, для того, чтобы возвести число 125 в квадрат достаточно 12 умножить на 13 и приписать 25, т.е. приписывая к числу 12*13=156 число 25, получаем результат 15625, т.е. 1252=15625. Напишите программу, возводящую число, оканчивающееся на 5, в квадрат для того, чтобы Вася смог проверить свои навыки.

Формат ввода

В единственной строке входного файла input.txt записано одно натуральное число А, оканчивающееся на цифру 5, не превышающее 4*105.

Формат вывода

В выходной файл output.txt выведите одно натуральное число - A2 без лидирующих нулей.

Примеры

Ввод Вывод
5 25
75 5625
4255 18105025
================================================ FILE: twenty_five/twentyFive.java ================================================ package twenty_five; import java.io.*; import java.util.*; public class twentyFive { public static void main(String[] args) throws IOException { long strInt; long out; String str; FileReader file = new FileReader("input.txt"); // Считывание данных из файла Scanner sc = new Scanner(file); str = sc.nextLine(); strInt = Integer.valueOf(str); out = (long) Math.pow(strInt, 2); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(out)); fileOut.close(); } } ================================================ FILE: two_bandits/README.md ================================================

Два бандита (4%)

Время: 1 сек.
Память: 16 Мб
Сложность: 4%

Бандиты Гарри и Ларри отдыхали на природе. Решив пострелять, они выставили на бревно несколько банок из-под кока-колы (не больше 10). Гарри начал простреливать банки по порядку, начиная с самой левой, Ларри — с самой правой. В какой-то момент получилось так, что они одновременно прострелили одну и ту же последнюю банку.

Гарри возмутился и сказал, что Ларри должен ему кучу денег за то, что тот лишил его удовольствия прострелить несколько банок. В ответ Ларри сказал, что Гарри должен ему еще больше денег по тем же причинам. Они стали спорить кто кому сколько должен, но никто из них не помнил сколько банок было в начале, а искать простреленные банки по всей округе было неохота. Каждый из них помнил только, сколько банок прострелил он сам.

Определите по этим данным, сколько банок не прострелил Гарри и сколько банок не прострелил Ларри.

Формат ввода

В единственной строке входного файла input.txt записано 2 числа — количество банок, простреленных Гарри и Ларри соответственно.

Формат вывода

В файл output.txt выведите 2 числа — количество банок, не простреленных Гарри и Ларри соответственно.

Пример 1

Ввод Вывод
4 7 6 3
================================================ FILE: two_bandits/TwoBandits.java ================================================ package two_bandits; import java.io.*; import java.util.*; public class TwoBandits { public static void main(String[] args) throws IOException { int count = 0; int a, b; ArrayList numberIn = new ArrayList<>(); String str; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while(st.hasMoreTokens()){ numberIn.add(Integer.valueOf(st.nextToken())); } for (Integer aNumberIn : numberIn) { // Посчитать колво банок с простреленной дважды банкой (+1) count += aNumberIn; } count--; a = count - numberIn.get(0); b = count - numberIn.get(1); FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(a + " " + b); fileOut.close(); } } ================================================ FILE: two_pow_n/README.md ================================================

2^N (30%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 30%

Необходимо вычислить значение 2n.

Формат ввода

В единственной строке входного файла input.txt записано натуральное число n (0 < n < 1000).

Формат вывода

В единственную строку выходного файла output.txt нужно вывести значение 2n.

Примеры

Ввод Вывод
3 8
10 1024
72 4722366482869645213696
================================================ FILE: two_pow_n/TwoPowN.java ================================================ package two_pow_n; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class TwoPowN { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int numberInput = sc.nextInt(); BigInteger result = BigInteger.TWO.pow(numberInput); PrintWriter out = new PrintWriter(System.out); out.println(result); out.flush(); } } ================================================ FILE: two_ring/README.md ================================================

Две окружности (17%)

Время: 1 сек.
Память: 16 Мб
Сложность: 17%

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

Формат ввода

Входной файл input.txt состоит из двух строк. На каждой строке записана информация об одной окружности – координаты ее центра x и y (целые числа, по модулю не превосходящие 5000) и радиус (целое число 1 ≤ r ≤ 1000).

Формат вывода

В выходной файл output.txt выведите «YES», если окружности имеют хотя бы одну общую точку, и «NO» в противном случае.

Примеры

Ввод Вывод
0 0 2
0 3 2		 YES
1 1 1
4 4 1		 NO
================================================ FILE: two_ring/TwoRing.java ================================================ package two_ring; import java.util.*; import java.io.*; public class TwoRing { private static ArrayList data = new ArrayList<>(); private static void getData() throws IOException{ // Получение данных FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } } } public static void main(String[] argv) throws IOException{ getData(); int r = (int) Math.sqrt(Math.pow((data.get(3) - data.get(0)), 2) + Math.pow((data.get(4) - data.get(1)), 2)); // Расчет расстояния между центрами окружностей String crossTwoRing = (r <= data.get(2) + data.get(5) && r + data.get(2) >= data.get(5) && r + data.get(5) >= data.get(2)) ? "YES" : "NO"; // Проверка условия существования общей точки PrintWriter pw = new PrintWriter(new File("output.txt")); pw.print(crossTwoRing); pw.close(); } } ================================================ FILE: two_sequences/README.md ================================================

Две последовательности (29%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 29%

Определим последовательности an и bn следующим образом: a1 = 2, a2 = 3, a3 = 4, a4 = 7, a5 = 13, an = bn−1 + bn−3, n > 5, bn — последовательность чисел, не входящих в an, записанных в возрастающем порядке.

Таким образом, последовательность an будет выглядеть следующим образом: 2, 3, 4, 7, 13, 15,..., а последовательность bn – 1, 5, 6, 8, 9, 10,....

Ваша задача состоит в том, чтобы найти an и bn.

Формат ввода

Входной файл содержит целое число n (1 ≤ n ≤ 10000).

Формат вывода

В первой строке выходного файла выведите an, во второй – bn.

Примеры

Ввод Вывод
4 7
8
10 25
16
6578 19731
9868
================================================ FILE: two_sequences/TwoSequences.java ================================================ package two_sequences; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class TwoSequences { private static int[] number(int n) { ArrayList a = new ArrayList<>(Arrays.asList(2, 3, 4, 7, 13)); ArrayList b = new ArrayList<>(Arrays.asList(1, 5, 6, 8, 9, 10, 11, 12)); for (int i = 14; i <= 20000; i++) { if (a.size() >= n && b.size() >= n) { break; } else { a.add(b.get(a.size()-1) + b.get(a.size()-3)); for (int j = a.get(a.size()-2)+1; j < a.get(a.size()-1); j++) { b.add(j); } } } int[] result = new int[2]; result[0] = a.get(n-1); result[1] = b.get(n-1); return result; } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int n = sc.nextInt(); int[] result = number(n); PrintWriter out = new PrintWriter(System.out); out.println(result[0]); out.println(result[1]); out.flush(); } } ================================================ FILE: two_simple_number/README.md ================================================

2-простое число (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Число называется 2-простым, если являются простыми числа, составленные из цифр этого числа в возрастающем и убывающем порядках.

Требуется написать программу, которая по заданному числу определит его 2-простоту.

Формат ввода

Входной файл input.txt содержит натуральное число N (10 < N < 109).

Формат вывода

В выходной файл output.txt выведите сообщение «Yes», если число N является 2-простым и «No» - иначе.

Примеры

Ввод Вывод
13 Yes
23 No
================================================ FILE: two_simple_number/TwoSimpleNumber.java ================================================ package two_simple_number; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.Scanner; public class TwoSimpleNumber { private static boolean isSimple(long number){ double sq = Math.sqrt(number); if(number == 1 || number == 2) return true; if(number % 2 == 0) return false; for(long i = 3; i <= sq; i += 2){ if(number % i == 0) return false; } return true; } private static long fromListToNumber(ArrayList symbols){ StringBuilder number = new StringBuilder(); for (Object symbol : symbols) { number.append(symbol); } return Long.valueOf(String.valueOf(number)); } public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String number = sc.nextLine(); boolean isSimple = true; ArrayList symbols = new ArrayList<>(); char[] ch = number.toCharArray(); for(char i : ch){ if(i - '0' == 0) { isSimple = false; break; } else { symbols.add(i - '0'); } } if(isSimple){ Collections.sort(symbols); long up = fromListToNumber(symbols); isSimple = isSimple(up); if(isSimple){ symbols.sort(Collections.reverseOrder()); long reverse = fromListToNumber(symbols); isSimple = isSimple(reverse); } } String result = isSimple ? "Yes" : "No"; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: underground/README.md ================================================

Метро (16%)

Время: 1 сек.
Память: 16 Мб
Сложность: 16%

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

Формат ввода

Во входном файле input.txt заданы три числа: сначала N – общее количество станций кольцевой линии, а затем i и j – номера станции, на которой Витя садится, и станции, на которой он должен выйти. Станции пронумерованы подряд натуральными числами 1, 2, 3, …, N (1-я станция – соседняя с N-й), N не превосходит 100. Числа i и j не совпадают. Все числа разделены пробелом.

Формат вывода

В выходной файл output.txt требуется вывести минимальное количество промежуточных станций (не считая станции посадки и высадки), которые необходимо проехать Вите.

Примеры

Ввод Вывод
100 5 6 0
10 1 9 1
================================================ FILE: underground/Underground.java ================================================ package underground; import java.io.*; import java.util.*; public class Underground { public static void main(String[] args) throws IOException { ArrayList data = new ArrayList<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); while (st.hasMoreTokens()){ data.add(Integer.valueOf(st.nextToken())); } int a = Math.abs(data.get(1) - data.get(2)) - 1; // Если едем прямо int b = (data.get(1) > data.get(2)) ? data.get(2) + Math.abs(data.get(0) - data.get(1)) - 1 : data.get(1) + (data.get(0) - data.get(2)) - 1; // Если едем в обратную сторону int result = (a > b) ? b : a; FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: unit/README.md ================================================

Единицы (16%)

Время: 1 сек.
Память: 16 Мб
Сложность: 16%

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

Формат ввода

Во входном файле input.txt записано целое число n (0 ≤ n ≤ 2×109).

Формат вывода

В единственную строку выходного файла output.txt нужно вывести одно целое число — количество двоичных единиц в записи числа n.

Примеры

Ввод Вывод
5 2
7 3
================================================ FILE: unit/Unit.java ================================================ package unit; import java.io.*; import java.util.*; public class Unit { public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); long number = Long.valueOf(sc.nextLine()); long result = 0; while (number >= 1){ if(number % 2 == 1){ result++; // Увеличиваем инднекс, если в остатке единица number = number / 2; }else { number = number / 2; } } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } } ================================================ FILE: unix/README.md ================================================

Unix (29%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 29%

Наш любимый сисадмин Алексей установил новую ОС семейства Unix. Основные её особенности - это стабильность, надежность, гибкость и масштабируемость и огромное количество идущего в стандартной поставке программного обеспечения. Одна из таких встроенных программ предназначена для сложения чисел, представленных в троичной системе счисления. Вы понимаете то, что Костя - известный тестер, и делом чести для него является найти ошибку в реализации столь сложной задачи. Помогите ему - напишите свою, абсолютно безошибочную версию «троичного калькулятора».

Формат ввода

Входной файл input.txt содержит два, разделенных пробелом, числа N и M (0 ≤ N, M ≤ 231-1) в троичной системе счисления.

Формат вывода

В выходной файл output.txt выведите ответ – сумму N и M в десятичной системе счисления.

Примеры

Ввод Вывод
1 1 2
20 102 17
================================================ FILE: unix/Unix.java ================================================ package unix; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.math.BigInteger; import java.util.Scanner; public class Unix { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String[] numbersInput = sc.nextLine().split(" "); BigInteger oneNumber = new BigInteger(numbersInput[0], 3); BigInteger twoNumber = new BigInteger(numbersInput[1], 3); BigInteger sum = new BigInteger(String.valueOf(oneNumber.add(twoNumber)), 10); PrintWriter out = new PrintWriter(System.out); out.println(sum); out.flush(); } } ================================================ FILE: unpack_string/README.md ================================================

Распаковка строки (25%)

Время: 1 сек.
Память: 16 Мб
Сложность: 25%

Будем рассматривать только строчки, состоящие из заглавных английских букв. Например, рассмотрим строку AAAABCCCCCDDDD. Длина этой строки равна 14. Поскольку строка состоит только из английских букв, повторяющиеся символы могут быть удалены и заменены числами, определяющими количество повторений. Таким образом, данная строка может быть представлена как 4AB5C4D. Длина такой строки 7. Описанный метод мы назовем упаковкой строки.

Напишите программу, которая берет упакованную строчку и восстанавливает по ней исходную строку.

Формат ввода

Входной файл input.txt содержит одну упакованную строку. В строке могут встречаться только конструкции вида nA, где n — количество повторений символа (целое число от 2 до 99), а A — заглавная английская буква, либо конструкции вида A, то есть символ без числа, определяющего количество повторений. Строка содержит от 1 до 80 символов.

Формат вывода

В выходной файл output.txt выведите восстановленную строку. При этом строка должна быть разбита на строчки длиной ровно по 40 символов (за исключением последней, которая может содержать меньше 40 символов).

Примеры

Ввод Вывод
3A4B7D AAABBBBDDDDDDD
22D7AC18FGD DDDDDDDDDDDDDDDDDDDDDDAAAAAAACFFFFFFFFFF
FFFFFFFFGD
95AB AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAB
40AB39A AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
================================================ FILE: unpack_string/UnpackString.java ================================================ package unpack_string; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class UnpackString { public static void main(String[] args) throws IOException { String originalString; FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); originalString = sc.nextLine(); StringBuilder finishString = new StringBuilder(); StringBuilder number = new StringBuilder(); char[] ch = originalString.toCharArray(); int shift = 0; for (char aCh : ch) { String symbol = String.valueOf(aCh); if (symbol.matches("\\d")) { number.append(symbol); } else { if (number.length() == 0) { if(finishString.length() > 0 && (finishString.length() - shift) % 40 == 0){ finishString.append("\n"); shift++; } finishString.append(symbol); } else { int countSymbol = Integer.valueOf(String.valueOf(number)); for (int j = 0; j < countSymbol; j++) { if(finishString.length() > 0 && (finishString.length() - shift) % 40 == 0){ finishString.append("\n"); shift++; } finishString.append(symbol); } number = new StringBuilder(); } } } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(finishString)); out.close(); } } ================================================ FILE: usm_dialogs/README.md ================================================

Диалоги по UCM (31%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 31%

Федя живет активной жизнью онлайн. Он легко ищет самые сложные рефераты, используя всемирно известные поисковые машины, скачивает музыку и делится ею с друзьями, он присоединился к многим популярным сообществам в Jивом Jурнале. И конечно же, он много общается с интернет-друзьями по UCM (You Seek Me) известному чат-клиенту.

Федя учится в школе. В школе изучают русский язык. Однажды учительница задала домашнее задание написать не менее 10-15 фраз, используя косвенную речь. Феде лень переписывать стандартные фразы из школьных учебников, он хочет мыслить нестандартно. И вот у Феди блеснула оригинальная идея – а не взять ли несколько диалогов из его любимого UCM и не перевести ли их в косвенную речь?

Идея хороша, но, к сожалению, Федя не умеет программировать, так как его еще не учили этому в школе. Помогите ему!

Формат ввода

Во входном файле находится распечатка одного из диалогов по UCM. В первой строке находится сообщение о том, что собеседник Феди вошел с ним в контакт. Оно выглядит так:

ЧЧ:ММ:СС: <Имя> signed on

где ЧЧ:ММ:СС – время, когда собеседник вошел в контакт, <Имя> – имя собеседника, записанное в транслите (английскими буквами). Любое число в отображении времени занимает две цифры, например, 9 часов 43 минуты 5 секунд будет выглядеть как 09:43:05.

В каждой из последующих строк (кроме самой последней строки файла) находится реплика участника диалога. Если каждой реплике присвоить ее порядковый номер (начиная с единицы), то нечетные реплики были произнесены Федей, а четные – его собеседником.

Реплика находится целиком на одной строке и состоит из метки времени, смысловой части и знака препинания конца предложения.

Метка времени имеет вид ЧЧ:ММ:СС:.

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

Знак препинания – это восклицательный знак, вопросительный знак или точка. Он может быть опущен, в этом случае подразумевается точка.

Пример реплики:

11:22:33: Ya skazal etu frazu.

Последняя строка файла имеет вид

ЧЧ:ММ:СС: <Имя> signed off

где <Имя> – имя все того же собеседника.

Объем входного файла не превышает 20 килобайт. Длина каждой строки не превосходит 250 символов.

Формат вывода

В выходной файл OUTPUT.TXT выведите для каждой реплики ее же, преобразованную в косвенную речь. Преобразование заключается в следующем. Сначала заключите реплику в двойные кавычки, при этом если она оканчивается на точку, то вместо точки поставьте запятую, иначе оставьте знак препинания без изменений, например:

Zakanchivayu tochkoi. → «Zakanchivayu tochkoi,» Eto voskhititel'no! → «Eto voskhititel'no!»

Затем поставьте пробел, три знака «–» (тире) и снова пробел, после чего выведите слово «ѕkazal» и имя собеседника, произнесшего эту реплику. После имени выведите точку. Федя запишется как «Fedya», имя его собеседника можно узнать из первой строки входного файла.

Примеры

Ввод Вывод
08:59:59: Vasya signed on
09:00:00: Privet!
09:00:31: Privet
09:00:59: Vasya signed off		 "Privet!" --- skazal Fedya.
"Privet," --- skazal Vasya.
================================================ FILE: usm_dialogs/UsmDialogs.java ================================================ package usm_dialogs; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Scanner; public class UsmDialogs { public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); Scanner sc = new Scanner(new FileReader("input.txt")); ArrayList lines = new ArrayList<>(); int startTextIndex = 10; String authorName = "Fedya"; String guestName = ""; boolean isAuthor = true; int index = 0; while (sc.hasNextLine()){ String line = sc.nextLine(); if (index == 0) { guestName = line.substring(startTextIndex, line.indexOf(" signed on")); } else { lines.add(line); } index++; } lines.remove(lines.size()-1); for (String line : lines) { String text = line.substring(startTextIndex); char lastSymbol = text.charAt(text.length() - 1); out.print("\""); if (lastSymbol == '!' || lastSymbol == '?') { out.print(text); } else if (lastSymbol == '.') { out.print(text.substring(0, text.length() - 1)); out.print(","); } else { out.print(text); out.print(","); } out.print("\" --- skazal "); if (isAuthor) { out.print(authorName); } else { out.print(guestName); } out.print(".\n"); isAuthor = !isAuthor; } out.flush(); } } ================================================ FILE: wagons/README.md ================================================

Вагоны (23%)

Время: 1 сек.
Память: 16 Мб
Сложность: 23%

Ежедневно диспетчеру железнодорожной станции приходится переставлять вагоны во многих поездах, чтобы они шли в заданном порядке. Для этого диспетчер может расцепить пришедший на станцию состав в произвольных местах и переставить образовавшиеся сцепки из одного или нескольких вагонов в произвольном порядке. Порядок вагонов в одной сцепке менять нельзя, также нельзя развернуть всю сцепку так, чтобы последний вагон в сцепке оказался первым в ней.

Диспетчер просит вашей помощи в определении того, какое минимальное число соединений между вагонами необходимо расцепить, чтобы переставить вагоны в составе в требуемом порядке.

Формат ввода

В первой строке входного файла input.txt содержится целое число N (1 ≤ N ≤ 100). Во второй строке содержится перестановка натуральных чисел от 1 до N (то есть все натуральные числа от 1 до N в некотором порядке). Числа разделяются одним пробелом. Эта перестановка задает номера вагонов в приходящем на станцию составе. Требуется, чтобы в уходящем со станции составе вагоны шли в порядке их номеров.

Формат вывода

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

Примеры

Ввод Вывод
4
3 1 2 4		 2
5
5 4 3 2 1		 4
2
1 2		 0
================================================ FILE: wagons/Wagons.java ================================================ package wagons; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; import java.util.StringTokenizer; public class Wagons { public static void main(String[] args) throws IOException { FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); int arrSize = Integer.valueOf(sc.nextLine()); int[] wagonsNumbers = new int[arrSize]; String str = sc.nextLine(); StringTokenizer st = new StringTokenizer(str, " "); int count = 0; while (st.hasMoreTokens()){ wagonsNumbers[count] = Integer.valueOf(st.nextToken()); count++; } int countCombination = 0; int prev = 0; for (int wagonsNumber : wagonsNumbers) { if(prev != 0){ if (prev + 1 != wagonsNumber) { countCombination++; } } prev = wagonsNumber; } System.out.println(countCombination); FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(countCombination)); out.close(); } } ================================================ FILE: watermelon/README.md ================================================

Арбузы (14%)

Время: 1 сек.
Память: 16 Мб
Сложность: 14%

Иван Васильевич пришел на рынок и решил купить два арбуза: один для себя, а другой для тещи. Понятно, что для себя нужно выбрать арбуз потяжелей, а для тещи полегче. Но вот незадача: арбузов слишком много и он не знает как же выбрать самый легкий и самый тяжелый арбуз? Помогите ему!

Формат ввода

В первой строке входного файла input.txt задано одно число N – количество арбузов. Вторая строка содержит N чисел, записанных через пробел. Здесь каждое число – это масса соответствующего арбуза. Все числа натуральные и не превышают 30000.

Формат вывода

В выходной файл output.txt нужно вывести два числа через пробел: массу арбуза, который Иван Васильевич купит теще и массу арбуза, который он купит себе.

Примеры

Ввод Вывод
5
5 1 6 5 9		 1 9
================================================ FILE: watermelon/Watermelon.java ================================================ package watermelon; import java.io.*; import java.util.*; public class Watermelon { public static void main(String[] args) throws IOException { ArrayList data= new ArrayList<>(); // Исходные данные построчно ArrayList weight = new ArrayList<>(); // Вес всех арбузов String result; // Результат решения задачи FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); while (sc.hasNextLine()){ data.add(sc.nextLine()); } StringTokenizer st = new StringTokenizer(data.get(1), " "); while (st.hasMoreTokens()){ weight.add(Integer.valueOf(st.nextToken())); } Collections.sort(weight); // Сортируем коллекцию result = weight.get(0) + " " + weight.get(weight.size() - 1); // Берем первый и последний элемент коллекции FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(result); fileOut.close(); } } ================================================ FILE: wedding/README.md ================================================

Свадьба (32%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 32%

Одна предприимчивая и очень симпатичная дамочка с прелестнейшим именем Горгона решила заработать себе денег на роскошную жизнь. N молодых людей так влюблены в нее, что предложили руку и сердце. К несчастью для них, Горгона видит в них только мешок с деньгами. Она планирует выйти замуж и почти сразу же развестись с некоторыми из молодых людей ради денежной выгоды. Все, что ей нужно, это подзаработать как можно больше денег (и уж, конечно, остаться незамужней). По законам этой прекрасной страны при разводе каждый из супругов получает половину всего имущества.

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

Формат ввода

В первой строке входного файла input.txt записано целое число N — количество молодых людей, без памяти влюбленных в Горгону (1 < N ≤ 40). Далее следует N чисел — сумма денег на счету каждого молодого человека. В последней строке записано целое число А — сумма денег на счету Горгоны. Суммы денег на счету — целые неотрицательные числа, не превосходящие 109.

Формат вывода

В выходной файл output.txt выведите единственное число — максимальную сумму денег, которой сможет обладать Горгона после своей махинации. Ответ выводите в формате с фиксированной точкой с ровно шестью знаками после десятичной точки.

Примеры

Ввод Вывод
2
5 10
5		 7.500000
3
1 3 2
0		 2.125000
================================================ FILE: wedding/Wedding.java ================================================ package wedding; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.*; public class Wedding { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int husbandCount = Integer.parseInt(sc.nextLine()); String[] husbandsMoney = sc.nextLine().split(" "); int gorgoneMoney = Integer.parseInt(sc.nextLine()); ArrayList money = new ArrayList<>(); for (String husband: husbandsMoney) { money.add(Integer.parseInt(husband)); } Collections.sort(money); double wifeMoney = 0; boolean first = true; for (int husbandMoney: money) { if (first) { wifeMoney = gorgoneMoney; } first = false; if (husbandMoney > wifeMoney) { double generalBudget = wifeMoney + husbandMoney; wifeMoney = generalBudget / 2; } } PrintWriter out = new PrintWriter(System.out); out.printf(Locale.US, "%.6f", wifeMoney); out.flush(); } } ================================================ FILE: weighing/README.md ================================================

Взвешивание (28%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Имеется N монет, не различимых на первый взгляд. Однако, одна из них фальшивая. Фальшивая монета чуть тяжелее, чем настоящая, но во всем остальном полностью идентична настоящим. Кроме того, есть чашечные весы без гирь и шкалы (по таким весам, можно определить, какая чаша тяжелее или легче, но нельзя сказать на сколько). Найти минимальное количество взвешиваний, за которое можно гарантированно определить фальшивку.

Формат ввода

Входной файл input.txt содержит одно натуральное число N – количество монет (2 ≤ N ≤ 109).

Формат вывода

В выходной файл output.txt выведите минимальное количество взвешиваний.

Примеры

Ввод Вывод
2 1
3 1
================================================ FILE: weighing/Weighing.java ================================================ package weighing; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class Weighing { public static void main(String[] args) throws IOException { PrintWriter out = new PrintWriter(System.out); int result = 0; int number = new Scanner(new FileReader("input.txt")).nextInt(); if (number == 2 || number == 3) { result = 1; } else { boolean plusOne = false; while (number > 2) { int div = number/3; int mod; if (div * 3 == number) { mod = div; } else { mod = div + 1; } if (mod == 2) { plusOne = true; } result++; number = mod; } if (plusOne) { result++; } } out.println(result); out.flush(); } } ================================================ FILE: wholesale/README.md ================================================

Замок (27%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 27%

Пара носков стоит 10 руб. 50 коп., связка (12 пар) стоит 102 руб. 50 коп., а коробка (12 связок) стоит 1140 руб.

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

Формат ввода

Входной файл input.txt содержит натуральное число N (N ≤ 109) – число пар носков, которые желает купить покупатель.

Формат вывода

Выходной файл output.txt должен содержать три числа (первое – количество коробок, второе – связок, третье – пар носков), разделенные пробелами.

Примеры

Ввод Вывод
11 0 1 0
500 3 5 8
================================================ FILE: wholesale/Wholesale.java ================================================ package wholesale; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class Wholesale { public static void main(String[] args) throws IOException { int opt = 12; int sockPrice = 21; int packPrice = 205; int boxPrice = 2280; Scanner scan = new Scanner(new FileReader("input.txt")); long sockCount = scan.nextInt(); int boxes = (int) (sockCount / (opt*opt)); int mod = (int) (sockCount % (opt*opt)); int packs = mod / opt; long items = mod % opt; if(items * sockPrice > packPrice){ packs++; items = 0; } if(packs * packPrice + items * sockPrice > boxPrice){ boxes++; packs = 0; items = 0; } String result = boxes + " " + packs + " " + items; FileWriter out = new FileWriter("output.txt"); out.write(result); out.close(); } } ================================================ FILE: wire_transfer/README.md ================================================

Телеграфный перевод (29%)

Ссылка на задачу

Время: 1 сек.
Память: 16 Мб
Сложность: 29%

Телеграфный перевод оплачивается по 7 рублей за каждую полную и неполную сотню рублей. Например, за перевод 123 рублей надо заплатить 14 рублей – 7 рублей за полную сотню и 7 рублей за 23 рубля – неполную сотню. Некто попросил переслать ему зарплату в N рублей, взяв деньги за перевод из этой зарплаты.

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

Формат ввода

Входной файл input.txt содержит одно натуральное число N (8 ≤ N ≤ 6∙104).

Формат вывода

Выходной файл output.txt должен содержать два натуральных числа – максимальную сумму и стоимость перевода. Числа разделить одним пробелом.

Примеры

Ввод Вывод
10 3 7
108 100 7
================================================ FILE: wire_transfer/WireTransfer.java ================================================ package wire_transfer; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.Scanner; public class WireTransfer { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); int sum = sc.nextInt(); int fee = 7; int feeSum = 100; int hundredCount = sum/feeSum; if (sum % feeSum != 0) { hundredCount++; } int resultSum = 0; int resultFee = 0; for (int i = 1; i <= hundredCount; i++) { int feeCount = i * fee; int translation = sum - feeCount; if (translation > feeSum * i) { translation = feeSum * i; } if (translation > resultSum) { resultSum = translation; resultFee = feeCount; } } PrintWriter out = new PrintWriter(System.out); out.println(resultSum + " " + resultFee); out.flush(); } } ================================================ FILE: word/README.md ================================================

Слово (28%)

Время: 1 сек.
Память: 16 Мб
Сложность: 28%

Числа Фибоначчи строятся следующим образом: первые два равны единице, а каждое следующее равно сумме двух предыдущих. Например, первые десять чисел Фибоначчи равны: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55. В заданном тексте символы нумеруются слева направо, начиная с единицы.

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

Формат ввода

Входной файл input.txt содержит в единственной строке текст, состоящий из английских строчных букв. В тексте от 1 до 30000 символов.

Формат вывода

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

Примеры

Ввод Вывод
a a
abc abc
abcdefghij abceh
================================================ FILE: word/Word.java ================================================ package word; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class Word { private static int next(int a, int b){ return a + b; } public static void main(String[] args) throws IOException { ArrayList fib = new ArrayList<>(Arrays.asList(1, 2)); StringBuilder result = new StringBuilder(); Scanner sc = new Scanner(new FileReader("input.txt")); String symbols = sc.nextLine(); char[] symbolsArr = symbols.toCharArray(); int index = 1; int next = next(fib.get(fib.size() - 1), fib.get(fib.size() - 2)); for (char symbol : symbolsArr){ String str = String.valueOf(symbol); if(index == 1 || index == 2){ result.append(str); }else { if(index == next){ result.append(str); fib.add(index); next = next(fib.get(fib.size() - 1), fib.get(fib.size() - 2)); } } index++; } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(result)); out.close(); } } ================================================ FILE: worst_divider/README.md ================================================

Наихудший делитель (23%)

Время: 1 сек.
Память: 16 Мб
Сложность: 23%

Будем говорить, что число a лучше числа b, если сумма цифр a больше суммы цифр числа b, а в случае равенства сумм их цифр, если число a меньше числа b. Например, число 124 лучше числа 123, так как у первого из них сумма цифр равна семи, а у второго — шести. Также, число 3 лучше числа 111, так как у них равны суммы цифр, но первое из них меньше.

Дано число n. Найдите такой его делитель d (само число n и единица считаются делителями числа n), что любой другой делитель c числа n лучше, чем d.

Формат ввода

Первая строка входного файла input.txt содержит целое число n (1 ≤ n ≤ 105000).

Формат вывода

В выходной файл output.txt выведите ответ на задачу.

Примеры

Ввод Вывод
10 10
239 1
================================================ FILE: worst_divider/WorstDivider.java ================================================ package worst_divider; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class WorstDivider { public static void main(String[] args) throws IOException { Scanner sc = new Scanner(new FileReader("input.txt")); String number = sc.nextLine(); char[] chNumber = number.toCharArray(); StringBuilder divider = new StringBuilder(); divider.append("1"); for(int i = chNumber.length-1; i > 0; i--){ if(chNumber[i] == '0'){ divider.append("0"); }else break; } FileWriter out = new FileWriter("output.txt"); out.write(String.valueOf(divider)); out.close(); } } ================================================ FILE: zero/README.md ================================================

Нули (16%)

Время: 1 сек.
Память: 16 Мб
Сложность: 16%

Требуется найти самую длинную непрерывную цепочку нулей в последовательности нулей и единиц.

Формат ввода

В единственной строке входного файла input.txt записана последовательность нулей и единиц (без пробелов). Суммарное количество цифр от 1 до 100.

Формат вывода

В единственную строку выходного файла output.txt нужно вывести искомую длину цепочки нулей.

Примеры

Ввод Вывод
00101110000110 4
================================================ FILE: zero/Zero.java ================================================ package zero; import java.io.*; import java.util.*; public class Zero { public static void main(String[] args) throws IOException { ArrayList zeroCount = new ArrayList<>(); FileReader file = new FileReader("input.txt"); Scanner sc = new Scanner(file); String str = sc.nextLine(); char[] symbols = str.toCharArray(); int count = 0; int result = 0; for (char symbol : symbols) { if (symbol - '0' == 0) { count++; } else { if (count != 0) { zeroCount.add(count); } count = 0; } } if(count != 0){ zeroCount.add(count); } if(!zeroCount.isEmpty()){ zeroCount.sort(Collections.reverseOrder()); result = zeroCount.get(0); } FileWriter fileOut = new FileWriter("output.txt"); fileOut.write(String.valueOf(result)); fileOut.close(); } }