├── .gitignore ├── .rustfmt.toml ├── BZOJ ├── 2844.cc └── 4126.cc ├── LibreOJ ├── 100.cc ├── 10000.cc ├── 10001.cc ├── 10034.cc ├── 10035.cc ├── 10036.cc ├── 101.cc ├── 10130.cc ├── 102.cc ├── 10208.py ├── 10209.py ├── 10211.py ├── 103.cc ├── 104.cc ├── 105.cc ├── 106.cc ├── 107.cc ├── 108.cc ├── 109.cc ├── 110.cc ├── 111.cc ├── 112.cc ├── 113.cc ├── 114.cc ├── 115.cc ├── 116.cc ├── 117.cc ├── 123.cc ├── 124.cc ├── 125.cc ├── 143.cc ├── 2000.cc ├── 2038.cc ├── 2045.cc ├── 2158.cc ├── 2170.cc ├── 2253.cc ├── 2432.cc ├── 2491.cc ├── 2813.cc ├── 4.py ├── 6.cc ├── 6024.cc ├── 6027.cc ├── 6028.cc ├── 6031.cc ├── 6053.cc ├── 6055.cc ├── 6056.cc ├── 6082.cc ├── 6083.cc ├── 6084.cc ├── 6085.cc ├── 6087.cc ├── 6090.cc ├── 6156.cc ├── 6158.cc ├── 6159.cc ├── 6164.cc ├── 6165.cc ├── 6180.cc ├── 6181.cc ├── 6183.cc ├── 6202.cc ├── 6220.cc ├── 6221.cc ├── 6222.cc ├── 6228.cc ├── 6229.cc ├── 6230.cc ├── 6231.cc ├── 6233.py ├── 6234.cc ├── 6235.cc ├── 6242.py ├── 6244.cc ├── 6245.cc ├── 6246.cc ├── 6247.cc ├── 6364.cc ├── 6368.py ├── 6563.cc ├── 6625.cc ├── 6687.py ├── 6707.cc ├── 6708.cc └── 6714.cc ├── README.md ├── acm-icpc ├── 1995 │ └── cerc │ │ ├── A.cc │ │ ├── D.cc │ │ ├── F.cc │ │ ├── G.cc │ │ └── H.cc ├── 2014 │ └── beijing │ │ └── G.cc ├── 2011-2012 │ └── dhaka │ │ └── E.cc ├── 2016-2017 │ └── asia-qingdao-online │ │ └── M.cc ├── 2018-2019 │ ├── cerc │ │ └── A.cc │ ├── neerc-moscow │ │ └── E.cc │ └── neerc-western │ │ ├── D.py │ │ ├── G.cc │ │ ├── J.py │ │ └── K.py └── 2019-2020 │ ├── nerc-north-western │ ├── D.cc │ └── F.cc │ └── nerc-southern-and-volga │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── E.cc │ └── F.cc ├── aizu-competitive-programming-camp ├── 2017-day1 │ ├── E.cc │ └── F.cc └── 2017-day2 │ └── L.cc ├── algorithmic-engagements ├── 2001 │ ├── box.cc │ ├── han.py │ ├── inw.cc │ ├── kni.cc │ ├── mar.cc │ ├── pos.cc │ ├── pot.py │ ├── res.cc │ ├── roz.py │ ├── sil.cc │ ├── tel.cc │ ├── tur.cc │ ├── wag.cc │ └── wyc.cc ├── 2002 │ ├── a.cc │ ├── b.cc │ ├── c.cc │ ├── e.cc │ ├── h.cc │ ├── imi.cc │ ├── lic.cc │ ├── min.cc │ ├── nar.cc │ ├── naw.cc │ ├── szy.cc │ └── wag.cc ├── 2003 │ ├── bai.cc │ ├── dyz.cc │ ├── fib.cc │ ├── jas.cc │ ├── jul.py │ ├── naw.cc │ ├── pic.cc │ ├── sko.cc │ └── sup.cc ├── 2005 │ ├── aut.cc │ ├── bib.cc │ ├── bil.cc │ ├── cyk.cc │ ├── dro.cc │ ├── dzw.cc │ ├── jan.cc │ ├── jas.cc │ ├── kos.cc │ ├── lin.cc │ ├── pot.py │ ├── sum.cc │ ├── sup.cc │ ├── sza.cc │ ├── usl.cc │ ├── wie.py │ ├── wiel.cc │ └── wyg.cc ├── 2006 │ ├── aut.cc │ ├── biu.cc │ ├── fib.cc │ ├── gra.cc │ ├── kon.cc │ ├── lii.cc │ ├── lot.cc │ ├── mro.cc │ ├── odc.cc │ ├── pol.cc │ ├── poz.cc │ ├── pro.py │ ├── rak.cc │ ├── sej.cc │ ├── slo.cc │ ├── spo.cc │ ├── sum.cc │ ├── tar.cc │ ├── tet.cc │ ├── wie.cc │ ├── wiz.cc │ └── zuc.cc ├── 2007 │ ├── aut.cc │ ├── bar.cc │ ├── dy2.cc │ ├── dys.cc │ ├── enc.cc │ ├── imp.cc │ ├── inw.cc │ ├── kar.cc │ ├── klu.cc │ ├── ko2.cc │ ├── kon.cc │ ├── naw.py │ ├── ogr.cc │ ├── pod.cc │ ├── pra.cc │ ├── pro.cc │ ├── rot.cc │ ├── sam.cc │ ├── sze.cc │ ├── ukl.cc │ └── zac.cc ├── 2008 │ ├── bal.cc │ ├── bug.cc │ ├── fun.cc │ ├── jab.cc │ ├── kli.cc │ ├── kon.cc │ ├── kot.cc │ ├── moz.cc │ ├── nie.cc │ ├── odb.cc │ ├── pap.cc │ ├── pow.cc │ ├── pra.cc │ ├── prz.cc │ ├── sej.cc │ ├── spi.cc │ ├── stu.cc │ ├── sza.cc │ ├── wyz.cc │ ├── zak.cc │ ├── zie.cc │ └── zli.cc ├── 2009 │ ├── ach.py │ ├── baj.cc │ ├── cia.cc │ ├── deb.cc │ ├── dro.cc │ ├── fib.cc │ ├── gra.cc │ ├── kns.cc │ ├── kol.cc │ ├── kos.cc │ ├── per.cc │ ├── pio.cc │ ├── pro.cc │ ├── prs.cc │ ├── ryb.cc │ ├── ste.cc │ ├── sto.cc │ ├── sza.cc │ ├── tra.cc │ └── wie.cc ├── 2010 │ ├── cuk.cc │ ├── dek.cc │ ├── ewa.cc │ ├── fib.cc │ ├── fir.cc │ ├── fra.cc │ ├── grz.cc │ ├── koz.cc │ ├── maa.cc │ ├── map.cc │ ├── mno.cc │ ├── mon.cc │ ├── pod.cc │ ├── pol.cc │ ├── pro.cc │ ├── prs.cc │ ├── sle.cc │ ├── ter.cc │ ├── wys.cc │ ├── zag.cc │ └── zaj.cc ├── 2011 │ ├── lic.cc │ ├── tul.cc │ ├── wie.cc │ └── wsp.cc ├── 2017 │ └── ban.cc ├── 2019 │ ├── apb.cc │ ├── des.cc │ ├── final │ │ ├── flo.cc │ │ ├── gdz.cc │ │ ├── gra.cc │ │ ├── lam.cc │ │ ├── olo.cc │ │ ├── pad.cc │ │ ├── pio.cc │ │ ├── ter.cc │ │ └── zdj.cc │ ├── her.cc │ ├── ilo.cc │ ├── kul.cc │ ├── oiw.cc │ ├── pod.cc │ ├── pop.cc │ ├── sis.cc │ ├── ter.cc │ ├── win.cc │ └── wys.cc └── 2002-2 │ ├── aut.cc │ ├── blo.cc │ ├── gra.cc │ ├── kor.cc │ ├── log.cc │ ├── paj.cc │ ├── pat.cc │ ├── pro.cc │ ├── soj.cc │ ├── szy.cc │ ├── tar.cc │ ├── tur.cc │ └── wid.cc ├── atcoder ├── abc154 │ ├── A.py │ ├── B.py │ ├── C.py │ ├── D.cc │ ├── E.cc │ └── F.cc ├── abc155 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc ├── agc012 │ └── D.cc ├── agc015 │ └── D.cc ├── arc055 │ └── C.cc ├── arc060 │ └── F.cc ├── cf16-final │ └── A.cc ├── code-festival-2016-quala │ ├── A.py │ ├── B.py │ ├── C.py │ ├── D.cc │ └── E.cc ├── code-festival-2016-qualb │ └── E.cc ├── code-festival-2016-qualc │ └── D.cc ├── ddcc2020-qual │ ├── A.py │ ├── B.py │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.py ├── dp │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ ├── F.cc │ ├── G.cc │ ├── H.cc │ └── I.cc ├── dwacon6th-prelims │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── nikkei2019-qual │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc └── snuke21 │ ├── A.py │ ├── B.cc │ └── C.cc ├── baltic-oi ├── 2001 │ ├── box.cc │ ├── exc.cc │ ├── kni.cc │ ├── mar.cc │ ├── pos.cc │ └── tel.cc └── 2018 │ ├── genetics.cc │ └── paths.cc ├── bubble-cup └── 2017 │ ├── F.cc │ ├── G.cc │ ├── H.cc │ └── I.cc ├── byteDance-moscow-workshops └── winter-2020 │ └── online-qualification-contest │ └── G.cc ├── ccpc ├── 2017-qinhuangdao │ ├── I.cc │ └── J.cc ├── 2020-online │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ ├── F.cc │ ├── G.cc │ ├── J.cc │ ├── K.cc │ ├── L.cc │ └── M.cc └── 2020-qinhuangdao │ ├── A.cc │ └── J.cc ├── ceoi ├── 2005 │ └── service.cc └── 2019 │ └── cubeword.cc ├── coci ├── 2010-2011 │ └── contest#4 │ │ └── hrpa.cc └── 2019-2020 │ ├── contest#1 │ ├── dzumbus.cc │ ├── lutrija.cc │ ├── trobojnica.cc │ ├── trol.cc │ └── zoo.cc │ ├── contest#3 │ ├── drvca.cc │ ├── grudanje.cc │ ├── preokret.cc │ └── sob.cc │ └── contest#4 │ ├── holding.cc │ ├── klasika.cc │ ├── nivelle.cc │ ├── pod.cc │ └── spiderman.cc ├── codechef ├── COOK114 │ ├── CFINASUM.cc │ ├── CNTIT.cc │ ├── PLIND.cc │ ├── PRT.cc │ └── RGAND.cc ├── COOK41 │ └── GERALD3.cc ├── DEC19 │ ├── APAIRS.cc │ ├── BINADD.cc │ ├── BINOFEV.cc │ ├── BINXOR.cc │ ├── CHFRAN.cc │ ├── PLMU.cc │ ├── STICNOT.cc │ ├── SUBSPLAY.cc │ └── WATSCORE.cc ├── JAN20 │ ├── ARMYOFME.cc │ ├── CHEFARMY.cc │ ├── CHEFPSA.cc │ ├── CHFDORA.cc │ ├── DFMTRX.cc │ ├── DYNAMO.cc │ └── ENGLISH.cc ├── OCT19 │ └── CNNCT2.cc ├── SEPT13 │ └── TMP01.cc ├── SNCK1A19 │ ├── ARRGRAPH.cc │ ├── CARDMGK.cc │ └── TYPING.cc ├── SNCKEL19 │ ├── ADJLEAF2.cc │ ├── RECOVER.cc │ └── SFXPAL.cc ├── SNCKPE19 │ ├── ANGLE.cc │ ├── INVENTRY.cc │ ├── PAINTREE.cc │ └── STRTF.cc └── SNCKQL19 │ ├── CHEFPRMS.cc │ ├── QABC.cc │ ├── QUALPREL.cc │ ├── SPREAD2.cc │ └── TEAMMATE.cc ├── codeforces ├── AIM Tech Round 3 │ ├── 2A.cc │ ├── 2B.cc │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── Codeforces Beta Round #1 │ ├── A.cc │ ├── B.cc │ └── C.cc ├── Codeforces Beta Round #10 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── Codeforces Beta Round #11 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ └── D.cc ├── Codeforces Beta Round #2 │ ├── A.cc │ ├── B.cc │ └── C.cc ├── Codeforces Beta Round #3 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ └── D.cc ├── Codeforces Beta Round #4 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ └── D.cc ├── Codeforces Beta Round #5 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── Codeforces Beta Round #6 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── Codeforces Beta Round #7 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── Codeforces Beta Round #8 │ ├── A.cc │ ├── B.cc │ └── C.cc ├── Codeforces Beta Round #9 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── Codeforces Round #365 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── Codeforces Round #366 │ ├── 2A.cc │ ├── 2B.cc │ └── A.cc ├── Codeforces Round #367 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── Codeforces Round #368 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── Codeforces Round #432 │ ├── 2A.cc │ ├── 2B.cc │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc ├── Codeforces Round #433 │ ├── 2A.cc │ ├── 2B.cc │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── Codeforces Round #434 │ ├── 2A.cc │ ├── 2B.cc │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── Codeforces Round #485 │ ├── A.cc │ ├── B.cc │ └── C.cc ├── Codeforces Round #539 │ ├── 2A.cc │ ├── 2B.cc │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc ├── Codeforces Round #540 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ ├── F1.cc │ └── F2.cc ├── Codeforces Round #542 │ ├── A.cc │ └── B.cc ├── Codeforces Round #568 │ ├── A │ │ ├── Cargo.toml │ │ └── src │ │ │ └── main.rs │ ├── B │ │ ├── Cargo.toml │ │ └── src │ │ │ └── main.rs │ ├── C │ │ ├── Cargo.toml │ │ └── src │ │ │ └── main.rs │ ├── D │ │ ├── Cargo.toml │ │ └── src │ │ │ └── main.rs │ └── E │ │ ├── Cargo.lock │ │ ├── Cargo.toml │ │ └── src │ │ └── main.rs ├── Codeforces Round #612 │ ├── 2A.cc │ ├── 2B.cc │ └── A.cc ├── Codeforces Round #613 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc ├── Educational Codeforces Round 16 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc ├── Good Bye 2018 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc ├── Hello 2019 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc ├── Hello 2020 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ ├── F.cc │ └── G.cc ├── valentines-day-contest-2020 │ ├── A.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ ├── F.cc │ └── G.cc └── vk-cup-2015 │ └── finals │ └── C.cc ├── codem ├── 2017 │ ├── qualification-round │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ └── F.cc │ └── round-1a │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ └── F.cc └── 2018 │ ├── qualification-round │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc │ └── round-1a │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── cometoj ├── contest#12 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc ├── contest#14 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc └── contest#4 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc ├── deadline24 └── 2017 │ ├── crossword.cc │ └── row.cc ├── distributed-code-jam ├── 2015 │ ├── final │ │ ├── kolakoski.cc │ │ ├── necklace.cc │ │ └── rocks.cc │ ├── online-round │ │ ├── almost_sorted.cc │ │ ├── highest_mountain.cc │ │ ├── johnny.cc │ │ └── mutexes.cc │ └── practice-round │ │ ├── load_balance.cc │ │ ├── majority.cc │ │ ├── sandwich.cc │ │ └── shhhh.cc ├── 2016 │ ├── final │ │ └── encoded_sum.cc │ ├── round1 │ │ ├── crates.cc │ │ ├── oops.cc │ │ └── rps.cc │ └── round2 │ │ ├── again.cc │ │ ├── asteroids.cc │ │ ├── gas_stations.cc │ │ └── lisp_plus_plus.cc ├── 2017 │ ├── final-round │ │ └── baby_blocks.cc │ ├── round1 │ │ ├── pancakes.cc │ │ ├── query_of_death.cc │ │ ├── todd_and_steven.cc │ │ └── weird_editor.cc │ └── round2 │ │ ├── broken_memory.cc │ │ ├── flagpoles.cc │ │ ├── nanobots.cc │ │ └── number_bases.cc └── template.cc ├── erdos ├── 1.py ├── 10.py ├── 14.py ├── 140.py ├── 146.py ├── 16.py ├── 163.py ├── 164.py ├── 166.py ├── 172.py ├── 189.py ├── 19.py ├── 190.py ├── 198.py ├── 199.py ├── 20.py ├── 200.py ├── 201.py ├── 202.py ├── 203.py ├── 204.py ├── 205.cc ├── 22.py ├── 3.py ├── 4.py ├── 5.py ├── 56.cc ├── 6.py ├── 8.py └── 9.py ├── facebook-hacker-cup ├── 2011 │ ├── final-round │ │ ├── alien-game.cc │ │ ├── party-time.cc │ │ └── safest-place.cc │ ├── qualification-round │ │ ├── double-squares.cc │ │ ├── peg-game.cc │ │ └── studious-student.cc │ ├── round-1a │ │ ├── diversity-number.cc │ │ ├── turn-on-the-lights.cc │ │ └── wine-tasting.cc │ ├── round-1b │ │ ├── chess-2.cc │ │ ├── diminishing-circle.cc │ │ └── slot-machine-hacker.cc │ ├── round-1c │ │ ├── n-factorful.cc │ │ ├── polynomial-factoring.cc │ │ └── risky-slide.cc │ └── round-2 │ │ ├── bonus-assignments.cc │ │ ├── scotts-new-trick.cc │ │ └── studious-student-ii.cc ├── 2012 │ ├── qualification-round │ │ ├── alphabet-soup.cc │ │ ├── auction.cc │ │ └── billboards.cc │ ├── round1 │ │ ├── checkpoint.cc │ │ ├── recover-the-sequence.cc │ │ └── squished-status.cc │ ├── round2 │ │ ├── monopoly.cc │ │ └── road-removal.cc │ └── round3 │ │ └── trapezoids.cc ├── 2018 │ ├── qualification-round │ │ ├── ethan-searches-for-a-string.cc │ │ ├── interception.cc │ │ └── tourist.cc │ └── round1 │ │ ├── ethan-traverses-a-tree.cc │ │ └── let-it-flow.cc └── 2019 │ ├── qualification-round │ ├── leapfrog-ch-1.cc │ ├── leapfrog-ch-2.cc │ ├── mr-x.py │ └── trees-as-a-service.cc │ ├── round1 │ ├── class-treasurer.cc │ ├── connect-the-dots.cc │ ├── graphs-as-a-service.cc │ └── ladders-and-snakes.cc │ └── round2 │ ├── bitstrings-as-a-service.cc │ ├── grading.cc │ ├── on-the-run.cc │ └── seafood.cc ├── google-code-jam ├── 2018 │ ├── practice │ │ ├── bathroom-stalls.cc │ │ ├── number-guessing.cc │ │ ├── senate-evacuation.cc │ │ └── steed-2-cruise-control.cc │ ├── qualification │ │ ├── cubic-ufo.cc │ │ ├── go-gopher.cc │ │ ├── saving-the-universe-again.cc │ │ └── trouble-sort.cc │ ├── round-1a │ │ ├── bit-party.cc │ │ ├── edgy-baking.cc │ │ └── waffle-choppers.cc │ ├── round2 │ │ ├── costume-change.cc │ │ ├── falling-balls.cc │ │ ├── graceful-chainsaw-jugglers.cc │ │ └── gridception.cc │ └── round3 │ │ └── field-trip.cc ├── 2019 │ ├── qualification │ │ ├── cryptopangrams.py │ │ ├── dat-bae.cc │ │ ├── foregone-solution.cc │ │ └── you-can-go-your-own-way.cc │ ├── round-1a │ │ ├── alien-rhyme.cc │ │ ├── golf-gophers.cc │ │ └── pylons.cc │ ├── round-1b │ │ └── manhattan-crepe-cart.cc │ ├── round-2 │ │ ├── contransmutation.cc │ │ ├── new-elements-part-1.cc │ │ ├── new-elements-part-2.py │ │ └── pottery-lottery.cc │ └── round-3 │ │ └── datacenter-duplex.cc └── 2020 │ ├── qualification-round │ ├── esab-atad.cc │ ├── indicium.cc │ ├── nesting-depth.cc │ ├── parenting-partnering-returns.cc │ └── vestigium.cc │ ├── round-1a │ ├── pascal-walk.cc │ ├── pattern-matching.cc │ └── square-dance.cc │ └── round2 │ ├── incremental-house-of-pancakes.py │ └── wormhole-in-one.cc ├── gordian-knot ├── 2017 │ ├── 1-4.py │ ├── 2-1.cc │ ├── 2-2.cc │ ├── 3-2.cc │ ├── 3-4.cc │ ├── 4-1.cc │ ├── 4-3.cc │ ├── 4-4.cc │ └── 5-3.cc └── 2018 │ ├── 22.py │ ├── Q12.cc │ ├── Q15.cc │ ├── Q17.py │ ├── Q18.py │ ├── Q2.cc │ ├── Q21.cc │ ├── Q22.cc │ ├── Q23.cc │ ├── Q24.cc │ ├── Q26.py │ ├── Q28.py │ ├── Q3.py │ ├── Q4.py │ ├── Q5.py │ ├── Q6.py │ └── Q9.py ├── hackerearth ├── algorithms-qualifiers-round-1 │ ├── explosive-game.cc │ ├── hungry-lemurs.cc │ ├── permutation-swaps.cc │ ├── strange-function.cc │ └── string-division.cc ├── algorithms-qualifiers-round-2 │ ├── a-walk-to-remember-qualifier2.cc │ ├── beautiful-array-qualifier2.cc │ ├── cube-change-qualifier2.cc │ ├── earthandthemeteorites-qualifier2.cc │ └── shil-and-square-sum-qualifier2.cc └── algorithms-qualifiers-round-3 │ ├── dilku-and-love-triangle.cc │ ├── memories-1.cc │ ├── new-world-11.cc │ ├── walls-of-the-north.cc │ └── zeroes.cc ├── hackerrank └── w27 │ └── how-many-substrings.cc ├── innopolis-open └── 2019-2020 │ ├── first-elimination-round │ ├── B.cc │ ├── C.cc │ └── D.cc │ └── second-elimination-round │ ├── C.cc │ ├── D.py │ └── E.cc ├── international-zhautykov-olympiad └── 2020 │ ├── kazhackstan.cc │ ├── lines.cc │ └── nasty-donchik.cc ├── japan-alumni-group ├── summer-2017-day3 │ ├── I.cc │ └── J.cc ├── summer-2018-day1 │ └── E.cc └── summer-2019-day3 │ └── F.cc ├── japan-olympiad-in-informatics ├── 2014-2015 │ ├── joi2015ho │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ └── E.cc │ ├── joiopen2015 │ │ └── C.cc │ ├── joisc2015day1 │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ └── D.cc │ ├── joisc2015day2 │ │ ├── A.cc │ │ ├── B.cc │ │ └── C.cc │ ├── joisc2015day3 │ │ ├── A.cc │ │ ├── B.cc │ │ └── C.cc │ └── joisc2015day4 │ │ ├── A.cc │ │ ├── B.cc │ │ └── C.cc └── 2019-2020 │ ├── joi-thanks-2020 │ ├── joi-sticker.cc │ └── piano.cc │ ├── joi2020_yo1a │ ├── A.cc │ ├── B.cc │ └── C.cc │ ├── joi2020_yo1b │ ├── A.cc │ ├── B.cc │ └── C.cc │ ├── joi2020_yo1c │ ├── A.cc │ ├── B.cc │ └── C.cc │ ├── joi2020ho │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc │ ├── joi2020yo2 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc │ ├── joi2020yo2_mock │ ├── employment2.cc │ ├── illumination2.cc │ ├── necklace.cc │ ├── persuasion.cc │ └── transportation-center.cc │ ├── joisc2020day1 │ ├── building4.cc │ └── hamburg.cc │ ├── joisc2020day2 │ ├── chameleon.cc │ ├── joitter2.cc │ └── ruins3.cc │ ├── joisc2020day3 │ ├── constellation3.cc │ ├── harvest.cc │ └── stray.cc │ └── joisc2020day4 │ ├── capital_city.cc │ ├── dango2.cc │ ├── dango2.zip │ └── treatment.cc ├── megcup └── 2017 │ ├── rules.py │ └── rules_input.txt ├── miscellaneous ├── new-year-mlr-blitz-2019 │ └── F.py └── riga-and-singapore-workshop-contest │ ├── E.cc │ └── J.cc ├── multi-university-training-contest ├── 2011 │ └── contest-11 │ │ └── J.cc └── 2019 │ └── A.cc ├── ontak ├── 2007 │ ├── gen.cc │ ├── map.cc │ └── poz.cc └── 2017 │ ├── pir.cc │ ├── pol.cc │ ├── raj.cc │ └── sla.cc ├── opencup ├── xix │ ├── gp-of-belarus │ │ ├── D.cc │ │ ├── F.py │ │ └── J.cc │ ├── gp-of-bytedance │ │ └── B.cc │ ├── gp-of-daejeon │ │ └── G.cc │ ├── gp-of-gomel │ │ └── D.cc │ ├── gp-of-korea │ │ ├── B.cc │ │ └── C.cc │ ├── gp-of-moscow │ │ └── I.cc │ ├── gp-of-poland │ │ └── M.cc │ ├── gp-of-xian │ │ └── B.cc │ └── gp-of-zhejiang │ │ ├── D.cc │ │ ├── E.cc │ │ ├── F.cc │ │ ├── H.cc │ │ └── L.cc ├── xv │ └── gp-of-karelia │ │ └── C.cc ├── xvi │ └── gp-of-moscow │ │ ├── H.cc │ │ └── K.cc ├── xvii │ ├── gp-of-japan │ │ └── A.cc │ └── gp-of-poland │ │ └── K.cc ├── xviii │ ├── gp-of-america │ │ └── G.cc │ ├── gp-of-khamovniki │ │ └── J.cc │ ├── gp-of-korea │ │ ├── G.cc │ │ └── I.cc │ ├── gp-of-poland │ │ └── G.cc │ ├── gp-of-romania │ │ ├── B.cc │ │ └── F.cc │ ├── gp-of-saratov │ │ ├── A.cc │ │ └── I.cc │ └── gp-of-ukraine │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ ├── F.cc │ │ ├── G.cc │ │ ├── H.cc │ │ ├── I.cc │ │ ├── J.cc │ │ ├── K.cc │ │ └── L.cc ├── xx │ ├── gp-of-bytedance │ │ ├── B.cc │ │ ├── C.cc │ │ ├── F.cc │ │ └── K.cc │ ├── gp-of-gomel │ │ ├── F.cc │ │ └── H.cc │ ├── gp-of-kazan │ │ ├── C.cc │ │ ├── F.cc │ │ ├── H.cc │ │ └── J.cc │ ├── gp-of-korea │ │ └── K.cc │ ├── gp-of-moscow │ │ ├── C.cc │ │ └── D.cc │ ├── gp-of-nanjing │ │ └── K.cc │ ├── gp-of-north-america │ │ └── E.cc │ ├── gp-of-poland │ │ ├── D.cc │ │ └── K.cc │ ├── gp-of-southeastern-europe │ │ └── H.cc │ ├── gp-of-spb │ │ └── A.cc │ ├── gp-of-tokyo │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ ├── F.cc │ │ ├── H.cc │ │ ├── I.cc │ │ ├── J.cc │ │ └── L.cc │ ├── gp-of-wroclaw │ │ ├── D.cc │ │ ├── I.cc │ │ └── J.cc │ ├── gp-of-xian │ │ └── K.cc │ └── gp-of-zhejiang │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── F.cc │ │ ├── H.cc │ │ ├── I.cc │ │ ├── K.cc │ │ └── L.cc └── xxi │ ├── gp-of-eurasia │ ├── 1.cc │ ├── 10.cc │ ├── 2.cc │ ├── 3.cc │ ├── 4.cc │ ├── 5.cc │ ├── 6.cc │ ├── 7.cc │ ├── 8.cc │ └── 9.cc │ ├── gp-of-spb │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── G.cc │ ├── H.cc │ ├── I.cc │ ├── J.cc │ └── L.cc │ └── gp-of-xiaomi │ └── F.cc ├── petrozavodsk-training-camp ├── 2011-winter │ └── orel-stu+nnsu-contest │ │ └── H.cc ├── 2012-summer │ └── kyiv-nu-contest │ │ └── A.cc ├── 2012-winter │ └── saratov-su-contest │ │ └── D.cc ├── 2013-summer │ └── moscow-su-st+nnsu-contest │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ ├── F.cc │ │ ├── G.cc │ │ ├── H.cc │ │ ├── I.cc │ │ └── J.cc ├── 2014-winter │ ├── moscow-su-tapir-contest │ │ ├── C.cc │ │ └── E.cc │ └── moscow-su-trinity-contest │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ ├── F.cc │ │ ├── G.cc │ │ ├── J.cc │ │ └── K.cc ├── 2015-summer │ ├── mipt-contest │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ ├── F.cc │ │ ├── G.cc │ │ ├── H.cc │ │ ├── I.cc │ │ └── J.cc │ └── yandex-cup-stage-2 │ │ └── H.cc ├── 2015-winter │ ├── chinese-camp-contest-2 │ │ └── F.cc │ ├── jagiellonian-u-contest │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ ├── F.cc │ │ ├── G.cc │ │ ├── H.cc │ │ ├── I.cc │ │ ├── J.cc │ │ └── K.cc │ ├── michael-tikhomirov-contest-1 │ │ ├── A.rs │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.rs │ │ ├── E.rs │ │ ├── F.rs │ │ ├── G.cc │ │ ├── H.cc │ │ ├── I.cc │ │ └── J.rs │ └── moscow-su-tapirs-contest │ │ └── F.cc ├── 2016-summer │ └── ural-fu-dandelion-contest │ │ ├── F.cc │ │ └── K.cc ├── 2017-winter │ ├── jagiellonian-u-contest │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── E.cc │ │ └── F.cc │ ├── u-of-tokyo-selection-1 │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── F.cc │ │ ├── H.cc │ │ └── K.cc │ └── yandex-cup-2017 │ │ ├── A.cc │ │ ├── D.cc │ │ └── F.cc ├── 2018-summer │ ├── mipt-contest │ │ ├── C.cc │ │ ├── D.cc │ │ └── H.cc │ ├── umnik-team-contest │ │ └── A.cc │ └── warsaw-u-contest │ │ └── D.cc ├── 2018-winter │ ├── itmo-u-1-contest │ │ └── H.cc │ └── jagiellonian-u-contest │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ ├── F.cc │ │ ├── G.cc │ │ ├── H.cc │ │ ├── I.cc │ │ ├── J.cc │ │ ├── K.cc │ │ └── L.cc ├── 2019-summer │ ├── mex-foundation-contest │ │ └── D.cc │ └── songyang-chen-contest-2 │ │ ├── C.cc │ │ ├── G.cc │ │ ├── I.cc │ │ ├── K.cc │ │ └── L.cc ├── 2019-winter │ ├── 300iq-contest-1 │ │ └── I.cc │ ├── oleksandr-kulkov-contest-1 │ │ └── I.cc │ ├── petrozavodsk-su-contest │ │ ├── G.cc │ │ └── J.cc │ └── yandex-cup-2019 │ │ └── D.cc ├── 2020-summer │ ├── korean-contest │ │ └── C.cc │ └── warsaw-u-contest │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ ├── F.cc │ │ ├── G.cc │ │ ├── H.cc │ │ ├── I.cc │ │ ├── J.cc │ │ ├── K.cc │ │ └── L.cc └── 2020-winter │ ├── 300iq-contest-3 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ ├── F.cc │ ├── G.cc │ ├── H.cc │ ├── I.cc │ └── J.cc │ ├── almost-algorithmic-contest │ └── J.cc │ ├── greetings-from-japan │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ ├── F.cc │ ├── G.cc │ ├── H.cc │ ├── I.cc │ ├── J.cc │ └── K.cc │ ├── jagiellonian-u-contest │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ ├── F.cc │ ├── G.cc │ ├── H.cc │ ├── I.cc │ ├── J.cc │ ├── K.cc │ └── L.cc │ ├── lviv-nu-contest │ ├── A.cc │ ├── D.cc │ └── I.cc │ ├── spb-su-contest │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── F.cc │ ├── G.cc │ ├── H.cc │ ├── I.cc │ └── K.cc │ └── yandex-cup-2020 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ ├── F.cc │ ├── G.cc │ ├── H.cc │ └── J.cc ├── polish-olympiad-in-informatics ├── i │ ├── pio.cc │ ├── prz.cc │ ├── spo.cc │ ├── sum.cc │ └── tro.cc ├── ii │ ├── drz.cc │ ├── jed.cc │ ├── jez.cc │ ├── kod.cc │ ├── kpk.cc │ ├── mud.cc │ ├── obc.cc │ ├── opt.cc │ ├── pal.cc │ ├── poc.cc │ ├── slo.cc │ ├── sza.cc │ ├── sze.cc │ ├── tro.cc │ └── wie.cc ├── iii │ ├── age.cc │ ├── fib.py │ ├── gon.cc │ ├── haz.cc │ ├── kul.cc │ ├── mok.cc │ ├── mon.cc │ ├── nie.py │ ├── per.cc │ ├── pre.cc │ ├── wie.cc │ └── wyr.cc ├── iv │ ├── lic.cc │ ├── lot.cc │ ├── tan.cc │ └── xor.cc ├── ix │ ├── lic.cc │ ├── min.cc │ ├── nar.cc │ ├── naw.cc │ ├── szy.cc │ └── wag.cc ├── xix │ └── roz.cc └── xxvii │ ├── czw.cc │ ├── mar.cc │ ├── nww.cc │ ├── pom.cc │ ├── pow.cc │ ├── szy.cc │ ├── tru.cc │ ├── ukl.cc │ ├── uni.cc │ ├── wak.cc │ └── wie.cc ├── prime-contest-2016 ├── 11.cc ├── 13.cc ├── 17.cc ├── 2.cc ├── 29.cc ├── 3.cc ├── 31.cc ├── 43.cc ├── 5.cc └── ny.en.pdf ├── prime-contest └── 2021 │ ├── 11.cc │ ├── 13.cc │ ├── 17.cc │ ├── 2.cc │ ├── 29.cc │ ├── 3.cc │ ├── 31.cc │ ├── 41.cc │ ├── 47.cc │ ├── 5.cc │ ├── 53.cc │ ├── 59.cc │ ├── 61.cc │ └── 7.cc ├── project-euler ├── volume01 │ ├── 1.cc │ ├── 10.cc │ ├── 11.cc │ ├── 12.cc │ ├── 13.py │ ├── 14.cc │ ├── 15.cc │ ├── 16.cc │ ├── 17.py │ ├── 18.cc │ ├── 19.cc │ ├── 2.cc │ ├── 20.py │ ├── 21.cc │ ├── 22.cc │ ├── 23.cc │ ├── 24.cc │ ├── 25.py │ ├── 26.cc │ ├── 27.cc │ ├── 28.py │ ├── 29.cc │ ├── 3.cc │ ├── 30.cc │ ├── 31.cc │ ├── 32.cc │ ├── 33.cc │ ├── 34.cc │ ├── 35.cc │ ├── 36.cc │ ├── 37.cc │ ├── 38.cc │ ├── 39.cc │ ├── 4.cc │ ├── 40.cc │ ├── 41.cc │ ├── 42.cc │ ├── 43.cc │ ├── 44.cc │ ├── 45.cc │ ├── 46.cc │ ├── 47.cc │ ├── 48.py │ ├── 49.cc │ ├── 5.cc │ ├── 50.cc │ ├── 6.cc │ ├── 7.cc │ ├── 8.cc │ └── 9.cc ├── volume02 │ ├── 100.py │ ├── 51.cs │ ├── 52.cc │ ├── 53.py │ ├── 54.py │ ├── 55.py │ ├── 56.py │ ├── 57.py │ ├── 58.cc │ ├── 59.cc │ ├── 60.cc │ ├── 61.cc │ ├── 62.cc │ ├── 63.py │ ├── 64.cc │ ├── 65.py │ ├── 66.py │ ├── 67.cc │ ├── 68.cc │ ├── 69.cc │ ├── 70.cc │ ├── 71.cc │ ├── 72.cc │ ├── 73.cc │ ├── 74.cc │ ├── 75.cc │ ├── 76.cc │ ├── 77.cc │ ├── 78.cc │ ├── 79.txt │ ├── 80.py │ ├── 81.cc │ ├── 82.cc │ ├── 83.cc │ ├── 84.cs │ ├── 85.cc │ ├── 86.cc │ ├── 87.cc │ ├── 88.cc │ ├── 89.py │ ├── 90.py │ ├── 91.py │ ├── 92.py │ ├── 93.py │ ├── 94.py │ ├── 95.py │ ├── 96.py │ ├── 97.py │ ├── 98.cc │ └── 99.py ├── volume03 │ ├── 101.py │ ├── 102.cc │ ├── 103.cc │ ├── 104.py │ ├── 105.cc │ ├── 106.cc │ ├── 107.py │ ├── 108.py │ ├── 109.cc │ ├── 110.cc │ ├── 111.cc │ ├── 112.cc │ ├── 113.cc │ ├── 114.cc │ ├── 115.cc │ ├── 116.cc │ ├── 117.cc │ ├── 118.cc │ ├── 119.py │ ├── 120.py │ ├── 121.cc │ ├── 122.cc │ ├── 123.cc │ ├── 124.cc │ ├── 125.cc │ ├── 126.cc │ ├── 127.cc │ ├── 128.cc │ ├── 129.cc │ ├── 130.cc │ ├── 131.cc │ ├── 132.py │ ├── 133.cc │ ├── 134.cc │ ├── 135.cc │ ├── 136.cc │ ├── 137.py │ ├── 138.py │ ├── 139.cc │ ├── 140.py │ ├── 141.py │ ├── 142.py │ ├── 143.cc │ ├── 144.cc │ ├── 145.cc │ ├── 146.cc │ ├── 147.cc │ ├── 148.cc │ ├── 149.cc │ └── 150.cc ├── volume04 │ ├── 151.cc │ ├── 152.cc │ ├── 153.cc │ ├── 154.cc │ ├── 155.py │ ├── 156.cc │ ├── 157.cc │ ├── 158.py │ ├── 159.cc │ ├── 160.cc │ ├── 162.cc │ ├── 163.py │ ├── 164.cc │ ├── 165.cc │ ├── 166.cc │ ├── 167.cc │ ├── 168.py │ ├── 169.cc │ ├── 170.cc │ ├── 171.cc │ ├── 172.cc │ ├── 173.py │ ├── 174.py │ ├── 175.py │ ├── 176.py │ ├── 177.cc │ ├── 178.cc │ ├── 179.cc │ ├── 180.cc │ ├── 181.cc │ ├── 182.cc │ ├── 183.py │ ├── 184.cc │ ├── 185.cc │ ├── 186.cc │ ├── 187.cc │ ├── 188.cc │ ├── 189.cc │ ├── 190.py │ ├── 191.cc │ ├── 192.py │ ├── 193.cc │ ├── 194.cc │ ├── 195.cc │ ├── 196.cc │ ├── 197.py │ ├── 198.py │ ├── 199.py │ └── 200.cc ├── volume05 │ ├── 201.cc │ ├── 202.cc │ ├── 203.py │ ├── 204.cc │ ├── 205.cc │ ├── 206.cc │ ├── 207.cc │ ├── 208.cc │ ├── 209.cc │ ├── 210.cc │ ├── 211.cc │ ├── 212.cc │ ├── 213.cc │ ├── 214.cc │ ├── 215.cc │ ├── 216.cc │ ├── 217.cc │ ├── 218.cc │ ├── 219.cc │ ├── 220.cc │ ├── 221.cc │ ├── 222.cc │ ├── 223.cc │ ├── 224.cc │ ├── 225.cc │ ├── 226.cc │ ├── 227.cc │ ├── 228.cc │ ├── 229.cc │ ├── 230.cc │ ├── 231.cc │ ├── 232.cc │ ├── 233.cc │ ├── 234.cc │ ├── 235.cc │ ├── 236.cc │ ├── 237.cc │ ├── 238.cc │ ├── 239.py │ ├── 240.cc │ ├── 241.cc │ ├── 242.cc │ ├── 243.cc │ ├── 244.cc │ ├── 245.cc │ ├── 246.cc │ ├── 247.cc │ ├── 248.cc │ ├── 249.cc │ └── 250.cc ├── volume06 │ ├── 251.cc │ ├── 252.cc │ ├── 253.cc │ ├── 254.cc │ ├── 255.cc │ ├── 256.cc │ ├── 257.cc │ ├── 258.cc │ ├── 259.cc │ ├── 260.cc │ ├── 261.py │ ├── 262.cc │ ├── 263.cc │ ├── 264.cc │ ├── 265.cc │ ├── 266.cc │ ├── 267.cc │ ├── 268.cc │ ├── 269.cc │ ├── 270.cc │ ├── 271.py │ ├── 272.cc │ ├── 273.cc │ ├── 274.cc │ ├── 275.cc │ ├── 276.cc │ ├── 277.py │ ├── 278.cc │ ├── 279.cc │ ├── 280.cc │ ├── 281.py │ ├── 282.cc │ ├── 283.cc │ ├── 284.cc │ ├── 285.cc │ ├── 286.cc │ ├── 287.cc │ ├── 288.cc │ ├── 289.cc │ ├── 290.cc │ ├── 291.cc │ ├── 292.cc │ ├── 293.cc │ ├── 294.cc │ ├── 295.cc │ ├── 296.cc │ ├── 297.cc │ ├── 298.cc │ ├── 299.cc │ └── 300.cc ├── volume07 │ ├── 301.cc │ ├── 302.cc │ ├── 303.cc │ ├── 304.cc │ ├── 306.cc │ ├── 307.cc │ ├── 308.py │ ├── 309.cc │ ├── 310.cc │ ├── 311.cc │ ├── 312.py │ ├── 313.cc │ ├── 314.cc │ ├── 315.cc │ ├── 316.py │ ├── 317.py │ ├── 318.py │ ├── 319.cc │ ├── 320.cc │ ├── 321.py │ ├── 322.cc │ ├── 323.cc │ ├── 324.cc │ ├── 325.py │ ├── 326.py │ ├── 327.py │ ├── 328.cc │ ├── 329.py │ ├── 330.py │ ├── 331.cc │ ├── 332.cc │ ├── 333.py │ ├── 334.py │ ├── 335.cc │ ├── 336.cc │ ├── 337.cc │ ├── 340.cc │ ├── 341.py │ ├── 342.cc │ ├── 343.cc │ ├── 345.cc │ ├── 346.cc │ ├── 347.cc │ ├── 348.cc │ ├── 349.cc │ └── 350.cc ├── volume08 │ ├── 351.cc │ ├── 357.cc │ ├── 358.cc │ ├── 359.cc │ ├── 365.cc │ ├── 371.cc │ ├── 377.cc │ ├── 378.cc │ ├── 381.cc │ ├── 387.cc │ ├── 389.cc │ └── 396.cc ├── volume09 │ ├── 401.cc │ ├── 407.cc │ ├── 425.cc │ ├── 429.cc │ ├── 432.cc │ ├── 435.cc │ ├── 443.cc │ └── 448.cc ├── volume10 │ ├── 451.cc │ ├── 458.cc │ ├── 461.cc │ ├── 463.cc │ ├── 479.py │ ├── 485.cc │ ├── 491.cc │ ├── 493.cc │ └── 500.cc ├── volume11 │ ├── 501.cc │ ├── 502.cc │ ├── 504.cc │ ├── 509.cc │ ├── 510.cc │ ├── 511.cc │ ├── 512.cc │ ├── 513.cc │ ├── 516.cc │ ├── 518.cc │ ├── 521.cc │ ├── 523.py │ ├── 531.cc │ ├── 537.cc │ ├── 538.cc │ ├── 539.cc │ ├── 540.cc │ ├── 542.cc │ ├── 543.cc │ ├── 545.cc │ ├── 547.cc │ ├── 548.cc │ ├── 549.cc │ └── 550.cc ├── volume12 │ ├── 551.cc │ ├── 552.cc │ ├── 553.cc │ ├── 554.cc │ ├── 555.py │ ├── 556.cc │ ├── 557.cc │ ├── 558.py │ ├── 559.cc │ ├── 560.cc │ ├── 561.cc │ ├── 562.cc │ ├── 563.cc │ ├── 564.cc │ ├── 565.cc │ ├── 566.cc │ ├── 567.cc │ ├── 568.py │ ├── 569.cc │ ├── 570.cc │ ├── 571.cc │ ├── 572.cc │ ├── 573.cc │ ├── 574.cc │ ├── 575.py │ ├── 576.cc │ ├── 577.m │ ├── 578.cc │ ├── 580.cc │ ├── 582.m │ ├── 583.cc │ ├── 587.cc │ ├── 588.cc │ ├── 590.cc │ ├── 592.py │ ├── 593.cc │ ├── 594.py │ └── 599.py └── volume13 │ ├── 601.py │ ├── 603.cc │ ├── 604.cc │ ├── 605.cc │ ├── 606.cc │ ├── 607.cc │ ├── 608.cc │ ├── 609.cc │ ├── 611.cc │ ├── 612.cc │ ├── 613.m │ ├── 614.cc │ └── 616.cc ├── rosecode ├── 1.py ├── 10.py ├── 111.cc ├── 112.cc ├── 113.py ├── 2.py ├── 3.py ├── 315.cc ├── 346.sage ├── 347.cc ├── 349.py ├── 354.cc ├── 358.py ├── 359.cc ├── 360.cc ├── 361.cc ├── 362.cc ├── 364.cc ├── 367.cc ├── 370.cc ├── 392.py ├── 396.py ├── 397.cc ├── 398.py ├── 399.py ├── 4.py ├── 402.py ├── 403.cc ├── 404.cc ├── 406.cc ├── 407.cc ├── 411.cc ├── 412.cc ├── 413.cc ├── 415.cc ├── 416.cc ├── 418.cc ├── 428.py ├── 430.py ├── 436.py ├── 437.cc ├── 438.cc ├── 439.py ├── 440.cc ├── 443.cc ├── 444.py ├── 447.cc ├── 448.cc ├── 450.py ├── 455.cc ├── 5.py ├── 6.py ├── 60.cc ├── 7.py ├── 78.py ├── 79.py ├── 8.py ├── 82.py ├── 83.py └── 9.py ├── russian-code-cup ├── 2011 │ ├── elimination-round │ │ ├── A.py │ │ ├── B.py │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ └── F.cc │ ├── qualification-round-1 │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ └── E.py │ ├── qualification-round-2 │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.py │ │ ├── D.py │ │ └── E.cc │ └── qualification-round-3 │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ └── E.cc ├── 2016 │ ├── elimination-round │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ └── F.cc │ ├── final-round │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ └── F.cc │ ├── qualification-round-1 │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ └── E.cc │ ├── qualification-round-2 │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ └── E.cc │ ├── qualification-round-3 │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ └── E.cc │ └── warmup-round │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ └── E.cc └── 2017 │ ├── elimination-round │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc │ ├── qualification-round-1 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc │ ├── qualification-round-2 │ ├── A.cc │ ├── B.py │ ├── C.cc │ ├── D.cc │ └── E.cc │ ├── qualification-round-3 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc │ └── warmup-round │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── russian-olympiad-in-informatics ├── 2016-2017 │ └── roi-2017 │ │ └── 1.cc ├── 2018-2019 │ └── roi-2019 │ │ └── 8.cc └── 2019-2020 │ └── vkoshp-19 │ └── E.cc ├── sgu ├── 100.cc ├── 101.cc ├── 102.cc ├── 103.cc ├── 104.cc ├── 105.cc ├── 106.cc ├── 107.cc ├── 108.cc ├── 109.cc ├── 110.cc ├── 111.py ├── 112.py ├── 113.cc ├── 114.cc ├── 115.cc ├── 116.cc ├── 117.cc ├── 118.cc ├── 119.cc ├── 120.cc ├── 121.cc ├── 122.cc ├── 123.py ├── 124.cc ├── 125.cc ├── 126.cc ├── 127.cc ├── 128.cc ├── 129.cc ├── 130.cc ├── 131.cc ├── 132.cc ├── 133.cc ├── 134.cc ├── 135.cc ├── 136.cc ├── 137.cc ├── 138.cc ├── 139.cc ├── 140.cc ├── 141.cc ├── 142.cc ├── 143.cc ├── 154.cc ├── 160.cc ├── 162.cc ├── 168.cc ├── 169.cc ├── 170.cc ├── 171.cc ├── 172.cc ├── 174.cc ├── 175.cc ├── 176.cc ├── 177.cc ├── 178.cc ├── 179.cc ├── 180.cc ├── 181.cc ├── 182.cc ├── 183.cc ├── 184.cc ├── 185.cc ├── 186.cc ├── 187.cc ├── 188.cc ├── 189.cc ├── 190.cc ├── 191.cc ├── 192.cc ├── 193.py ├── 194.cc ├── 195.cc ├── 196.cc ├── 197.java ├── 198.cc ├── 199.cc ├── 200.cc ├── 275.cc ├── 491.cc ├── 542.cc ├── 543.cc ├── 544.cc ├── 546.cc ├── 547.cc ├── 548.cc ├── 549.cc ├── 550.cc ├── 551.cc ├── 552.cc └── 553.cc ├── snarknews-winter-series └── 2020 │ ├── round1 │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc │ ├── round2 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc │ ├── round3 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ ├── E.cc │ └── F.cc │ ├── round4 │ ├── A.cc │ ├── B.cc │ ├── D.cc │ └── F.cc │ └── round5 │ ├── A.cc │ ├── B.cc │ ├── C.cc │ ├── D.cc │ └── E.cc ├── solve.edu.pl └── pod6.cc ├── spoj ├── A001856.py ├── ABA12C.cc ├── ABA12D.cc ├── ADABANKET.cc ├── ADABASH.sh ├── ADABRANC.cc ├── ADACHERY.cc ├── ADACHES2.cc ├── ADACHESS.cc ├── ADACITRS.cc ├── ADACROP.cc ├── ADACUT.cc ├── ADADIG.cc ├── ADADIGIT.cc ├── ADAFEAR.cc ├── ADAFIMBR.cc ├── ADAFRIEN.cc ├── ADAFTBLL.cc ├── ADAFUROW.cc ├── ADAGAME4.cc ├── ADAGAME5.cc ├── ADAGF.cc ├── ADAGRAFT.cc ├── ADAHLIA.cc ├── ADAHOSE.cc ├── ADAJOBS.cc ├── ADAKOHL.cc ├── ADALEMON.cc ├── ADAM1.cc ├── ADAMOLD.cc ├── ADAPANEL.cc ├── ADAPET.cc ├── ADAPHONE.cc ├── ADAPHOTO.cc ├── ADAPLNTS.cc ├── ADAPRIME.cc ├── ADARAIN.cc ├── ADAROADS.cc ├── ADASALE.cc ├── ADASEQEN.cc ├── ADASETS.cc ├── ADASQR.cc ├── ADASTRNG.cc ├── ADASUM.cc ├── ADATOMAT.cc ├── ADATOMEL.cc ├── ADATREE.cc ├── ADAUSORT.cc ├── ADAXMAS.cc ├── ADRABR.cc ├── AGPREFX.py ├── AJOB.cc ├── APIO14_A.cc ├── APS.cc ├── APS2.cc ├── ARCTAN.cc ├── AROPE.cc ├── AROPE3.cc ├── ARRHUDAI.cc ├── ASSIST.cc ├── BALANCE1PARA.cc ├── BAPM.cc ├── BILLI.cc ├── BIO.cc ├── BLOPER2.cc ├── BOI02TRI.cc ├── BOI7ESC.cc ├── BOI7FEN.cc ├── BOI7SEQ.cc ├── BOI7SOU.cc ├── BRCKTS.cc ├── BYTESE2.cc ├── CANDY4.cc ├── CATER.cc ├── CDGLF3.cc ├── CNTINDX.cc ├── CODEWRECK4.cc ├── COLORSEG.cc ├── CONOR.cc ├── COT.cc ├── COT2.cc ├── CS.cc ├── CTRICK.cc ├── CTTC.cc ├── CUTSQRS.cc ├── DETER2.cc ├── DETER3.cc ├── DISGRAPH.cc ├── DIVCNT1.cc ├── DIVCNT2.cc ├── DIVCNT3.cc ├── DIVCNTK.cc ├── DIVEQL.cc ├── DIVFACT.cc ├── DIVFACT2.cc ├── DIVFACT3.cc ├── DIVFACT4.cc ├── DIVISION.cc ├── DORTMUND.cc ├── DOUGHNUT.cc ├── DQUERY.cc ├── DRAWIT.cc ├── DTPOLY.cc ├── DTPOLY2.cc ├── DUKKAR.cc ├── DUKKAR2.cc ├── DYEL.py ├── EASYFACT.cc ├── ELEC.cc ├── ESYR.cc ├── EXLAGFIB.cc ├── FACEFRND.cc ├── FASTFLOW.cc ├── FINDLR.cc ├── FREQ2.cc ├── FREQUENT.cc ├── FRMT.cc ├── FRNDAM.cc ├── FRS2.py ├── FRSKH.cc ├── FRSKT.cc ├── FTOUR2.cc ├── FUKU11J.cc ├── GCD2.py ├── GEMS.cc ├── GSS1.cc ├── GSS2.cc ├── GSS3.cc ├── GSS4.cc ├── HAGU.cc ├── HDEVIL.cc ├── HISTOGRA.cc ├── HORRIBLE.cc ├── HRSIAM.cc ├── HUSGAME.cc ├── IGAME.cc ├── INCDSEQ.cc ├── INCSEQ.cc ├── INS17M.cc ├── INTDSET.cc ├── INTDSET2.cc ├── INTSUB.cc ├── INUM.cc ├── INVCNT.cc ├── IQUERY.cc ├── ISELECT.cc ├── JGTLE.cc ├── JLNT.cc ├── KDOMINO.cc ├── KGSS.cc ├── KHANS.cc ├── KNIGHTSG.cc ├── KPRIMES2.cc ├── KQUERY.cc ├── LARMY.cc ├── LCS0.cc ├── LEXSTR.cc ├── LITE.cc ├── MAIN75.cc ├── MATHII.cc ├── MATSUM.cc ├── MAXMATCH.cc ├── MCIRCLE.cc ├── MDST.cc ├── MEANARR.cc ├── MINSUB.cc ├── MINVSMIN.cc ├── MKTHNUM.cc ├── MOHIB.cc ├── MSE06H.cc ├── MUL.cc ├── MULTII.cc ├── MULTQ3.cc ├── NESPALIN.java ├── NICEDAY.cc ├── NKDIV.cc ├── NNS.cc ├── NSUBSTR.cc ├── NTG.cc ├── NTHPRIME.cc ├── OPMODULO.cc ├── ORDERS.cc ├── ORDERSET.cc ├── PALMKR.cc ├── PARCARD2.cc ├── PAUL2.cc ├── PBBN2.py ├── PCOPTRIP.cc ├── PELL2.py ├── PERIOD2.cc ├── PERMRANK.cc ├── PHONELST.cc ├── PIHEX2.cc ├── PISANO.cc ├── POP1.cc ├── POP2.cc ├── PRIMES2.cc ├── PRINT.cc ├── PRO.cc ├── PSFWORDS.cc ├── PT07C.cc ├── PT07J.cc ├── PTRI.cc ├── PUCMMT02.cc ├── QTREE.cc ├── QTREE2.cc ├── QTREE5.cc ├── RACETIME.cc ├── RATING.cc ├── RENT.cc ├── RSHIFT.cc ├── RSORTING.cc ├── RTREE.cc ├── SAS001.cc ├── SAS002.cc ├── SEGSQRSS.cc ├── SELECTION.cc ├── SEUG.cc ├── SHAREIT.cc ├── SHPGM.cc ├── SIMPLEPATH.cc ├── SNIM.cc ├── SOLVEIT.cc ├── SORTOUT.cc ├── SPCU.cc ├── STRMATCH.cc ├── SUFFIX.py ├── SUMMATION.cc ├── TAKIN.cc ├── TANDC.py ├── TDPRIME.cc ├── TDPRIMES.cc ├── TEST.cc ├── THFANDM.cc ├── THREENUMBERS.cc ├── TPCPALIN.cc ├── TPCPPLAR.cc ├── TPGA.cc ├── TPGAME.cc ├── TREEDEGREE.cc ├── TREENUM2.cc ├── TRI2.cc ├── TSUM.cc ├── TWINP.cc ├── TWINP2.cc ├── UCBINTB.cc ├── UCBINTC.cc ├── UCBINTD.cc ├── UCBINTF.cc ├── UCBINTG.cc ├── UCBINTH.cc ├── UCBINTI.cc ├── UCBINTJ.cc ├── UCF.cc ├── UJ01.cc ├── URD.cc ├── VDATE.cc ├── VFMUL.cc ├── VGCD.py ├── WALK1.cc ├── WILD.cc ├── WORDCNT2.cc ├── WPC5A.cc ├── WPC5D.cc ├── WPC5E.cc ├── WPC5G.cc ├── WPC5H.cc ├── WPC5I.cc ├── WRP.cc ├── WTFM.cc ├── XXXXXXXX.cc ├── YASSP.cc ├── YODANESS.cc └── ZQUERY.cc ├── topcoder ├── 2019 Topcoder Open Algo │ ├── FamilySeatingArrangement.cpp │ ├── FamilySeatingArrangement.html │ ├── FamilySeatingArrangement.sample │ ├── TwoLineRegions.cpp │ ├── TwoLineRegions.html │ ├── TwoLineRegions.sample │ ├── WaitingForBusAgain.cpp │ ├── WaitingForBusAgain.html │ └── WaitingForBusAgain.sample ├── 2020 Humblefool Prelim │ ├── CardDrawPoints.cpp │ ├── CardDrawPoints.sample │ ├── NonSimilarTriangles.cpp │ ├── NonSimilarTriangles.sample │ ├── ScoringJudges.cpp │ └── ScoringJudges.sample ├── Greed-2.0-RC-7.1.0.jar ├── SRM 452 │ ├── IOIString.cpp │ ├── IOIString.html │ ├── IOIString.sample │ ├── IncreasingNumber.cpp │ ├── IncreasingNumber.html │ ├── IncreasingNumber.sample │ ├── NotTwo.cpp │ ├── NotTwo.html │ └── NotTwo.sample ├── SRM 774 │ ├── ClassRankings.cpp │ ├── ClassRankings.html │ ├── ClassRankings.sample │ ├── FillInTheDAG.cpp │ ├── FillInTheDAG.html │ ├── FillInTheDAG.sample │ ├── LandSplitter.cpp │ ├── LandSplitter.html │ └── LandSplitter.sample ├── SRM 775 │ ├── FairSplit.cpp │ ├── FairSplit.html │ ├── FairSplit.sample │ ├── IterateOverACube.cpp │ ├── IterateOverACube.html │ └── IterateOverACube.sample ├── SRM 778 │ ├── CollectingCoins.cpp │ ├── CollectingCoins.sample │ ├── DominoPlacement.cpp │ ├── DominoPlacement.sample │ ├── KRectangleIntersection.cpp │ └── KRectangleIntersection.sample ├── SRM 779 │ ├── ArraySorting.cpp │ ├── ArraySorting.sample │ ├── ParadePlanner.cpp │ ├── ParadePlanner.sample │ ├── SubstringQueries.cpp │ └── SubstringQueries.sample ├── SRM 780 │ ├── BeatTheStar.cpp │ ├── BeatTheStar.sample │ ├── Prominence.cpp │ ├── Prominence.sample │ ├── RestrictedLeaves.cpp │ └── RestrictedLeaves.sample ├── SRM 781 │ ├── EpicPartition.cpp │ ├── EpicPartition.sample │ ├── RandomPartition.cpp │ ├── RandomPartition.sample │ ├── RoseDressGame.cpp │ └── RoseDressGame.sample ├── SRM 782 │ ├── PaintItBlack.cpp │ ├── PaintItBlack.html │ └── PaintItBlack.sample ├── TCO 2015 Round 2A │ ├── ModModMod.cpp │ ├── ModModMod.html │ └── ModModMod.sample ├── TCO 2017 Round 1A │ ├── CheeseSlicing.java │ ├── CheeseSlicing.tctask │ ├── PingPongQueue.java │ ├── PingPongQueue.tctask │ ├── PolygonRotation.java │ └── PolygonRotation.tctask ├── TCO 2017 Round 1B │ ├── CoinConstruction.cpp │ ├── CoinConstruction.html │ ├── CoinConstruction.sample │ ├── SubtreeSumHash.cpp │ ├── SubtreeSumHash.html │ ├── SubtreeSumHash.sample │ ├── WaterAndOxygen.cpp │ ├── WaterAndOxygen.html │ └── WaterAndOxygen.sample ├── TCO 2017 Round 1C │ ├── EllysRPS.cpp │ ├── EllysRPS.html │ ├── EllysRPS.sample │ ├── EllysTickets.cpp │ ├── EllysTickets.html │ ├── EllysTickets.sample │ ├── EllysWordCoins.cpp │ ├── EllysWordCoins.html │ └── EllysWordCoins.sample ├── TCO 2017 Round 2A │ ├── DistanceZeroAndOne.cpp │ ├── DistanceZeroAndOne.html │ ├── DistanceZeroAndOne.sample │ ├── FoxAndCake2.cpp │ ├── FoxAndCake2.html │ └── FoxAndCake2.sample ├── TCO 2017 Round 2B │ ├── DengklekGaneshAndChains.cpp │ ├── DengklekGaneshAndChains.html │ ├── DengklekGaneshAndChains.sample │ ├── DengklekGaneshAndDetention.cpp │ ├── DengklekGaneshAndDetention.html │ ├── DengklekGaneshAndDetention.sample │ ├── DengklekGaneshAndTree.cpp │ ├── DengklekGaneshAndTree.html │ └── DengklekGaneshAndTree.sample ├── TCO 2018 Round 1A │ ├── Deadfish.cpp │ ├── Deadfish.html │ ├── Deadfish.sample │ ├── RedDragonInn.cpp │ ├── RedDragonInn.html │ ├── RedDragonInn.sample │ ├── Resistance.cpp │ ├── Resistance.html │ └── Resistance.sample ├── TCO 2019 Round 1A │ ├── EllysAndXor.cpp │ ├── EllysAndXor.html │ └── EllysAndXor.sample ├── TCO 2019 Round 2A │ ├── Byes.cpp │ ├── Byes.html │ ├── Byes.sample │ ├── RulerMaker.cpp │ ├── RulerMaker.html │ ├── RulerMaker.sample │ ├── YetAnotherTokenGame.cpp │ ├── YetAnotherTokenGame.html │ └── YetAnotherTokenGame.sample └── TCO17 Beijing │ ├── Ellys8Bit.cpp │ ├── Ellys8Bit.html │ ├── Ellys8Bit.sample │ ├── EllysBottles.cpp │ ├── EllysBottles.html │ ├── EllysBottles.sample │ ├── EllysPrimePals.cpp │ ├── EllysPrimePals.html │ └── EllysPrimePals.sample ├── usaco └── 2019-2020 │ ├── Dec 2019 │ ├── Gold │ │ ├── cowmbat.cc │ │ ├── milkvisits.cc │ │ └── pump.cc │ └── Plat │ │ ├── pieaters.cc │ │ ├── snowcow.cc │ │ └── treedepth.cc │ └── Jan 2020 │ └── Plat │ ├── cave.cc │ ├── falling.cc │ └── nondec.cc ├── winter-camp └── 2011 │ └── xor.cc ├── yandex-algorithm ├── 2015 │ └── round2.2 │ │ └── F.cc ├── 2017 │ ├── round1 │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ └── F.cc │ └── warmup-round │ │ ├── A.cc │ │ ├── B.cc │ │ ├── C.cc │ │ ├── D.cc │ │ ├── E.cc │ │ └── F.cc └── 2018 │ └── round1 │ └── F.cc ├── yukicoder ├── 1.java ├── 10.py ├── 11.py ├── 12.py ├── 13.py ├── 14.py ├── 15.py ├── 16.py ├── 17.py ├── 18.py ├── 19.py ├── 2.java ├── 20.py ├── 21.py ├── 22.py ├── 23.py ├── 24.py ├── 25.py ├── 26.py ├── 27.py ├── 28.py ├── 29.py ├── 3.java ├── 30.py ├── 3000.py ├── 3001.py ├── 3002.py ├── 3016.cc ├── 3017.py ├── 3019.py ├── 3020.py ├── 3021.py ├── 3022.py ├── 3023.py ├── 3024.py ├── 3025.py ├── 3026.py ├── 3027.py ├── 3028.py ├── 3029.py ├── 3030.py ├── 31.py ├── 32.py ├── 33.py ├── 337.py ├── 34.py ├── 35.py ├── 36.py ├── 37.py ├── 38.py ├── 39.py ├── 4.java ├── 40.py ├── 41.py ├── 42.py ├── 43.py ├── 44.py ├── 45.py ├── 450.java ├── 451.java ├── 452.java ├── 453.java ├── 454.java ├── 455.java ├── 456.cc ├── 457.java ├── 458.java ├── 459.py ├── 46.py ├── 469.py ├── 47.py ├── 476.java ├── 477.java ├── 478.java ├── 479.java ├── 48.py ├── 480.java ├── 481.java ├── 482.java ├── 483.java ├── 484.java ├── 485.java ├── 486.py ├── 487.py ├── 488.java ├── 489.java ├── 49.py ├── 490.java ├── 491.java ├── 492.java ├── 493.java ├── 494.java ├── 495.java ├── 496.java ├── 497.java ├── 498.java ├── 499.java ├── 5.java ├── 50.py ├── 500.java ├── 501.java ├── 502.java ├── 589.py ├── 591.py ├── 597.py ├── 598.py ├── 599.py ├── 6.java ├── 600.py ├── 601.cc ├── 602.cc ├── 603.py ├── 604.cc ├── 605.cc ├── 606.cc ├── 607.cc ├── 608.cc ├── 609.cc ├── 610.py ├── 611.py ├── 612.py ├── 613.cc ├── 614.cc ├── 615.py ├── 616.cc ├── 626.cc ├── 67.cc ├── 7.java ├── 8.py ├── 9.py ├── 9000.py ├── 9001.py ├── 9002.py ├── 9003.py ├── 9004.py ├── 9005.py ├── 9006.py ├── 9007.py ├── 9008.py ├── 9009.py ├── 9010.py ├── 9011.py └── 9012.py └── zoj ├── 3808.cc └── 3970.cc /.gitignore: -------------------------------------------------------------------------------- 1 | *.in 2 | *.out 3 | input 4 | output 5 | *.exe 6 | .vscode 7 | *.dSYM 8 | .DS_Store 9 | -------------------------------------------------------------------------------- /.rustfmt.toml: -------------------------------------------------------------------------------- 1 | max_width = 120 -------------------------------------------------------------------------------- /LibreOJ/10208.py: -------------------------------------------------------------------------------- 1 | from fractions import gcd 2 | 3 | a = int(input()) 4 | b = int(input()) 5 | print(gcd(a, b)) 6 | -------------------------------------------------------------------------------- /LibreOJ/10209.py: -------------------------------------------------------------------------------- 1 | from math import gcd 2 | 3 | def exgcd(a, b): 4 | if b == 0: 5 | return 1, 0 6 | else: 7 | x, y = exgcd(b, a % b) 8 | x -= a // b * y 9 | return y, x 10 | 11 | x, y, m, n, L = map(int, input().split()) 12 | a = n - m 13 | b = L 14 | c = x - y 15 | r = gcd(a, b) 16 | if c % r != 0: 17 | print("Impossible") 18 | else: 19 | a //= r 20 | b //= r 21 | c //= r 22 | x, y = exgcd(a, b) 23 | t = c * x // b 24 | x = x * c - t * b 25 | if x < 0: 26 | x += b 27 | print(x) 28 | -------------------------------------------------------------------------------- /LibreOJ/10211.py: -------------------------------------------------------------------------------- 1 | mod = 9901 2 | 3 | a, b = map(int, input().split()) 4 | if a == 0: 5 | print(0) 6 | exit(0) 7 | p = [] 8 | i = 2 9 | while i * i <= a: 10 | if a % i == 0: 11 | c = 0 12 | while a % i == 0: 13 | c += 1 14 | a //= i 15 | p.append((i, c * b)) 16 | i += 1 17 | if a > 1: 18 | p.append((a, b)) 19 | r = 1 20 | for (i, e) in p: 21 | inv = pow(i - 1, mod - 2, mod) 22 | r = r * inv * (pow(i, e + 1, mod) - 1 + mod) % mod 23 | print(r) 24 | -------------------------------------------------------------------------------- /LibreOJ/110.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const int N = 3e6 + 10; 4 | 5 | int inv[N]; 6 | 7 | int main() { 8 | int n, p; 9 | scanf("%d%d", &n, &p); 10 | inv[1] = 1; 11 | for (int i = 2; i <= n; ++i) { 12 | inv[i] = (long long)(p - p / i) * inv[p % i] % p; 13 | } 14 | for (int i = 1; i <= n; ++i) { 15 | printf("%d\n", inv[i]); 16 | } 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /LibreOJ/4.py: -------------------------------------------------------------------------------- 1 | _='_=%r;print _%%_';print _%_ 2 | -------------------------------------------------------------------------------- /LibreOJ/6.cc: -------------------------------------------------------------------------------- 1 | #include "interaction.h" 2 | 3 | int guess(int index) { 4 | int l = 0, r = 1000000; 5 | while (l < r) { 6 | int m = (l + r) >> 1; 7 | int res = guess(index, m); 8 | if (res == 0) return m; 9 | if (res == -1) l = m + 1; 10 | else r = m - 1; 11 | } 12 | return l; 13 | } 14 | 15 | int main() { 16 | int n = get_num(); 17 | std::vector res(n); 18 | for (int i = 0; i < n; ++i) { 19 | res[i] = guess(i); 20 | } 21 | submit(res); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /LibreOJ/6090.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, k; 6 | scanf("%d%d", &n, &k); 7 | if (k > 1) { 8 | puts("Yes"); 9 | return 0; 10 | } 11 | std::vector a(n); 12 | int zero = -1; 13 | for (int i = 0; i < n; ++i) { 14 | scanf("%d", &a[i]); 15 | if (a[i] == 0) zero = i; 16 | } 17 | scanf("%d", &a[zero]); 18 | bool flag = true; 19 | for (int i = 1; i < n; ++i) { 20 | if (a[i] <= a[i - 1]) flag = false; 21 | } 22 | if (!flag) puts("Yes"); 23 | else puts("No"); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /LibreOJ/6233.py: -------------------------------------------------------------------------------- 1 | from fractions import * 2 | n = int(raw_input()) 3 | s = 1 4 | while n > 0: 5 | a = map(int, raw_input().split()) 6 | n -= len(a) 7 | for x in a: 8 | s = s * x / gcd(s, x) 9 | b = [] 10 | while s: 11 | b.append(s % 26) 12 | s /= 26 13 | b = [chr(x + ord('a')) for x in b] 14 | b.reverse() 15 | print 'a' * len(b) 16 | print ''.join(b) 17 | -------------------------------------------------------------------------------- /LibreOJ/6368.py: -------------------------------------------------------------------------------- 1 | from math import gcd 2 | 3 | a, b = map(int, input().split()) 4 | p = 10 ** 9 + 7 5 | sign = 1 6 | if a < 0: 7 | a = -a 8 | sign = -sign 9 | if b < 0: 10 | b = -b 11 | sign = -sign 12 | if a or b: 13 | g = gcd(a, b) 14 | a //= g 15 | b //= g 16 | if b == 0 or (a != 0 and b % p == 0): 17 | print('No Solution!') 18 | else: 19 | ans = a * pow(b, p - 2, p) % p * sign 20 | print(ans) 21 | -------------------------------------------------------------------------------- /LibreOJ/6714.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int f[100]; 5 | f[1] = 1; 6 | for (int i = 2; i < 100; ++i) { 7 | f[i] = 0; 8 | for (int d = 1; d < i; ++d) if (i % d == 0) { 9 | f[i] += f[d]; 10 | } 11 | } 12 | for (int i = 1; i < 30; ++i) printf("%d, ", f[i]); 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Source Codes for Competitive Programming 2 | -------------------------------------------------------------------------------- /acm-icpc/1995/cerc/G.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int T; 5 | return 0; 6 | } 7 | -------------------------------------------------------------------------------- /acm-icpc/2016-2017/asia-qingdao-online/M.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zimpha/competitive-programming/147cb2be02917d12fdbe488c084567c9d0a7d76c/acm-icpc/2016-2017/asia-qingdao-online/M.cc -------------------------------------------------------------------------------- /acm-icpc/2018-2019/neerc-western/D.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | s = sum(map(int, input().split())) 3 | if n == 0: 4 | print(0) 5 | else: 6 | print(s / n) 7 | -------------------------------------------------------------------------------- /acm-icpc/2018-2019/neerc-western/J.py: -------------------------------------------------------------------------------- 1 | def valid(s): 2 | if len(s) != 9: return False 3 | if s[0] not in "1234567" or s[4] != ' ': return False 4 | if s[1:4] not in ["TAX", "TEX", "TBX"]: return False 5 | if s[0] != '7' and s[1:4] == "TEX": return False 6 | for c in s[5:]: 7 | if c not in "0123456789": return False 8 | if int(s[5:]) == 0: return False 9 | return True 10 | 11 | n = int(input()) 12 | ret = 0 13 | for i in range(n): 14 | s = input() 15 | ret += valid(s) 16 | print(ret) 17 | -------------------------------------------------------------------------------- /acm-icpc/2019-2020/nerc-southern-and-volga/F.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n; 6 | scanf("%d", &n); 7 | int ret = (n + 1) * 2; 8 | for (int i = 1; i <= n; ++i) if (n % i == 0) { 9 | ret = std::min(ret, 2 * (i + n / i)); 10 | } 11 | printf("%d\n", ret); 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /algorithmic-engagements/2001/han.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | print(5 * 2 ** n // 7) 3 | -------------------------------------------------------------------------------- /algorithmic-engagements/2001/pot.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | print(pow(2, n, 10)) 3 | -------------------------------------------------------------------------------- /algorithmic-engagements/2001/roz.py: -------------------------------------------------------------------------------- 1 | n = input() 2 | n = int(input()) 3 | result = 0 4 | while n > 0: 5 | if n % 2 == 1: 6 | n -= 2 - n % 4 7 | result += 1 8 | n //= 2 9 | print(result) 10 | -------------------------------------------------------------------------------- /algorithmic-engagements/2001/sil.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | int ret = 1; 7 | for (int i = 1; i <= n; ++i) { 8 | ret = ret * i % 10; 9 | } 10 | printf("%d\n", ret); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /algorithmic-engagements/2002-2/pat.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n; 6 | scanf("%d", &n); 7 | std::map cnt; 8 | for (int i = 0; i < n; ++i) { 9 | int x; 10 | scanf("%d", &x); 11 | cnt[x]++; 12 | } 13 | int ret = 0; 14 | while (!cnt.empty()) { 15 | auto v = *cnt.begin(); 16 | cnt.erase(cnt.begin()); 17 | if (v.second & 1) ++ret; 18 | if (v.second > 1) cnt[v.first * 2] += v.second / 2; 19 | } 20 | printf("%d\n", ret); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /algorithmic-engagements/2002-2/pro.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main() { 7 | std::string s; 8 | std::cin >> s; 9 | std::reverse(s.begin(), s.end()); 10 | std::cout << s << std::endl; 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /algorithmic-engagements/2002-2/szy.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int x = 1, y = 0; 5 | int n, m; 6 | scanf("%d%d", &n, &m); 7 | for (int i = 1; i <= m; ++i) { 8 | int z = (x + y) % 10; 9 | x = y; 10 | y = z; 11 | if (i >= n) printf("%d", z); 12 | } 13 | puts(""); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /algorithmic-engagements/2002/b.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | int n; 7 | scanf("%d", &n); 8 | std::vector> e; 9 | for (int i = 0; i < n; ++i) { 10 | int a, b; 11 | scanf("%d%d", &a, &b); 12 | e.emplace_back(a, +1); 13 | e.emplace_back(b + 1, -1); 14 | } 15 | std::sort(e.begin(), e.end()); 16 | int ret = 0, cnt = 0; 17 | for (auto &&x: e) { 18 | cnt += x.second; 19 | ret = std::max(ret, cnt); 20 | } 21 | printf("%d\n", ret); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /algorithmic-engagements/2002/imi.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | int ret = 0; 7 | for (int i = 0; i < n; ++i) { 8 | static char s[1000]; 9 | scanf("%s", s); 10 | int cnt[256] = {0}; 11 | for (int j = 0; s[j]; ++j) cnt[(int)s[j]]++; 12 | int count = 0; 13 | for (int j = 0; j < 256; ++j) count += !!cnt[j]; 14 | if (count > ret) ret = count; 15 | } 16 | printf("%d\n", ret); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /algorithmic-engagements/2002/min.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n; 6 | scanf("%d", &n); 7 | std::vector s(n - 1); 8 | for (int i = 0; i < n -1; ++i) { 9 | scanf(" %c", &s[i]); 10 | } 11 | for (int i = 0; i < n - 1; ++i) { 12 | if (s[i] == '-') putchar('-'); 13 | else { 14 | if (s[i - 1] == '-') putchar('('); 15 | putchar('-'); 16 | if (i == n - 2 || s[i + 1] == '-') putchar(')'); 17 | } 18 | } 19 | puts(""); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /algorithmic-engagements/2003/fib.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | std::vector f = {0, 1}; 6 | int n; 7 | scanf("%d", &n); 8 | for (int i = 2; i <= n; ++i) { 9 | f.push_back(f[i - 1] + f[i - 2]); 10 | } 11 | printf("%lld\n", f[n]); 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /algorithmic-engagements/2003/jul.py: -------------------------------------------------------------------------------- 1 | x = int(input()) 2 | y = int(input()) 3 | print((x + y) // 2) 4 | print((x - y) // 2) 5 | -------------------------------------------------------------------------------- /algorithmic-engagements/2005/bil.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | 5 | int main() { 6 | int64 n, m, sx, sy, dx, dy; 7 | scanf("%lld%lld%lld%lld%lld%lld", &n, &m, &sx, &sy, &dx, &dy); 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /algorithmic-engagements/2005/pot.py: -------------------------------------------------------------------------------- 1 | a, b = map(int, input().split()) 2 | print(pow(a, b, 10)) 3 | -------------------------------------------------------------------------------- /algorithmic-engagements/2005/sum.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using int64 = long long; 5 | 6 | int main() { 7 | int64 n; 8 | scanf("%lld", &n); 9 | int64 ret = 0; 10 | for (int x = 1; x <= n / x; ++x) { 11 | ret += n / x; 12 | } 13 | int64 v = sqrt(n); 14 | ret = ret * 2 - v * v; 15 | printf("%lld\n", ret); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /algorithmic-engagements/2005/wie.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | p = [] 3 | for i in range(n + 1): 4 | p.append(int(input())) 5 | r, b = 0, 1 6 | for i in range(n + 1): 7 | t = b * p[i] 8 | if (n - i) % 2 == 0: 9 | r += t 10 | else: 11 | r -= t 12 | b = b * (n + 1 - i) // (i + 1) 13 | print(r) 14 | -------------------------------------------------------------------------------- /algorithmic-engagements/2006/kon.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a = 1, b = 1, n; 5 | scanf("%d", &n); 6 | for (int i = 1; i < n; ++i) { 7 | int c = (a + b) % 10; 8 | a = b; 9 | b = c; 10 | } 11 | printf("%d\n", b); 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /algorithmic-engagements/2006/lot.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | int r = 1, zero = true; 7 | for (int i = 0; i < n; ++i) { 8 | int x; 9 | scanf("%d", &x); 10 | if (x) zero = false; 11 | r = r * (x + 1) % 9; 12 | } 13 | r = (r + 8) % 9; 14 | if (r == 0) r = 9; 15 | if (zero) r = 0; 16 | printf("%d\n", r); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /algorithmic-engagements/2006/odc.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | if (n == 1) puts("0"); 7 | else if (n == 2) puts("1"); 8 | else if (n == 3) puts("3"); 9 | else printf("%d\n", 3 * (n - 2)); 10 | for (int i = 0; i < n; ++i) { 11 | if (i == 0) printf("%d %d %d\n", i, 0, 1000000000); 12 | else if (i == 1) printf("%d %d %d\n", i, 100000000, 200000000); 13 | else printf("%d %d %d\n", i, 100000000 - i, 100000000 + i); 14 | } 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /algorithmic-engagements/2006/pro.py: -------------------------------------------------------------------------------- 1 | from cmath import complex 2 | 3 | def solve(a1, b1, a2, b2): 4 | u = complex(1, 0) 5 | v = complex(0, 1) 6 | while not (a1 > b1 and a2 < b2): 7 | if a2 >= b2: 8 | k = a2 // b2 9 | v = k * u + v 10 | a1 -= k * b1 11 | a2 -= k * a2 12 | else: 13 | assert a1 <= b1 14 | k = b1 // a1 15 | u = u + k * v 16 | b1 -= k * a1 17 | b2 -= k * a2 18 | return u, v 19 | -------------------------------------------------------------------------------- /algorithmic-engagements/2006/spo.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n; 6 | scanf("%d", &n); 7 | std::vector s = {2, 1, 3, 4, 7, 1, 8, 9, 7, 6, 3, 9}; 8 | printf("%d\n", s[n % s.size()]); 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /algorithmic-engagements/2006/sum.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | printf("%d\n", n * (n + 1) / 2); 7 | return 0; 8 | } 9 | -------------------------------------------------------------------------------- /algorithmic-engagements/2007/dy2.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const int N = 1e6 + 10; 5 | 6 | char s[N], t[N]; 7 | 8 | int main() { 9 | int n; 10 | scanf("%d%s%s", &n, s, t); 11 | int ret = 0; 12 | for (int i = 0; i < n; ++i) { 13 | ret += s[i] == t[i]; 14 | } 15 | printf("%d\n", ret); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /algorithmic-engagements/2007/dys.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const int N = 1e5 + 10; 4 | 5 | char s[N], t[N]; 6 | 7 | int main() { 8 | int n; 9 | scanf("%d%s%s", &n, s, t); 10 | int ret = 0; 11 | for (int i = 0; i < n; ++i) { 12 | ret += s[i] != t[i]; 13 | } 14 | printf("%d\n", ret); 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /algorithmic-engagements/2007/sam.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n1, k1, n2, k2; 5 | scanf("%d%d%d%d", &n1, &k1, &n2, &k2); 6 | printf("%d\n", n1 * k1 + n2 * k2); 7 | return 0; 8 | } 9 | -------------------------------------------------------------------------------- /algorithmic-engagements/2008/fun.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const int mod = 1e9 + 7; 5 | 6 | int main() { 7 | int n; 8 | scanf("%d", &n); 9 | std::vector cnt(n); 10 | for (int i = 0, x; i < n; ++i) { 11 | scanf("%d", &x); 12 | cnt[x - 1]++; 13 | } 14 | int ret = 1, m = n; 15 | for (int i = 0; i < n; ++i) if (cnt[i]) { 16 | ret = 1ll * ret * cnt[i] % mod; 17 | m -= 1; 18 | } 19 | for (int i = 1; i <= m; ++i) { 20 | ret = 1ll * ret * i % mod; 21 | } 22 | printf("%d\n", ret); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /algorithmic-engagements/2008/kot.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | std::vector s = { 7 | "`1234567890-=", 8 | "QWERTYUIOP[]\\", 9 | "ASDFGHJKL;'", 10 | "ZXCVBNM,./", 11 | " " 12 | }; 13 | 14 | int main() { 15 | int map[256]; 16 | for (int i = 0; i < 5; ++i) { 17 | for (auto &c: s[i]) map[(int)c] = i + 1; 18 | } 19 | std::string line; 20 | std::getline(std::cin, line); 21 | for (auto &c: line) putchar('0' + map[(int)c]); 22 | puts(""); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /algorithmic-engagements/2009/ach.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | if n == 1: 3 | print(1) 4 | elif n % 4 in [0, 1]: 5 | n //= 4 6 | x, y = 2, 1 7 | for i in range(n - 1): 8 | y *= i + 1 9 | for i in range(n * 2 - 1): 10 | x *= i + 1 11 | print(x // y) 12 | else: 13 | print(0) 14 | -------------------------------------------------------------------------------- /algorithmic-engagements/2009/deb.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const int N = 1e6 + 10; 5 | 6 | char s[N]; 7 | 8 | int main() { 9 | int n, m; 10 | scanf("%d%d", &m, &n); 11 | scanf("%s", s); 12 | n *= 2; 13 | for (int i = 1; i < m; ) { 14 | if (s[i] != s[i - 1]) { 15 | s[i] = s[i - 1] = 0; 16 | i += 2; 17 | n -= 2; 18 | } else { 19 | ++i; 20 | } 21 | } 22 | if (s[m - 1]) --n; 23 | printf("%d\n", std::max(0, n)); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /algorithmic-engagements/2009/pro.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | int r = 0; 7 | for (int x = 1; x <= n; ++x) { 8 | r += n / x; 9 | if (x * x <= n) ++r; 10 | } 11 | printf("%d\n", r / 2); 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /algorithmic-engagements/2009/prs.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n; 6 | scanf("%d", &n); 7 | int v = sqrt(n); 8 | long long r = 0; 9 | for (int x = 1; x <= v; ++x) { 10 | r += n / x; 11 | } 12 | printf("%lld\n", r - v * (v - 1) / 2); 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /algorithmic-engagements/2009/sto.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | int n, k, s; 7 | scanf("%d%d%d", &n, &k, &s); 8 | std::vector a(n); 9 | for (int i = 0; i < n; ++i) { 10 | scanf("%d", &a[i]); 11 | } 12 | std::sort(a.begin(), a.end()); 13 | int ret = 0; 14 | s = s * k; 15 | while (!a.empty() && s > 0) { 16 | s -= a.back(); 17 | a.pop_back(); 18 | ++ret; 19 | } 20 | printf("%d\n", ret); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /algorithmic-engagements/2010/fib.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | return 0; 5 | } 6 | -------------------------------------------------------------------------------- /algorithmic-engagements/2010/pro.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, m, p; 5 | scanf("%d%d%d", &n, &m, &p); 6 | int ret = 0; 7 | for (int i = 1; i <= n; ++i) { 8 | for (int j = 1; j <= m; ++j) { 9 | if ((i + j) * 2 >= p) ret += (n - i + 1) * (m - j + 1); 10 | } 11 | } 12 | printf("%d\n", ret); 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /algorithmic-engagements/2010/prs.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, m, p; 6 | scanf("%d%d%d", &n, &m, &p); 7 | long long ret = 0; 8 | for (int i = 1; i <= n; ++i) { 9 | for (int j = std::max(1, p / 2 - i); j <= m; ++j) { 10 | if ((i + j) * 2 >= p) ret += (n - i + 1) * (m - j + 1); 11 | } 12 | } 13 | printf("%lld\n", ret); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /algorithmic-engagements/2011/tul.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n; 6 | scanf("%d", &n); 7 | std::set s; 8 | for (int i = 0; i < n; ++i) { 9 | int x; 10 | scanf("%d", &x); 11 | s.insert(x); 12 | } 13 | printf("%d\n", 15000 - (int)s.size()); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /algorithmic-engagements/2019/win.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, k; 6 | while (scanf("%d%d", &n, &k) == 2) { 7 | int ret = 2019; 8 | for (int i = 0; i < n; ++i) { 9 | for (int j = 0, x; j <= i; ++j) { 10 | scanf("%d", &x); 11 | int cnt = (j + 1) * (i - j + 1); 12 | if (cnt <= k) ret = std::min(ret, x); 13 | } 14 | } 15 | printf("%d\n", ret); 16 | } 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /atcoder/abc154/A.py: -------------------------------------------------------------------------------- 1 | S, T = input().split() 2 | A, B = map(int, input().split()) 3 | U = input() 4 | if U == S: 5 | print(A - 1, B) 6 | else: 7 | print(A, B - 1) 8 | -------------------------------------------------------------------------------- /atcoder/abc154/B.py: -------------------------------------------------------------------------------- 1 | print('x' * len(input())) 2 | -------------------------------------------------------------------------------- /atcoder/abc154/C.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | s = set(map(int, input().split())) 3 | print('YES' if len(s) == n else 'NO') 4 | -------------------------------------------------------------------------------- /atcoder/abc154/D.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, k; 6 | scanf("%d%d", &n, &k); 7 | std::vector sum(n + 1); 8 | double ret = 0; 9 | for (int i = 1; i <= n; ++i) { 10 | int p; 11 | scanf("%d", &p); 12 | sum[i] = (p + 1) * 0.5 + sum[i - 1]; 13 | if (i >= k && sum[i] - sum[i - k] >= ret) ret = sum[i] - sum[i - k]; 14 | } 15 | printf("%.10f\n", ret); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /atcoder/abc155/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b, c; 5 | scanf("%d%d%d", &a, &b, &c); 6 | if ((a == b && a != c) || (a == c && a != b) || (b == c && a != b)) puts("Yes"); 7 | else puts("No"); 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /atcoder/abc155/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | int ret = 1; 7 | for (int i = 0, x; i < n; ++i) { 8 | scanf("%d", &x); 9 | ret &= (x % 2 == 1) || (x % 3 == 0) || (x % 5 == 0); 10 | } 11 | if (ret) puts("APPROVED"); 12 | else puts("DENIED"); 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /atcoder/abc155/C.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | int n; 7 | std::cin >> n; 8 | std::map mp; 9 | for (int i = 0; i < n; ++i) { 10 | std::string s; 11 | std::cin >> s; 12 | mp[s]++; 13 | } 14 | int mx = 0; 15 | for (auto &e: mp) { 16 | if (e.second > mx) mx = e.second; 17 | } 18 | for (auto &e: mp) { 19 | if (e.second == mx) std::cout << e.first << std::endl; 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /atcoder/cf16-final/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, m; 6 | scanf("%d%d", &n, &m); 7 | for (int i = 0; i < n; ++i) { 8 | for (int j = 0; j < m; ++j) { 9 | char s[10]; 10 | scanf("%s", s); 11 | if (strcmp(s, "snuke") == 0) { 12 | printf("%c%d\n", 'A' + j, i + 1); 13 | return 0; 14 | } 15 | } 16 | } 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /atcoder/code-festival-2016-quala/A.py: -------------------------------------------------------------------------------- 1 | s = input() 2 | print(s[:4], s[4:]) 3 | -------------------------------------------------------------------------------- /atcoder/code-festival-2016-quala/B.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | a = list(map(int, input().split())) 3 | ret = 0 4 | for i in range(n): 5 | ret += a[i] != i + 1 and a[a[i] - 1] == i + 1 6 | print(ret // 2) 7 | -------------------------------------------------------------------------------- /atcoder/code-festival-2016-quala/C.py: -------------------------------------------------------------------------------- 1 | s = input() 2 | k = int(input()) 3 | r = [] 4 | for c in s: 5 | n = ord('z') - ord(c) + 1 6 | if k >= n and c != 'a': 7 | r.append('a') 8 | k -= n 9 | else: 10 | r.append(c) 11 | if k > 0: 12 | r[-1] = chr(ord('a') + (ord(r[-1]) - ord('a') + k) % 26) 13 | print(''.join(r)) 14 | -------------------------------------------------------------------------------- /atcoder/code-festival-2016-qualc/D.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | const int N = 310; 6 | 7 | char s[N][N]; 8 | int cost[N][N]; 9 | int best[N][N]; 10 | int dp[N][N]; 11 | 12 | int main() { 13 | int n, m; 14 | scanf("%d%d", &n, &m); 15 | for (int i = 0; i < n; ++i) scanf("%s", s[i]); 16 | memset(best, -1, sizeof(best)); 17 | best[0][n] = 0; 18 | for (int i = 0; i + 1 < m; ++i) { 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /atcoder/ddcc2020-qual/A.py: -------------------------------------------------------------------------------- 1 | x, y = map(int, input().split()) 2 | ret = 0 3 | if x == 1: ret += 300000 4 | if x == 2: ret += 200000 5 | if x == 3: ret += 100000 6 | if y == 1: ret += 300000 7 | if y == 2: ret += 200000 8 | if y == 3: ret += 100000 9 | if x == 1 and y == 1: ret += 400000 10 | print(ret) 11 | -------------------------------------------------------------------------------- /atcoder/ddcc2020-qual/B.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | a = list(map(int, input().split())) 3 | s = sum(a) 4 | now = 0 5 | ret = s 6 | for x in a: 7 | now += x 8 | ret = min(ret, abs(s - now - now)) 9 | print(ret) 10 | -------------------------------------------------------------------------------- /atcoder/ddcc2020-qual/F.py: -------------------------------------------------------------------------------- 1 | from fractions import gcd 2 | 3 | mod = 10 ** 9 + 7 4 | n, m, t = map(int, input().split()) 5 | a = gcd(n, t) 6 | b = gcd(m, t) 7 | n //= a 8 | m //= b 9 | ret = pow(2, n, mod) + pow(2, m, mod) + pow(2, gcd(n, m), mod) - 3 10 | print(pow(ret, a * b, mod)) 11 | -------------------------------------------------------------------------------- /atcoder/dp/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | int n; 7 | scanf("%d", &n); 8 | std::vector h(n), dp(n); 9 | for (int i = 0; i < n; ++i) { 10 | scanf("%d", &h[i]); 11 | if (!i) dp[i] = 0; 12 | else dp[i] = 2e9; 13 | if (i >= 1) { 14 | dp[i] = std::min(dp[i], dp[i - 1] + std::abs(h[i] - h[i - 1])); 15 | } 16 | if (i >= 2) { 17 | dp[i] = std::min(dp[i], dp[i - 2] + std::abs(h[i] - h[i - 2])); 18 | } 19 | } 20 | printf("%d\n", dp.back()); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /atcoder/dp/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | int n, k; 7 | scanf("%d%d", &n, &k); 8 | std::vector h(n), dp(n); 9 | for (int i = 0; i < n; ++i) { 10 | scanf("%d", &h[i]); 11 | if (!i) dp[i] = 0; 12 | else dp[i] = 2e9; 13 | for (int j = i - 1; j >= i - k && j >= 0; --j) { 14 | dp[i] = std::min(dp[i], dp[j] + std::abs(h[i] - h[j])); 15 | } 16 | } 17 | printf("%d\n", dp.back()); 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /atcoder/dp/D.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using int64 = long long; 6 | 7 | int main() { 8 | int n, m; 9 | scanf("%d%d", &n, &m); 10 | std::vector dp(m + 1); 11 | for (int i = 0; i < n; ++i) { 12 | int w, v; 13 | scanf("%d%d", &w, &v); 14 | for (int j = m; j >= w; --j) { 15 | dp[j] = std::max(dp[j], dp[j - w] + v); 16 | } 17 | } 18 | printf("%lld\n", *std::max_element(dp.begin(), dp.end())); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /atcoder/dwacon6th-prelims/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const int N = 60, M = 1e3 + 10; 5 | 6 | char s[N][M], x[M]; 7 | int t[M]; 8 | 9 | int main() { 10 | int n; 11 | scanf("%d", &n); 12 | for (int i = 0; i < n; ++i) { 13 | scanf("%s%d", s[i], &t[i]); 14 | } 15 | scanf("%s", x); 16 | int ret = 0; 17 | for (int i = n - 1; i >= 0; --i) { 18 | if (strcmp(x, s[i]) == 0) break; 19 | ret += t[i]; 20 | } 21 | printf("%d\n", ret); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /atcoder/nikkei2019-qual/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, a, b; 6 | scanf("%d%d%d", &n, &a, &b); 7 | printf("%d %d\n", std::min(a, b), std::max(0, a + b - n)); 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /atcoder/nikkei2019-qual/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const int N = 100; 4 | 5 | char a[N], b[N], c[N]; 6 | 7 | int main() { 8 | int n; 9 | scanf("%d", &n); 10 | scanf("%s%s%s", a, b, c); 11 | int ret = 0; 12 | for (int i = 0; i < n; ++i) { 13 | if (a[i] != b[i] && a[i] != c[i] && b[i] != c[i]) ret += 2; 14 | else if (a[i] == b[i] && a[i] == c[i]) ret += 0; 15 | else ret += 1; 16 | } 17 | printf("%d\n", ret); 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /atcoder/nikkei2019-qual/C.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using int64 = long long; 6 | 7 | int main() { 8 | int n; 9 | scanf("%d", &n); 10 | std::vector b(n); 11 | int64 ret = 0; 12 | for (int i = 0; i < n; ++i) { 13 | int x, y; 14 | scanf("%d%d", &x, &y); 15 | ret += x; 16 | b[i] = x + y; 17 | } 18 | std::sort(b.begin(), b.end()); 19 | std::reverse(b.begin(), b.end()); 20 | for (int i = 1; i < n; i += 2) ret -= b[i]; 21 | printf("%lld\n", ret); 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /atcoder/snuke21/A.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | l, r = 1, n 3 | while l < r: 4 | m = (l + r) >> 1 5 | if m * (m + 1) // 2 >= n: 6 | r = m 7 | else: 8 | l = m + 1 9 | if r * (r + 1) // 2 == n: 10 | print(r) 11 | else: 12 | print(-1) 13 | -------------------------------------------------------------------------------- /ccpc/2020-online/D.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int T; 5 | scanf("%d", &T); 6 | for (int cas = 1; cas <= T; ++cas) { 7 | } 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /ccpc/2020-online/G.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const int N = 1e5 + 10; 4 | 5 | char s[N]; 6 | int cnt[26]; 7 | 8 | int main() { 9 | int T; 10 | scanf("%d", &T); 11 | for (int cas = 1; cas <= T; ++cas) { 12 | scanf("%s", s); 13 | for (int i = 0; i < 26; ++i) cnt[i] = 0; 14 | for (int i = 0; s[i]; ++i) cnt[s[i] - 'a']++; 15 | int ret = 0; 16 | for (int i = 0; i < 26; ++i) { 17 | if (cnt[i] > ret) ret = cnt[i]; 18 | } 19 | printf("Case #%d: %d\n", cas, ret); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /ccpc/2020-online/J.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int T; 5 | scanf("%d", &T); 6 | for (int cas = 1; cas <= T; ++cas) { 7 | int n; 8 | scanf("%d", &n); 9 | int last = -1, valid = 1; 10 | for (int i = 0, x; i < n; ++i) { 11 | scanf("%d", &x); 12 | valid &= last != x; 13 | last = x; 14 | } 15 | if (valid) puts("YES"); 16 | else puts("NO"); 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /ccpc/2020-qinhuangdao/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int gcd(int a, int b) { 4 | return b ? gcd(b, a % b) : a; 5 | } 6 | 7 | int main() { 8 | int T; 9 | scanf("%d", &T); 10 | for (int cas = 1; cas <= T; ++cas) { 11 | int r, b; 12 | scanf("%d%d", &r, &b); 13 | int y = (r + b) * (r + b - 1) / 2; 14 | int x = r * (r - 1) / 2; 15 | int g = gcd(x, y); 16 | printf("Case #%d: %d/%d\n", cas, x / g, y / g); 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /coci/2010-2011/contest#4/hrpa.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | 5 | int main() { 6 | int64 n; 7 | scanf("%lld", &n); 8 | int64 ret = -1; 9 | while (n) { 10 | int64 a = 0, b = 1; 11 | while (true) { 12 | int64 c = a + b; 13 | a = b; b = c; 14 | if (b > n) break; 15 | } 16 | ret = a; 17 | n -= a; 18 | } 19 | printf("%lld\n", ret); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /coci/2019-2020/contest#1/trol.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | 5 | int main() { 6 | int T; 7 | scanf("%d", &T); 8 | for (int cas = 1; cas <= T; ++cas) { 9 | int64 l, r; 10 | scanf("%lld%lld", &l, &r); 11 | --l; 12 | int64 kr = r / 9, mr = r % 9; 13 | int64 kl = l / 9, ml = l % 9; 14 | printf("%lld\n", kr * 45 + (1 + mr) * mr / 2 - kl * 45 - (ml + 1) * ml / 2); 15 | } 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /coci/2019-2020/contest#3/sob.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, m; 5 | scanf("%d%d", &n, &m); 6 | for (int a = n - 1, b = m; a >= 0; ) { 7 | while ((a & b) != a) ++b; 8 | for (int i = b; i >= m; --i) { 9 | printf("%d %d\n", a - (b - i), i); 10 | } 11 | a -= (b - m + 1); 12 | b = m = b + 1; 13 | } 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /coci/2019-2020/contest#4/spiderman.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const int N = 1e6 + 10; 4 | 5 | int cnt[N], ret[N], h[N]; 6 | 7 | int main() { 8 | int n, k; 9 | scanf("%d%d", &n, &k); 10 | for (int i = 0; i < n; ++i) { 11 | scanf("%d", &h[i]); 12 | cnt[h[i]]++; 13 | } 14 | for (int i = k + 1; i < N; ++i) if (cnt[i]) { 15 | for (int x = k; x < N; x += i) ret[x] += cnt[i]; 16 | if (k == 0) ret[i]--; 17 | } 18 | for (int i = 0; i < n; ++i) printf("%d ", ret[h[i]]); 19 | puts(""); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /codechef/DEC19/PLMU.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int T; 6 | scanf("%d", &T); 7 | for (int cas = 1; cas <= T; ++cas) { 8 | int n; 9 | scanf("%d", &n); 10 | int c0 = 0, c2 = 0; 11 | for (int i = 0; i < n; ++i) { 12 | int x; 13 | scanf("%d", &x); 14 | c0 += x == 0; 15 | c2 += x == 2; 16 | } 17 | printf("%d\n", c0 * (c0 - 1) / 2 + c2 * (c2 - 1) / 2); 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /codechef/DEC19/WATSCORE.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int T; 6 | scanf("%d", &T); 7 | for (int cas = 1; cas <= T; ++cas) { 8 | int n; 9 | scanf("%d", &n); 10 | std::vector score(11); 11 | for (int i = 0; i < n; ++i) { 12 | int p, x; 13 | scanf("%d%d", &p, &x); 14 | if (p <= 8 && score[p - 1] < x) score[p - 1] = x; 15 | } 16 | int sum = 0; 17 | for (int i = 0; i < 11; ++i) sum += score[i]; 18 | printf("%d\n", sum); 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /codechef/JAN20/ARMYOFME.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | const int N = 5e5 + 10; 6 | 7 | int main() { 8 | int n, q; 9 | scanf("%d%d", &n, &q); 10 | std::vector p(n); 11 | for (int i = 0; i < n; ++i) scanf("%d", &p[i]); 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /codechef/JAN20/CHEFARMY.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int T; 6 | scanf("%d", &T); 7 | for (int cas = 1; cas <= T; ++cas) { 8 | int n, m; 9 | scanf("%d%d", &m, &n); 10 | for (int i = 0; i < m; ++i) scanf("%*s"); 11 | std::vector s(n); 12 | for (int i = 0; i < n; ++i) scanf("%d", &s[i]); 13 | for (int i = 0; i < n; ++i) scanf("%*d"); 14 | printf("%d\n", n); 15 | for (int i = 0; i < n; ++i) { 16 | printf("1 %d %d\n", s[i], i + 1); 17 | } 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /codechef/SNCKEL19/SFXPAL.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using int64 = long long; 8 | 9 | int64 mod; 10 | 11 | int64 solve(int64 n, int64 m) { 12 | if (n == 1) return m % mod; 13 | else if (n == 2) return m * (m - 1) % mod; 14 | else return solve(n - 2, m - 1) * m % mod * (m - 1) % mod; 15 | } 16 | 17 | int main() { 18 | int64 n, m; 19 | scanf("%lld%lld%lld", &n, &m, &mod); 20 | printf("%lld\n", solve(n, m)); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /codeforces/AIM Tech Round 3/2A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void run() { 4 | int n, b, d; 5 | std::cin >> n >> b >> d; 6 | int ret = 0, now = 0; 7 | for (int i = 0; i < n; ++i) { 8 | int a; 9 | std::cin >> a; 10 | if (a > b) continue; 11 | now += a; 12 | if (now > d) { 13 | now = 0; 14 | ++ret; 15 | } 16 | } 17 | std::cout << ret << std::endl; 18 | } 19 | 20 | int main() { 21 | run(); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /codeforces/AIM Tech Round 3/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void run() { 4 | std::string s; 5 | std::cin >> s; 6 | bool flag = false; 7 | for (auto &&c: s) { 8 | flag |= c != 'a'; 9 | } 10 | if (!flag) { 11 | s.back() = 'z'; 12 | std::cout << s << std::endl; 13 | } else { 14 | int i, j; 15 | for (i = 0; s[i] == 'a'; ++i); 16 | for (j = i; j < s.size() && s[j] != 'a'; ++j); 17 | for (; i < j; ++i) s[i]--; 18 | std::cout << s << std::endl; 19 | } 20 | } 21 | 22 | int main() { 23 | run(); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /codeforces/Codeforces Beta Round #1/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | int main() 7 | { 8 | int n, m, a; 9 | scanf("%d%d%d", &n, &m, &a); 10 | n=(n%a)?(n/a+1):(n/a); 11 | m=(m%a)?(m/a+1):(m/a); 12 | cout << (long long)n*m << endl; 13 | } 14 | -------------------------------------------------------------------------------- /codeforces/Codeforces Beta Round #11/B.cc: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n; cin >> n; 7 | if (n < 0) n = -n; 8 | if (n == 0) cout << "0\n"; 9 | else { 10 | int sum = 0, i = 0; 11 | while (sum + i <= n) sum += i, ++ i; 12 | while (sum < n || (sum ^ n) & 1) sum += i, ++ i; 13 | cout << i - 1 << endl; 14 | } 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /codeforces/Codeforces Beta Round #4/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | int w; 7 | scanf("%d", &w); 8 | if ((w&1)||w<=2) puts("NO"); 9 | else puts("YES"); 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /codeforces/Codeforces Beta Round #7/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int x=0, y=0, num; 6 | for (int i=0; i<8; i++) { 7 | char st[10]; scanf("%s", st); num=0; 8 | for (int j=0; j<8; j++) { 9 | if (st[j]=='B') num++; 10 | } 11 | if (num==8) x++; 12 | else y=num; 13 | } 14 | printf("%d\n", x+y); 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /codeforces/Codeforces Beta Round #9/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int Y, W; cin >> Y >> W; 6 | int A = 7 - max(Y, W), B = 6; 7 | int g = __gcd(A, B); 8 | A /= g, B /= g; 9 | cout << A << "/" << B << endl; 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /codeforces/Codeforces Beta Round #9/C.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int n, ret; 5 | 6 | int toDecimal(int mask) { 7 | int ret = 0; 8 | for (int i = 9; i >= 0; -- i) { 9 | int o = (mask >> i) & 1; 10 | ret = ret * 10 + o; 11 | } 12 | return ret; 13 | } 14 | 15 | int main() { 16 | cin >> n; 17 | for (int mask = 1; mask <= 0x200; ++ mask) { 18 | if (toDecimal(mask) <= n) ++ ret; 19 | } 20 | cout << ret << endl; 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #365/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void run() { 4 | int n; 5 | std::cin >> n; 6 | int m = 0, c = 0; 7 | for (int i = 0; i < n; ++i) { 8 | int x, y; 9 | std::cin >> x >> y; 10 | if (x > y) ++m; 11 | if (x < y) ++c; 12 | } 13 | if (m > c) puts("Mishka"); 14 | if (m < c) puts("Chris"); 15 | if (m == c) puts("Friendship is magic!^^"); 16 | } 17 | 18 | int main() { 19 | run(); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #365/C.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void run() { 4 | int n; 5 | double u, v, w; 6 | std::cin >> n >> w >> v >> u; 7 | double l = 1e9, r = 0; 8 | for (int i = 0; i < n; ++i) { 9 | double x, y; 10 | std::cin >> x >> y; 11 | l = std::min(l, x - y / u * v); 12 | r = std::max(r, x - y / u * v); 13 | } 14 | printf("%.10f\n", w / u + r / v * (l < 0)); 15 | } 16 | 17 | int main() { 18 | run(); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #366/2A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void run() { 4 | int n; 5 | std::cin >> n; 6 | for (int i = 1; i < n; ++i) { 7 | if (i & 1) printf("I hate that "); 8 | else printf("I love that "); 9 | } 10 | if (n & 1) printf("I hate it\n"); 11 | else printf("I love it\n"); 12 | } 13 | 14 | int main() { 15 | run(); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #366/2B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void run() { 4 | int n; 5 | std::cin >> n; 6 | int sg = 0; 7 | for (int i = 0; i < n; ++i) { 8 | int x; 9 | std::cin >> x; 10 | sg ^= ~x & 1; 11 | if (sg) puts("1"); 12 | else puts("2"); 13 | } 14 | } 15 | 16 | int main() { 17 | run(); 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #367/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void run() { 4 | int a, b; 5 | std::cin >> a >> b; 6 | int n; 7 | std::cin >> n; 8 | double res = 1e9; 9 | for (int i = 0; i < n; ++i) { 10 | int x, y, v; 11 | std::cin >> x >> y >> v; 12 | double dis = hypot(x - a, y - b) / v; 13 | res = std::min(res, dis); 14 | } 15 | printf("%.10f\n", res); 16 | } 17 | 18 | int main() { 19 | run(); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #367/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void run() { 4 | int n; 5 | std::cin >> n; 6 | std::vector x(n); 7 | for (int i = 0; i < n; ++i) std::cin >> x[i]; 8 | std::sort(x.begin(), x.end()); 9 | int q; 10 | std::cin >> q; 11 | for (int i = 0; i < q; ++i) { 12 | int m; 13 | std::cin >> m; 14 | std::cout << std::upper_bound(x.begin(), x.end(), m) - x.begin() << std::endl; 15 | } 16 | } 17 | 18 | int main() { 19 | run(); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #368/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void run() { 4 | int n, m; 5 | std::cin >> n >> m; 6 | int cnt = 0; 7 | for (int i = 0; i < n; ++i) { 8 | for (int j = 0; j < m; ++j) { 9 | std::string s; 10 | std::cin >> s; 11 | if (s[0] == 'G' || s[0] == 'B' || s[0] == 'W') ++cnt; 12 | } 13 | } 14 | if (cnt == n * m) puts("#Black&White"); 15 | else puts("#Color"); 16 | } 17 | 18 | int main() { 19 | run(); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #432/2A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, k, t; 5 | scanf("%d%d%d", &n, &k, &t); 6 | if (t <= k) printf("%d\n", t); 7 | else if (t > n) printf("%d\n", n + k - t); 8 | else printf("%d\n", k); 9 | return 0; 10 | } -------------------------------------------------------------------------------- /codeforces/Codeforces Round #433/2A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int gcd(int a, int b) { 4 | return b ? gcd(b, a % b) : a; 5 | } 6 | 7 | int main() { 8 | int n; 9 | scanf("%d", &n); 10 | for (int b = 1; b < n; ++b) { 11 | if (n - b >= b) continue; 12 | if (gcd(n - b, b) == 1) { 13 | printf("%d %d\n", n - b, b); 14 | break; 15 | } 16 | } 17 | return 0; 18 | } -------------------------------------------------------------------------------- /codeforces/Codeforces Round #433/2B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, k; 5 | std::cin >> n >> k; 6 | if (k == 0 || k == n) std::cout << "0 0" << std::endl; 7 | else { 8 | std::cout << "1 "; 9 | int all = (n - 1) / 3 + 1; 10 | if (k <= all) std::cout << std::min(k * 2, n - k) << std::endl; 11 | else std::cout << (n - all) - (k - all) << std::endl; 12 | } 13 | return 0; 14 | } -------------------------------------------------------------------------------- /codeforces/Codeforces Round #434/2A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int gcd(int a, int b) { 4 | return b ? gcd(b, a % b) : a; 5 | } 6 | 7 | int main() { 8 | int n, k; 9 | scanf("%d%d", &n, &k); 10 | int s = 1; 11 | for (int i = 0; i < k; ++i) s *= 10; 12 | int g = gcd(s, n); 13 | printf("%lld\n", 1ll * s / g * n); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #539/2A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int dp[200][200]; 5 | 6 | int main() { 7 | int n, v; 8 | scanf("%d%d", &n, &v); 9 | int ret = std::min(n - 1, v), p = 2; 10 | for (int i = v + 1; i < n; ++i) { 11 | ret += p; 12 | ++p; 13 | } 14 | printf("%d\n", ret); 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #539/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | 5 | int cnt[2][1 << 20]; 6 | 7 | int main() { 8 | int n; 9 | scanf("%d", &n); 10 | int s = 0; 11 | cnt[0][s]++; 12 | int64 ret = 0; 13 | for (int i = 1; i <= n; ++i) { 14 | int x; 15 | scanf("%d", &x); 16 | s ^= x; 17 | ret += cnt[i & 1][s]; 18 | cnt[i & 1][s]++; 19 | } 20 | printf("%lld\n", ret); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #539/F.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | return 0; 5 | } 6 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #540/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | 5 | int main() { 6 | int T; 7 | scanf("%d", &T); 8 | for (int cas = 1; cas <= T; ++cas) { 9 | int64 n, a, b; 10 | scanf("%lld%lld%lld", &n, &a, &b); 11 | if (b >= 2 * a) printf("%lld\n", n * a); 12 | else printf("%lld\n", n * a + (b - a * 2) * (n / 2)); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #540/E.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, k; 5 | scanf("%d%d", &n, &k); 6 | if (n > 1ll * k * k - k) { 7 | puts("NO"); 8 | return 0; 9 | } 10 | puts("YES"); 11 | for (int s = 2; s <= k + k && n; ++s) { 12 | int l = 1, r = k; 13 | if (s >= k + 2) l = s - k; 14 | for (int i = l; i <= r && i < s && n; ++i) { 15 | if (i == s - i) continue; 16 | printf("%d %d\n", i, s - i); 17 | --n; 18 | } 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #542/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int k; 6 | scanf("%d", &k); 7 | int n = 2000; 8 | int s = k + n; 9 | std::vector a(n); 10 | a[0] = -1; 11 | for (int i = 1; i < n; ++i) a[i] = s / (n - 1); 12 | for (int i = 1; i <= s % (n - 1); ++i) ++a[i]; 13 | printf("%d\n", n); 14 | for (int i = 0; i < n; ++i) { 15 | if (i) putchar(' '); 16 | printf("%d", a[i]); 17 | } 18 | puts(""); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #568/A/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "A" 3 | version = "0.1.0" 4 | authors = ["zimpha"] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #568/B/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "B" 3 | version = "0.1.0" 4 | authors = ["zimpha"] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #568/C/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "C" 3 | version = "0.1.0" 4 | authors = ["zimpha"] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #568/D/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "D" 3 | version = "0.1.0" 4 | authors = ["zimpha"] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #568/E/Cargo.lock: -------------------------------------------------------------------------------- 1 | # This file is automatically @generated by Cargo. 2 | # It is not intended for manual editing. 3 | [[package]] 4 | name = "E" 5 | version = "0.1.0" 6 | 7 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #568/E/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "E" 3 | version = "0.1.0" 4 | authors = ["zimpha"] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #612/2A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const int N = 200; 5 | 6 | char s[N]; 7 | 8 | int main() { 9 | int T; 10 | scanf("%d", &T); 11 | for (int cas = 1; cas <= T; ++cas) { 12 | int n; 13 | scanf("%d%s", &n, s); 14 | int ret = 0, cnt = 0; 15 | for (int i = n - 1; i >= 0; --i) { 16 | if (s[i] == 'A') ret = std::max(ret, cnt), cnt = 0; 17 | else cnt++; 18 | } 19 | printf("%d\n", ret); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /codeforces/Codeforces Round #613/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const int N = 1e5 + 10; 4 | 5 | char s[N]; 6 | 7 | int main() { 8 | int n; 9 | scanf("%d%s", &n, s); 10 | int cl = 0, cr = 0; 11 | for (int i = 0; i < n; ++i) { 12 | cl += s[i] == 'L'; 13 | cr += s[i] == 'R'; 14 | } 15 | printf("%d\n", cl + cr + 1); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /codeforces/Educational Codeforces Round 16/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void run() { 4 | std::string s; 5 | std::cin >> s; 6 | const int dx[] = {0, 0, 1, -1, 1, 1, -1, -1}; 7 | const int dy[] = {1, -1, 0, 0, 1, -1, 1, -1}; 8 | int ret = 0; 9 | for (int i = 0; i < 8; ++i) { 10 | char x = s[0] + dx[i]; 11 | char y = s[1] + dy[i]; 12 | if (x >= 'a' && x <= 'h' && y >= '1' && y <= '8') ++ret; 13 | } 14 | std::cout << ret << std::endl; 15 | } 16 | 17 | int main() { 18 | run(); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /codeforces/Educational Codeforces Round 16/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void run() { 4 | int n; 5 | std::cin >> n; 6 | std::vector x(n); 7 | for (int i = 0; i < n; ++i) { 8 | std::cin >> x[i]; 9 | } 10 | std::sort(x.begin(), x.end()); 11 | std::cout << x[(n - 1) / 2] << std::endl; 12 | } 13 | 14 | int main() { 15 | run(); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /codeforces/Educational Codeforces Round 16/E.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using LL = long long; 3 | 4 | void run() { 5 | int n, x, y; 6 | std::cin >> n >> x >> y; 7 | std::vector f(n + 3, 1ll << 60); 8 | f[0] = 0; 9 | for (int i = 0; i <= n; ++i) { 10 | f[i] = std::min(f[i], f[i + 1] + x); 11 | f[i + 1] = std::min(f[i + 1], f[i] + x); 12 | if (i * 2 <= n + 2) { 13 | f[i * 2] = std::min(f[i * 2], f[i] + y); 14 | } 15 | } 16 | std::cout << f[n] << std::endl; 17 | } 18 | 19 | int main() { 20 | run(); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /codeforces/Good Bye 2018/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | int main() { 8 | int y, b, r; 9 | scanf("%d%d%d", &y, &b, &r); 10 | int ret = 0; 11 | for (int i = 0; i <= 100; ++i) { 12 | if (i <= y && i + 1 <= b && i + 2 <= r) ret = i; 13 | } 14 | printf("%d\n", ret * 3 + 3); 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /codeforces/Hello 2019/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | using int64 = long long; 11 | 12 | int main() { 13 | std::string s[6]; 14 | for (int i = 0; i < 6; ++i) std::cin >> s[i]; 15 | for (int i = 1; i < 6; ++i) { 16 | if (s[i][0] == s[0][0] || s[i][1] == s[0][1]) { 17 | puts("YES"); 18 | return 0; 19 | } 20 | } 21 | puts("NO"); 22 | return 0; 23 | } -------------------------------------------------------------------------------- /codeforces/Hello 2020/C.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using int64 = long long; 5 | 6 | int main() { 7 | int n, m; 8 | scanf("%d%d", &n, &m); 9 | std::vector fac(n + 1, 1); 10 | for (int i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i % m; 11 | int64 ret = 0; 12 | for (int i = 1; i <= n; ++i) { 13 | ret += fac[i] * (n - i + 1) % m * fac[n - i] % m * (n - i + 1) % m; 14 | } 15 | printf("%lld\n", ret % m); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /codeforces/valentines-day-contest-2020/E.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main() { 5 | int T; 6 | scanf("%d", &T); 7 | for (int cas = 1; cas <= T; ++cas) { 8 | int X; 9 | scanf("%d", &X); 10 | } 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /codem/2017/qualification-round/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, x; 6 | scanf("%d%d", &n, &x); 7 | int cnt = 1; 8 | for (int i = 1; i < n; ++i) { 9 | int u; 10 | scanf("%d", &u); 11 | cnt += u <= x; 12 | } 13 | printf("%d\n", int(log(cnt) / log(2))); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /codem/2017/round-1a/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n; 6 | double u, v; 7 | scanf("%d%lf%lf", &n, &v, &u); 8 | std::vector a(n), b(n); 9 | for (int i = 0; i < n; ++i) scanf("%lf", &a[i]); 10 | for (int i = 0; i < n; ++i) scanf("%lf", &b[i]); 11 | double ret = 0; 12 | for (int i = 0; i < n; ++i) { 13 | for (int j = 0; j < n; ++j) { 14 | ret += u / (a[i] - j * b[i] - v); 15 | } 16 | } 17 | printf("%.3f\n", ret); 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /codem/2018/round-1a/E.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | 6 | return 0; 7 | } -------------------------------------------------------------------------------- /cometoj/contest#4/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int T; 6 | scanf("%d", &T); 7 | for (int cas = 1; cas <= T; ++cas) { 8 | int a[5]; 9 | for (int i = 0; i < 5; ++i) a[i] = 0; 10 | for (int i = 0; i < 5; ++i) { 11 | int x; 12 | scanf("%d", &x); 13 | a[x - 1]++; 14 | } 15 | int best = 0; 16 | for (int i = 0; i < 5; ++i) { 17 | if (a[i] > a[best]) best = i; 18 | } 19 | printf("%d\n", best + 1); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /erdos/1.py: -------------------------------------------------------------------------------- 1 | def D(n): 2 | r = 1e9 3 | for mask in xrange(1 << n): 4 | now = 0 5 | for i in xrange(n): 6 | if (mask >> i) & 1: 7 | now += i + 1 8 | else: 9 | now -= i + 1 10 | if now >= 0: 11 | r = min(r, now) 12 | return r 13 | 14 | def S(n): 15 | # [0, 1, 1, 0] 16 | return n / 4 * 2 + n % 4 - (n % 4 == 3) 17 | 18 | print S(19216812112) 19 | -------------------------------------------------------------------------------- /erdos/10.py: -------------------------------------------------------------------------------- 1 | def number_spiral_diagonals(n): 2 | ret = 0 3 | for i in xrange(1, n + 1): 4 | ret += i * i - i + 1 5 | ret += (3 + 4 * (i - 1) + 2 * (i - 1) ** 2 - (1 if i % 2 else -1)) / 2 6 | return ret - 1 7 | 8 | print number_spiral_diagonals(5) 9 | print number_spiral_diagonals(10001) 10 | -------------------------------------------------------------------------------- /erdos/14.py: -------------------------------------------------------------------------------- 1 | def count_fibonacci(): 2 | a, b = 0, 1 3 | fib = set() 4 | for i in xrange(100): 5 | fib.add(a) 6 | c = a + b 7 | a, b = b, c 8 | with open('14.txt', 'r') as fp: 9 | a = map(int, fp.readlines()) 10 | ret = sum([x in fib for x in a]) 11 | return ret 12 | 13 | print count_fibonacci() 14 | -------------------------------------------------------------------------------- /erdos/146.py: -------------------------------------------------------------------------------- 1 | def a_very_easy_sum(n, mod): 2 | def f(n): 3 | return n * (n + 1) / 2 4 | u = int(n ** (1. / 3)) 5 | mu = [0] * (u + 1) 6 | for i in xrange(1, u + 1): 7 | mu[i] += i == 1 8 | for j in xrange(i + i, u + 1, i): 9 | mu[j] -= mu[i] 10 | ret = 0 11 | for i in xrange(1, u + 1): 12 | ret += mu[i] * i ** 3 * f(n / i ** 3) 13 | return ret % mod 14 | 15 | print a_very_easy_sum(10, 10 ** 9 + 7) 16 | print a_very_easy_sum(10 ** 4, 10 ** 9 + 7) 17 | print a_very_easy_sum(123456789123456789, 10 ** 9 + 7) 18 | -------------------------------------------------------------------------------- /erdos/16.py: -------------------------------------------------------------------------------- 1 | from fractions import * 2 | print pow(2, gcd(10 ** 10, 8 ** 8), 10 ** 9 + 7) - 1 3 | -------------------------------------------------------------------------------- /erdos/164.py: -------------------------------------------------------------------------------- 1 | def kill_the_remaining_chinese(): 2 | X = 1 3 | for i in xrange(100): 4 | X *= i + 1 5 | Y = pow(X, 9449771607341027425, 9449771616229914661) 6 | return Y % 1000000008; 7 | 8 | print kill_the_remaining_chinese() 9 | -------------------------------------------------------------------------------- /erdos/166.py: -------------------------------------------------------------------------------- 1 | def apples_for_ryuk(n): 2 | # sum_{i=1}^{n} (2^(2^n) + 1) mod 9 3 | x, y = divmod(n, 2) 4 | return x * 13 + y * 5 5 | 6 | print apples_for_ryuk(999999999999) 7 | -------------------------------------------------------------------------------- /erdos/172.py: -------------------------------------------------------------------------------- 1 | def phi(n): 2 | r, i = n, 2 3 | while i * i <= n: 4 | if n % i == 0: 5 | r = r / i * (i - 1) 6 | while n % i == 0: 7 | n /= i 8 | i += 1 9 | if n > 1: 10 | r = r / n * (n - 1) 11 | return r 12 | 13 | def polynomial_expansion_2(): 14 | # 15^k mod 100086841 15 | mod = 100086841 16 | p1 = phi(mod) 17 | p2 = phi(p1) 18 | e = pow(18, pow(10, 18, p2), p1) 19 | return pow(15, e, mod) 20 | 21 | print polynomial_expansion_2() 22 | -------------------------------------------------------------------------------- /erdos/189.py: -------------------------------------------------------------------------------- 1 | def prob189(n): 2 | return (n + 1) / 2 3 | 4 | print prob189(123456789) 5 | -------------------------------------------------------------------------------- /erdos/19.py: -------------------------------------------------------------------------------- 1 | def large_exponentiation(): 2 | p = 1 3 | for i in xrange(2097152): 4 | if p == 1 and i: 5 | return i 6 | p = p * 201413 % 2097152 7 | return -1 8 | 9 | print large_exponentiation() 10 | -------------------------------------------------------------------------------- /erdos/199.py: -------------------------------------------------------------------------------- 1 | r = 1 2 | for i in range(6): 3 | r *= 197 - i 4 | r %= 10 ** 9 + 7 5 | r = bin(r) 6 | cnt = 0 7 | for x in r: 8 | if x == '1': 9 | cnt += 1 10 | print(cnt) 11 | -------------------------------------------------------------------------------- /erdos/20.py: -------------------------------------------------------------------------------- 1 | def fives_and_sevens(): 2 | ret = 0 3 | for mask in xrange(1 << 20): 4 | n = 0 5 | for i in xrange(20): 6 | if mask >> i & 1: 7 | n = n * 10 + 5 8 | else: 9 | n = n * 10 + 7 10 | if n % 5 == 0 and n % 7 == 0: 11 | ret += 1 12 | return ret 13 | 14 | print fives_and_sevens() 15 | -------------------------------------------------------------------------------- /erdos/200.py: -------------------------------------------------------------------------------- 1 | n = 10 ** 18 2 | r = (-2 + n) * (-1 + n) * n * (1 + n) // 24 3 | r %= 22011663 4 | print(r) 5 | -------------------------------------------------------------------------------- /erdos/201.py: -------------------------------------------------------------------------------- 1 | n = 733 2 | print(2 ** (n - 1) // n % (10 ** 9 + 9)) 3 | -------------------------------------------------------------------------------- /erdos/203.py: -------------------------------------------------------------------------------- 1 | n = 6367 2 | m = 6571 3 | print(int(2 * n * m / (n + m) * 10000)) 4 | -------------------------------------------------------------------------------- /erdos/204.py: -------------------------------------------------------------------------------- 1 | mod = 10 ** 9 + 7 2 | 3 | def fib(n): 4 | if n == 1: 5 | return 1, 1 6 | if n & 1: 7 | y, x = fib(n - 1) 8 | return x, (x + y) % mod 9 | else: 10 | x, y = fib(n >> 1) 11 | return (x * y + x * (y - x + mod)) % mod, (x * x + y * y) % mod 12 | 13 | print(fib(10 ** 18 + 3)[0] - 1) 14 | -------------------------------------------------------------------------------- /erdos/22.py: -------------------------------------------------------------------------------- 1 | from math import * 2 | 3 | def totient_function(): 4 | n = 100064101 5 | r = 0 6 | for i in xrange(n): 7 | r += log(i + 1) 8 | r /= log(10) 9 | return int(r) + 1 10 | 11 | print totient_function() 12 | -------------------------------------------------------------------------------- /erdos/5.py: -------------------------------------------------------------------------------- 1 | def three_musketeers(): 2 | k = 65 / 5 3 | return 5 * 2 * 3 * k ** 3 4 | 5 | print three_musketeers() 6 | -------------------------------------------------------------------------------- /erdos/6.py: -------------------------------------------------------------------------------- 1 | A = sum([int(x) for x in str(3334 ** 3334)]) 2 | B = sum([int(x) for x in str(A)]) 3 | print 2013 * sum([int(x) for x in str(B)]) 4 | -------------------------------------------------------------------------------- /erdos/9.py: -------------------------------------------------------------------------------- 1 | def highly_divisible_number(bound): 2 | n = 3 * 10 ** 6 3 | d = [0] * n 4 | for i in xrange(1, n): 5 | for j in xrange(i, n, i): 6 | d[j] += 1 7 | for i in xrange(1, n): 8 | if d[i] > bound: 9 | return i 10 | return -1 11 | 12 | print highly_divisible_number(300) 13 | -------------------------------------------------------------------------------- /facebook-hacker-cup/2011/qualification-round/double-squares.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using ll = long long; 5 | 6 | bool is_square(ll n) { 7 | ll x = sqrt(n); 8 | return x * x == n; 9 | } 10 | 11 | int main() { 12 | int T; 13 | scanf("%d", &T); 14 | for (int cas = 1; cas <= T; ++cas) { 15 | ll n; 16 | scanf("%lld", &n); 17 | int ret = 0; 18 | for (ll i = 0; i * i * 2 <= n; ++i) { 19 | ret += is_square(n - i * i); 20 | } 21 | printf("Case #%d: %d\n", cas, ret); 22 | } 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /facebook-hacker-cup/2018/qualification-round/interception.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int T; 6 | scanf("%d", &T); 7 | for (int cas = 1; cas <= T; ++cas) { 8 | int n; 9 | scanf("%d", &n); 10 | std::vector p(n + 1); 11 | for (int i = n; i >= 0; --i) { 12 | scanf("%d", &p[i]); 13 | } 14 | if (n % 2 == 1) printf("Case #%d: 1\n0.0\n", cas); 15 | else printf("Case #%d: 0\n", cas); 16 | } 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /facebook-hacker-cup/2019/qualification-round/leapfrog-ch-1.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | int T; 7 | std::cin >> T; 8 | for (int cas = 1; cas <= T; ++cas) { 9 | std::string s; 10 | std::cin >> s; 11 | int b = 0, d = 0; 12 | for (size_t i = 1; i < s.size(); ++i) { 13 | if (s[i] == 'B') ++b; 14 | else ++d; 15 | } 16 | if (d && b >= d) printf("Case #%d: Y\n", cas); 17 | else printf("Case #%d: N\n", cas); 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /facebook-hacker-cup/2019/qualification-round/leapfrog-ch-2.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | int T; 7 | std::cin >> T; 8 | for (int cas = 1; cas <= T; ++cas) { 9 | std::string s; 10 | std::cin >> s; 11 | int b = 0, d = 0; 12 | for (size_t i = 1; i < s.size(); ++i) { 13 | if (s[i] == 'B') ++b; 14 | else ++d; 15 | } 16 | if (d && (b >= 2 || b >= d)) printf("Case #%d: Y\n", cas); 17 | else printf("Case #%d: N\n", cas); 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /facebook-hacker-cup/2019/qualification-round/mr-x.py: -------------------------------------------------------------------------------- 1 | def valid(e): 2 | return eval(e.replace('x', '0').replace('X', '1')) == eval(e.replace('x', '1').replace('X', '0')) 3 | 4 | T = int(raw_input()) 5 | for cas in xrange(1, T + 1): 6 | e = raw_input() 7 | ret = not valid(e) 8 | print 'Case #{}: {}'.format(cas, int(ret)) 9 | -------------------------------------------------------------------------------- /google-code-jam/2018/practice/steed-2-cruise-control.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int T; 6 | scanf("%d", &T); 7 | for (int cas = 1; cas <= T; ++cas) { 8 | int D, n; 9 | scanf("%d%d", &D, &n); 10 | double need = 0; 11 | for (int i = 0; i < n; ++i) { 12 | int K, S; 13 | scanf("%d%d", &K, &S); 14 | need = std::max(need, double(D - K) / S); 15 | } 16 | printf("Case #%d: %.10f\n", cas, D / need); 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /google-code-jam/2019/round-1b/manhattan-crepe-cart.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /google-code-jam/2019/round-2/pottery-lottery.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int T; 5 | scanf("%d", &T); 6 | for (int cas = 1; cas <= T; ++cas) { 7 | } 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /google-code-jam/2020/round2/wormhole-in-one.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int T; 6 | scanf("%d", &T); 7 | for (int cas = 1; cas <= T; ++cas) { 8 | int n; 9 | scanf("%d", &n); 10 | std::vector x(n), y(n); 11 | for (int i = 0; i < n; ++i) scanf("%d%d", &x[i], &y[i]); 12 | } 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /gordian-knot/2017/3-2.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | int p[100]; 7 | for (int i = 0; i < n; ++i) { 8 | p[i] = i + 1; 9 | } 10 | std::map cnt; 11 | do { 12 | int sum = 0; 13 | for (int i = 0; i < n; ++i) sum += abs(i + 1 - 2 * p[i]); 14 | cnt[sum]++; 15 | } while (std::next_permutation(p, p + n)); 16 | for (auto &&e: cnt) { 17 | std::cout << e.first << ' ' << e.second << std::endl; 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /gordian-knot/2018/22.py: -------------------------------------------------------------------------------- 1 | from math import cos, pi 2 | 3 | n = [(2, 2), (3, 1), (19, 1), (10570841, 1), (104395301, 1)] 4 | gn = 1 5 | for p, k in n: 6 | r = 1 7 | for i in range(1, k + 1): 8 | r += p ** i 9 | gn *= r 10 | print(gn) 11 | -------------------------------------------------------------------------------- /gordian-knot/2018/Q17.py: -------------------------------------------------------------------------------- 1 | from math import * 2 | 3 | n = 1000 4 | f = [0] * (n + 1) 5 | for i in range(1, n + 1): 6 | f[i] = f[i - 1] + log(i) 7 | mx, p = -1e9, 1 8 | for i in range(2, n + 1): 9 | r = log(i - 1) - i * log(1000) + f[1000] - f[1000 - i + 1] 10 | if r > mx: 11 | mx = r 12 | p = i 13 | print mx, p 14 | r = 1 15 | factors = [3, 11] 16 | for p in factors: 17 | r *= p + pi 18 | print r 19 | -------------------------------------------------------------------------------- /gordian-knot/2018/Q3.py: -------------------------------------------------------------------------------- 1 | from fractions import gcd 2 | N = 10 ** 6 3 | p = [0] * N 4 | for i in range(2, N): 5 | if p[i]: continue 6 | for j in range(i + i, N, i): 7 | p[j] = 1 8 | for n in range(2, N): 9 | if not p[n]: continue 10 | flag = True 11 | for a in range(2, n + 1): 12 | if gcd(a, n) != 1: continue 13 | if pow(a, n, n) != a: 14 | flag = False 15 | break 16 | if flag: 17 | print n 18 | break 19 | -------------------------------------------------------------------------------- /gordian-knot/2018/Q4.py: -------------------------------------------------------------------------------- 1 | def count(n): 2 | r = 0 3 | while n > 1: 4 | r += n / 2 5 | n = n / 2 + n % 2 6 | return r 7 | 8 | cnt = 22369621 9 | left, right = 1, cnt * 2 10 | while left < right: 11 | mid = (left + right - 1) >> 1 12 | if count(mid) >= cnt: 13 | right = mid 14 | else: 15 | left = mid + 1 16 | print left 17 | -------------------------------------------------------------------------------- /gordian-knot/2018/Q5.py: -------------------------------------------------------------------------------- 1 | def f(x): 2 | return x ** 4 + 1 3 | 4 | r = 0 5 | for i in range(2, 222 + 1): 6 | r += f(i) 7 | print r 8 | -------------------------------------------------------------------------------- /gordian-knot/2018/Q9.py: -------------------------------------------------------------------------------- 1 | from fractions import * 2 | 3 | n = 251277 4 | a = Fraction(1) 5 | b = Fraction(0) 6 | for i in xrange(n): 7 | p = Fraction(1, 2 * i + 5) 8 | c = a * (1 - p) + b * p 9 | d = a * p + b * (1 - p) 10 | a, b = c, d 11 | print a 12 | -------------------------------------------------------------------------------- /hackerearth/algorithms-qualifiers-round-1/hungry-lemurs.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n, m; cin >> n >> m; 6 | int ret = n; 7 | for (int i = 1; i <= n * 2; ++ i) { 8 | int tmp = abs(i - m); 9 | for (int j = i; j <= n * 2; j += i) { 10 | // i man, j banana 11 | ret = min(ret, tmp + abs(j - n)); 12 | } 13 | } 14 | cout << ret << endl; 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /hackerearth/algorithms-qualifiers-round-2/cube-change-qualifier2.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int T; cin >> T; 6 | for (int cas = 1; cas <= T; ++ cas) { 7 | int n; cin >> n; 8 | if (n == 1) puts("1"); 9 | else printf("%lld\n", 6ll * n * n - 12ll * n + 8); 10 | } 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /japan-olympiad-in-informatics/2014-2015/joiopen2015/C.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | return 0; 5 | } 6 | -------------------------------------------------------------------------------- /japan-olympiad-in-informatics/2019-2020/joi2020_yo1a/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b, c; 5 | scanf("%d%d%d", &a, &b, &c); 6 | int cnt = (a == 1) + (b == 1) + (c == 1); 7 | if (cnt >= 2) puts("1"); 8 | else puts("2"); 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /japan-olympiad-in-informatics/2019-2020/joi2020_yo1a/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | int ret = 0; 7 | for (int i = 0; i <= n; ++i) { 8 | char c = getchar(); 9 | ret += (c == 'a') || (c == 'i') || (c == 'u') || (c == 'e') || (c == 'o'); 10 | } 11 | printf("%d\n", ret); 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /japan-olympiad-in-informatics/2019-2020/joi2020_yo1b/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int a, b, c; 6 | scanf("%d%d%d", &a, &b, &c); 7 | if (b < c) std::swap(b, c); 8 | if (a < b) std::swap(a, b); 9 | if (b < c) std::swap(b, c); 10 | printf("%d\n", a + b); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /japan-olympiad-in-informatics/2019-2020/joi2020_yo1b/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | char s[1000]; 5 | 6 | int main() { 7 | int n, a, b; 8 | scanf("%d%d%d", &n, &a, &b); 9 | scanf("%s", s); 10 | std::reverse(s + a - 1, s + b); 11 | puts(s); 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /japan-olympiad-in-informatics/2019-2020/joi2020_yo1b/C.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, m; 6 | scanf("%d%d", &n, &m); 7 | std::vector cnt(m); 8 | for (int i = 0, x; i < n; ++i) { 9 | scanf("%d", &x); 10 | cnt[x - 1]++; 11 | } 12 | int ret = 0; 13 | for (auto &x: cnt) { 14 | if (x > ret) ret = x; 15 | } 16 | printf("%d\n", ret); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /japan-olympiad-in-informatics/2019-2020/joi2020_yo1c/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int x, l, r; 5 | scanf("%d%d%d", &x, &l, &r); 6 | if (x < l) x = l; 7 | else if (x > r) x = r; 8 | printf("%d\n", x); 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /japan-olympiad-in-informatics/2019-2020/joi2020_yo1c/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | char s[1000]; 4 | 5 | int main() { 6 | int n; 7 | scanf("%d%s", &n, s); 8 | for (int i = 0; i + 3 <= n; ++i) { 9 | if (s[i] == 'j' && s[i + 1] == 'o' && s[i + 2] == 'i') { 10 | s[i] = 'J'; 11 | s[i + 1] = 'O'; 12 | s[i + 2] = 'I'; 13 | } 14 | } 15 | puts(s); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /japan-olympiad-in-informatics/2019-2020/joi2020_yo1c/C.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n; 6 | scanf("%d", &n); 7 | std::vector a(n); 8 | for (int i = 0; i < n; ++i) scanf("%d", &a[i]); 9 | int ret = 1; 10 | for (int i = 0, j; i < n; i = j) { 11 | for (j = i + 1; j < n && a[j - 1] <= a[j]; ++j); 12 | if (j - i > ret) ret = j - i; 13 | } 14 | printf("%d\n", ret); 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /japan-olympiad-in-informatics/2019-2020/joi2020yo2/C.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const int N = 1e6 + 10; 5 | 6 | std::vector edges[N]; 7 | 8 | int dfs(int u) { 9 | int ret = 1; 10 | for (auto &v: edges[u]) ret += dfs(v); 11 | return ret; 12 | } 13 | 14 | int main() { 15 | int n; 16 | scanf("%d", &n); 17 | for (int i = 1; i <= n; ++i) { 18 | int j = i; 19 | for (int m = i; m; m /= 10) j += m % 10; 20 | if (j <= n) edges[j].push_back(i); 21 | } 22 | printf("%d\n", dfs(n)); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /japan-olympiad-in-informatics/2019-2020/joi2020yo2_mock/persuasion.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | int c1 = 0, c2 = 0; 7 | int A, B; 8 | scanf("%d%d", &A, &B); 9 | for (int i = 1; i < n; ++i) { 10 | int a, b; 11 | scanf("%d%d", &a, &b); 12 | if (a > A) ++c1; 13 | if (b > B) ++c2; 14 | } 15 | printf("%d\n", c1 < c2 ? c1 : c2); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /japan-olympiad-in-informatics/2019-2020/joisc2020day4/dango2.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zimpha/competitive-programming/147cb2be02917d12fdbe488c084567c9d0a7d76c/japan-olympiad-in-informatics/2019-2020/joisc2020day4/dango2.zip -------------------------------------------------------------------------------- /miscellaneous/new-year-mlr-blitz-2019/F.py: -------------------------------------------------------------------------------- 1 | from random import shuffle 2 | from fractions import gcd 3 | 4 | T = input() 5 | for _ in range(T): 6 | n = input() 7 | ret = int(n) 8 | n = [ord(x) - ord('0') for x in n] 9 | for _ in range(250): 10 | shuffle(n) 11 | r = 0 12 | for x in n: 13 | r = r * 10 + x 14 | ret = gcd(ret, r) 15 | print(ret) 16 | -------------------------------------------------------------------------------- /ontak/2007/poz.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | int n; 7 | scanf("%d", &n); 8 | std::vector a(n); 9 | for (int i = 0; i < n; ++i) { 10 | scanf("%d", &a[i]); 11 | } 12 | std::set> s; 13 | for (int i = 0; i < n; ++i) { 14 | std::vector t(500); 15 | for (int j = i; j < n; ++j) { 16 | t[a[j] - 1] = 1; 17 | s.insert(t); 18 | } 19 | } 20 | printf("%d\n", (int)s.size()); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /opencup/xx/gp-of-tokyo/H.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const int inf = 1e9; 4 | 5 | int main() { 6 | printf("%d %d\n", -inf, 0); 7 | printf("%d %d\n", 1, inf); 8 | printf("%d %d\n", 0, -inf); 9 | printf("%d %d\n", inf, -1); 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /opencup/xxi/gp-of-spb/G.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using i64 = long long; 4 | 5 | const int mod = 998244353; 6 | 7 | i64 pow_mod(i64 a, i64 n) { 8 | i64 r = 1; 9 | for (; n; n >>= 1) { 10 | if (n & 1) r = r * a % mod; 11 | a = a * a % mod; 12 | } 13 | return r; 14 | } 15 | 16 | int main() { 17 | int n, m; 18 | scanf("%d%d", &n, &m); 19 | printf("%lld\n", pow_mod(n, m - 1) * pow_mod(m, n - 1) % mod); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /opencup/xxi/gp-of-spb/I.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const int N = 500 + 10; 4 | 5 | int dp[N * N]; 6 | 7 | int main() { 8 | int n, m; 9 | scanf("%d%d", &n, &m); 10 | for (int i = 0; i <= m; ++i) dp[i] = 1; 11 | for (int i = 1; i <= n; ++i) { 12 | for (int j = m; j >= i; --j) { 13 | dp[j] ^= dp[j - i]; 14 | } 15 | for (int j = 1; j <= m; ++j) dp[j] ^= dp[j - 1]; 16 | } 17 | printf("%d\n", dp[m] ^ (m == 0 ? 0 : dp[m - 1])); 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /petrozavodsk-training-camp/2014-winter/moscow-su-trinity-contest/D.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, k; 6 | scanf("%d%d", &n, &k); 7 | if (k == 1) printf("%lld\n", 1ll * n * (n + 1) / 2); 8 | else { 9 | double ret = 0; 10 | for (int i = 1; i <= n && i <= 1000000; ++i) { 11 | ret += pow(k, (i + 1) / 2 - i) * (n - i + 1); 12 | } 13 | printf("%.10f\n", ret); 14 | } 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /petrozavodsk-training-camp/2018-winter/jagiellonian-u-contest/F.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int T; 6 | scanf("%d", &T); 7 | for (int cas = 1; cas <= T; ++cas) { 8 | int r; 9 | scanf("%*d%*d%*d%d%*d%*d%*d%*d", &r); 10 | printf("%.20f\n", r * r * acos(-1.0)); 11 | } 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /petrozavodsk-training-camp/2018-winter/jagiellonian-u-contest/I.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int T; 5 | scanf("%d", &T); 6 | for (int cas = 1; cas <= T; ++cas) { 7 | int n; 8 | scanf("%d", &n); 9 | printf("%c\n", (n % 2) ? 'B' : 'A'); 10 | } 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /petrozavodsk-training-camp/2020-winter/300iq-contest-3/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int T; 5 | scanf("%d", &T); 6 | for (int cas = 1; cas <= T; ++cas) { 7 | int n, cnt = 0; 8 | scanf("%d", &n); 9 | for (int i = 0, x; i < n; ++i) { 10 | scanf("%d", &x); 11 | cnt += x != 1; 12 | } 13 | if (n / 2 < cnt) cnt = n / 2; 14 | if (n == 2) cnt = 1; 15 | printf("%d\n", cnt); 16 | } 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /polish-olympiad-in-informatics/i/sum.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int T; 6 | scanf("%d", &T); 7 | for (int cas = 1; cas <= T; ++cas) { 8 | char s[100]; 9 | scanf("%s", s); 10 | while (true) { 11 | if (strlen(s) == 1 && (s[0] == '1' || s[0] == '4')) break; 12 | printf("%s ", s); 13 | int n = 0; 14 | for (int i = 0; s[i]; ++i) n += (s[i] - '0') * (s[i] - '0'); 15 | sprintf(s, "%d", n); 16 | } 17 | printf("%s\n", s); 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /polish-olympiad-in-informatics/i/tro.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | int n; 7 | scanf("%d", &n); 8 | std::vector p(n); 9 | for (int i = 0; i < n; ++i) { 10 | int a, b; 11 | scanf("%d/%d", &a, &b); 12 | p[i] = 1.0 * a / b; 13 | } 14 | std::sort(p.begin(), p.end()); 15 | puts(p[0] + p[1] > p.back() ? "TAK" : "NIE"); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /polish-olympiad-in-informatics/ii/tro.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | const int N = 1e6 + 10; 6 | 7 | int a[N]; 8 | 9 | int main() { 10 | int n = 0; 11 | for (int x; scanf("%d", &x) == 1 && x; ) { 12 | a[n++] = x; 13 | if (n > 1000) break; 14 | } 15 | std::sort(a, a + n); 16 | for (int i = 0; i + 2 < n; ++i) { 17 | if (a[i] + a[i + 1] > a[i + 2]) { 18 | printf("%d %d %d\n", a[i], a[i + 1], a[i + 2]); 19 | return 0; 20 | } 21 | } 22 | puts("NIE"); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /polish-olympiad-in-informatics/iii/per.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | std::vector solve(int n) { 5 | if (n == 1) return {1}; 6 | auto p = solve(n / 2); 7 | auto q = solve(n - n / 2); 8 | for (auto &&x : p) x *= 2; 9 | for (auto &&x : q) p.push_back(x * 2 - 1); 10 | return p; 11 | } 12 | 13 | int main() { 14 | int n; 15 | scanf("%d", &n); 16 | auto p = solve(n); 17 | for (auto && x: p) printf("%d\n", x - 1); 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /polish-olympiad-in-informatics/iv/lic.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /polish-olympiad-in-informatics/ix/min.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n; 6 | scanf("%d", &n); 7 | std::vector s(n - 1); 8 | for (int i = 0; i < n -1; ++i) { 9 | scanf(" %c", &s[i]); 10 | } 11 | for (int i = 0; i < n - 1; ++i) { 12 | if (s[i] == '-') putchar('-'); 13 | else { 14 | if (s[i - 1] == '-') putchar('('); 15 | putchar('-'); 16 | if (i == n - 2 || s[i + 1] == '-') putchar(')'); 17 | } 18 | } 19 | puts(""); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /prime-contest-2016/ny.en.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zimpha/competitive-programming/147cb2be02917d12fdbe488c084567c9d0a7d76c/prime-contest-2016/ny.en.pdf -------------------------------------------------------------------------------- /project-euler/volume01/1.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | template 5 | int sol() { 6 | int sum(0); 7 | for (int i = 1; i < n; ++ i) { 8 | if (i % 3 == 0 || i % 5 == 0) { 9 | sum += i; 10 | } 11 | } 12 | return sum; 13 | } 14 | 15 | int main() { 16 | cout << sol<10>() << endl; 17 | cout << sol<1000>() << endl; 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /project-euler/volume01/10.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | const int MAXN = 2000000 + 10; 5 | int pl[MAXN]; 6 | 7 | LL sol(int n) { 8 | LL ret(0); 9 | fill(pl, pl + n, 0); 10 | for (int i = 2; i < n; ++ i) if (!pl[i]) { 11 | ret += i; 12 | for (int j = i; j < n; j += i) pl[j] = 1; 13 | } 14 | return ret; 15 | } 16 | 17 | int main() { 18 | cout << sol(10) << endl; 19 | cout << sol(2000000) << endl; 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /project-euler/volume01/13.py: -------------------------------------------------------------------------------- 1 | s = 0 2 | for _ in xrange(100): 3 | x = input() 4 | s = s + x 5 | 6 | print s 7 | -------------------------------------------------------------------------------- /project-euler/volume01/15.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | 5 | LL sol(int n, int m) { 6 | vector > g; 7 | g.assign(n + 1, vector(m + 1, 0)); 8 | for (int i = 0; i <= n; ++ i) { 9 | for (int j = 0; j <= m; ++ j) { 10 | if (i == 0 || j == 0) g[i][j] = 1; 11 | else g[i][j] = g[i - 1][j] + g[i][j - 1]; 12 | } 13 | } 14 | return g[n][m]; 15 | } 16 | 17 | int main() { 18 | cout << sol(20, 20) << endl; 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /project-euler/volume01/16.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol() { 5 | string s; cin >> s; 6 | int ret(0); 7 | for (auto &c: s) ret += c - '0'; 8 | return ret; 9 | } 10 | 11 | int main() { 12 | cout << sol() << endl; 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /project-euler/volume01/17.py: -------------------------------------------------------------------------------- 1 | print 21124 2 | -------------------------------------------------------------------------------- /project-euler/volume01/2.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | template 5 | int sol() { 6 | int sum(0), a(1), b(1); 7 | for (; ;) { 8 | int c = a + b; 9 | if (c > n) break; 10 | if (c % 2 == 0) sum += c; 11 | a = b; b = c; 12 | } 13 | return sum; 14 | } 15 | 16 | int main() { 17 | cout << sol<4000000>() << endl; 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /project-euler/volume01/20.py: -------------------------------------------------------------------------------- 1 | n = input() 2 | s = 1 3 | for i in xrange(n): 4 | s = s * (i + 1) 5 | print s 6 | 7 | s = str(s) 8 | n = len(s) 9 | ret = 0 10 | for i in xrange(n): 11 | ret += ord(s[i]) - ord('0'); 12 | print ret 13 | -------------------------------------------------------------------------------- /project-euler/volume01/21.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol(int n) { 5 | vector dv(n + 1, 0); 6 | for (int i = 1; i <= n; ++ i) { 7 | for (int j = i + i; j <= n; j += i) { 8 | dv[j] += i; 9 | } 10 | } 11 | int ret(0); 12 | for (int i = 1; i <= n; ++ i) { 13 | if (dv[i] <= n && dv[dv[i]] == i && i != dv[i]) { 14 | ret += i; 15 | } 16 | } 17 | return ret; 18 | } 19 | 20 | int main() { 21 | cout << sol(10000) << endl; 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /project-euler/volume01/22.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol() { 5 | vector v; 6 | string s; 7 | while (cin >> s) { 8 | v.push_back(s); 9 | } 10 | sort(v.begin(), v.end()); 11 | int ret(0); 12 | for (size_t i = 0; i < v.size(); ++ i) { 13 | int val(0); 14 | for (auto &c: v[i]) val += c - 'A' + 1; 15 | ret += (i + 1) * val; 16 | } 17 | return ret; 18 | } 19 | 20 | int main() { 21 | cout << sol() << endl; 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /project-euler/volume01/24.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | void sol(int n) { 5 | int p[10]; 6 | for (int i = 0; i < 10; ++ i) p[i] = i; 7 | for (int _ = 1; _ < n; ++ _) { 8 | next_permutation(p, p + 10); 9 | } 10 | for (int i = 0; i < 10; ++ i) cout << p[i]; 11 | cout << endl; 12 | } 13 | 14 | int main() { 15 | sol(1000000); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /project-euler/volume01/25.py: -------------------------------------------------------------------------------- 1 | def sol(n): 2 | f1 = 1 3 | f2 = 1 4 | i = 3 5 | while True: 6 | t = f1 + f2 7 | f1, f2 = f2, t 8 | if len(str(t)) == n: 9 | return i 10 | i = i + 1 11 | return -1 12 | 13 | print sol(1000) 14 | -------------------------------------------------------------------------------- /project-euler/volume01/26.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int cycle(int n) { 5 | vector v(n, 0); 6 | int a = 1; 7 | for (int i = 1; ; ++ i) { 8 | if (v[a]) return i - v[a]; 9 | v[a] = i; 10 | a = a * 10 % n; 11 | } 12 | return -1; 13 | } 14 | 15 | int main() { 16 | int ret(0), mx(-1);; 17 | for (int d = 2; d < 1000; ++ d) { 18 | int c = cycle(d); 19 | if (c > mx) mx = c, ret = d; 20 | } 21 | cout << ret << endl; 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /project-euler/volume01/28.py: -------------------------------------------------------------------------------- 1 | def sol(n): 2 | return (16 * n * n * n + 30 * n * n + 26 * n + 3) / 3 3 | 4 | print sol(2) 5 | print sol(500) 6 | -------------------------------------------------------------------------------- /project-euler/volume01/3.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | system("factor 600851475143"); 6 | return 0; 7 | } 8 | -------------------------------------------------------------------------------- /project-euler/volume01/30.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol() { 5 | int ret(0); 6 | for (int i = 2; i < 1e6; ++ i) { 7 | int s(0); 8 | for (int n = i; n; n /= 10) { 9 | int d(1); 10 | for (int _ = 0; _ < 5; ++ _) { 11 | d = d * (n % 10); 12 | } 13 | s += d; 14 | } 15 | if (s == i) ret += i; 16 | } 17 | return ret; 18 | } 19 | 20 | int main() { 21 | cout << sol() << endl; 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /project-euler/volume01/31.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol(int n) { 5 | vector g(n + 1, 0); 6 | const int c[] = {1, 2, 5, 10, 20, 50, 100, 200}; 7 | g[0] = 1; 8 | for (int i = 0; i < 8; ++ i) { 9 | for (int j = c[i]; j <= n; ++ j) { 10 | g[j] += g[j - c[i]]; 11 | } 12 | } 13 | return g[n]; 14 | } 15 | 16 | int main() { 17 | cout << sol(200) << endl; 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /project-euler/volume01/34.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n = 10000000; 6 | int fac[10] = {1}; 7 | for (int i = 1; i < 10; ++ i) { 8 | fac[i] = fac[i - 1] * i; 9 | } 10 | int ret(0); 11 | for (int i = 10; i < n; ++ i) { 12 | int tmp(0); 13 | for (int x = i; x; x /= 10) { 14 | tmp += fac[x % 10]; 15 | } 16 | if (tmp == i) ret += i; 17 | } 18 | cout << ret << endl; 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /project-euler/volume01/36.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int reverse(int n, int b) { 5 | int r(0); 6 | for (; n; n /= b) { 7 | r = r * b + n % b; 8 | } 9 | return r; 10 | } 11 | 12 | typedef long long LL; 13 | LL sol(int n) { 14 | LL ret(0); 15 | for (int i = 1; i < n; ++ i) { 16 | if (reverse(i, 2) == i && reverse(i, 10) == i) { 17 | ret += i; 18 | } 19 | } 20 | return ret; 21 | } 22 | 23 | int main() { 24 | cout << sol(1000000) << endl; 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /project-euler/volume01/39.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol(int n) { 5 | vector cnt(n + 1, 0); 6 | for (int a = 1; a < n; ++ a) { 7 | for (int b = a + 1; b < n; ++ b) { 8 | int c = sqrt(a * a + b * b); 9 | if (c * c == a * a + b * b && a + b + c <= n) { 10 | cnt[a + b + c] ++; 11 | } 12 | } 13 | } 14 | return max_element(cnt.begin(), cnt.end()) - cnt.begin(); 15 | } 16 | 17 | int main() { 18 | cout << sol(1000) << endl; 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /project-euler/volume01/4.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol() { 5 | int ret(-1); 6 | for (int i = 100; i <= 999; ++ i) { 7 | for (int j = i; j <= 999; ++ j) { 8 | int n = i * j, y = 0; 9 | for (int x = n; x; x /= 10) { 10 | y = y * 10 + x % 10; 11 | } 12 | if (n == y) ret = max(ret, i * j); 13 | } 14 | } 15 | return ret; 16 | } 17 | 18 | int main() { 19 | cout << sol() << endl; 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /project-euler/volume01/40.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int d(int n) { 5 | int s(0); 6 | for (int i = 1; ; ++ i) { 7 | static char buf[10]; 8 | sprintf(buf, "%d", i); 9 | s += strlen(buf); 10 | if (s >= n) { 11 | return buf[n - s + strlen(buf) - 1] - '0'; 12 | } 13 | } 14 | return 0; 15 | } 16 | 17 | int main() { 18 | cout << d(1) * d(10) * d(100) * d(1000) * d(10000) * d(100000) * d(1000000) << endl; 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /project-euler/volume01/42.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol() { 5 | string s; 6 | int ret(0); 7 | while (cin >> s) { 8 | int v(0); 9 | for (auto &c: s) v += c - 'A' + 1; 10 | int n = sqrt(v * 2); 11 | if (n * (n + 1) == v * 2) ++ ret; 12 | } 13 | return ret; 14 | } 15 | 16 | int main() { 17 | cout << sol() << endl; 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /project-euler/volume01/44.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool ok(int n) { 5 | double x = (sqrt(1 + 24 * n) + 1) / 6; 6 | return x == (int)x; 7 | } 8 | 9 | int main() { 10 | for (int i = 1; ; ++ i) { 11 | int a = i * (i * 3 - 1) >> 1; 12 | for (int j = 1; j < i; ++ j) { 13 | int b = j * (j * 3 - 1) >> 1; 14 | if (ok(a + b) && ok(a - b)) { 15 | cout << a - b << endl; 16 | return 0; 17 | } 18 | } 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /project-euler/volume01/45.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool isP(double n) { 5 | double x = (sqrt(1 + 24 * n) + 1) / 6; 6 | return x == (int)x; 7 | } 8 | 9 | int main() { 10 | for (int i = 144; ; ++ i) { 11 | int n = i * (2 * i - 1); 12 | if (isP(n)) { 13 | cout << i << " " << n << endl; 14 | return 0; 15 | } 16 | } 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /project-euler/volume01/47.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol() { 5 | int n = 1000000; 6 | vector vs(n, 0); 7 | for (int i = 2; i < n; ++ i) if (!vs[i]) { 8 | for (int j = i; j < n; j += i) vs[j] ++; 9 | } 10 | for (int i = 1; i < n; ++ i) { 11 | if (vs[i] == 4 && vs[i + 1] == 4 && vs[i + 2] == 4 && vs[i + 3] == 4) { 12 | return i; 13 | } 14 | } 15 | return -1; 16 | } 17 | 18 | int main() { 19 | cout << sol() << endl; 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /project-euler/volume01/48.py: -------------------------------------------------------------------------------- 1 | s = 0 2 | for i in xrange(1, 1001): 3 | s += pow(i, i, 10000000000L) 4 | print (s % 10000000000L) 5 | -------------------------------------------------------------------------------- /project-euler/volume01/5.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol(int n) { 5 | int ret(1); 6 | for (int i = 1; i <= n; ++ i) { 7 | ret = ret / __gcd(ret, i) * i; 8 | } 9 | return ret; 10 | } 11 | 12 | int main() { 13 | cout << sol(20) << endl; 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /project-euler/volume01/6.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol(int n) { 5 | int sum(0), res(0); 6 | for (int i = 1; i <= n; ++ i) { 7 | sum += i; 8 | res += i * i; 9 | } 10 | return sum * sum - res; 11 | } 12 | 13 | int main() { 14 | cout << sol(100) << endl; 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /project-euler/volume01/7.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol(int m) { 5 | const int n = 1000000; 6 | static int pl[n]; 7 | int s(0); 8 | for (int i = 2; i < n; ++ i) if (!pl[i]) { 9 | pl[s ++] = i; 10 | for (int j = i; j < n; j += i) pl[j] = 1; 11 | } 12 | return pl[m - 1]; 13 | } 14 | 15 | int main() { 16 | cout << sol(10001) << endl; 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /project-euler/volume01/9.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol() { 5 | for (int a = 1; a < 1000; ++ a) { 6 | for (int b = 1; b < 1000; ++ b) { 7 | int c = 1000 - a - b; 8 | if (c >= 0 && a * a + b * b == c * c) { 9 | return a * b * c; 10 | } 11 | } 12 | } 13 | } 14 | 15 | int main() { 16 | cout << sol() << endl; 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /project-euler/volume02/100.py: -------------------------------------------------------------------------------- 1 | x, y = 1, 1 2 | while True: 3 | x, y = 3 * x + 2 * y, 4 * x + 3 * y 4 | if x % 2 == 1 and y % 2 == 1: 5 | B = (x + 1) / 2 6 | T = (y + 1) / 2 7 | if T > 1e12: 8 | print B 9 | break 10 | -------------------------------------------------------------------------------- /project-euler/volume02/53.py: -------------------------------------------------------------------------------- 1 | f = {} 2 | f[0] = 1 3 | for i in xrange(1, 101): 4 | f[i] = f[i - 1] * i 5 | 6 | ret = 0 7 | for i in xrange(1, 101): 8 | for j in xrange(0, i + 1): 9 | c = f[i] / f[j] / f[i - j] 10 | if c > 1000000L: 11 | ret += 1 12 | 13 | print ret 14 | -------------------------------------------------------------------------------- /project-euler/volume02/55.py: -------------------------------------------------------------------------------- 1 | def ok(n): 2 | n += int(str(n)[::-1]) 3 | for i in xrange(50): 4 | s = str(n) 5 | s = s[::-1] 6 | t = int(s) 7 | if t == n: 8 | return 0 9 | n += t 10 | return 1 11 | 12 | print ok(47) 13 | print ok(349) 14 | print ok(4994) 15 | ret = 0 16 | for n in xrange(1, 10001): 17 | ret += ok(n) 18 | print ret 19 | -------------------------------------------------------------------------------- /project-euler/volume02/56.py: -------------------------------------------------------------------------------- 1 | def gao(n): 2 | s = str(n) 3 | r = 0 4 | for i in xrange(len(s)): 5 | r += ord(s[i]) - ord('0') 6 | return r 7 | 8 | r = 0 9 | for a in xrange(1, 100): 10 | for b in xrange(1, 100): 11 | t = gao(a ** b) 12 | if t > r: 13 | r = t 14 | print r 15 | -------------------------------------------------------------------------------- /project-euler/volume02/57.py: -------------------------------------------------------------------------------- 1 | a, b = 1, 1 2 | ret = 0 3 | 4 | for i in xrange(1000): 5 | a, b = a + 2 * b, a + b 6 | if len(str(a)) > len(str(b)): 7 | ret = ret + 1 8 | print ret 9 | -------------------------------------------------------------------------------- /project-euler/volume02/63.py: -------------------------------------------------------------------------------- 1 | from math import * 2 | 3 | ret = 0 4 | i = 0 5 | for n in xrange(1, 1000): 6 | i = ceil(pow(10, (n - 1.0) / n)); 7 | ret += 10 - i 8 | if i >= 10: 9 | break 10 | print n 11 | print ret 12 | -------------------------------------------------------------------------------- /project-euler/volume02/64.cc: -------------------------------------------------------------------------------- 1 | //http://oeis.org/A013943/b013943.txt 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int ret(0); 7 | for (int i = 1; i <= 10000; ++ i) { 8 | int x = sqrt(i); 9 | if (x * x == i) continue; 10 | int a, b; cin >> a >> b; 11 | ret += b & 1; 12 | } 13 | cout << ret << endl; 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /project-euler/volume02/65.py: -------------------------------------------------------------------------------- 1 | a = 0 2 | b = 1 3 | for i in xrange(0, 100): 4 | if i == 99: 5 | a += b * 2 6 | else: 7 | k = 98 - i 8 | if k % 3 == 1: 9 | k = k / 3 + 1 10 | k *= 2 11 | else: 12 | k = 1 13 | a, b = b, k * b + a 14 | print a, b 15 | s = str(a) 16 | ret = 0 17 | for i in xrange(len(s)): 18 | ret += ord(s[i]) - ord('0'); 19 | print ret 20 | -------------------------------------------------------------------------------- /project-euler/volume02/72.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | 5 | LL sol(int n) { 6 | vector phi(n + 1); 7 | for (int i = 0; i <= n; i ++) phi[i] = i; 8 | for (int i = 2; i <= n; ++ i) if (phi[i] == i) { 9 | for (int j = i; j <= n; j += i) { 10 | phi[j] = phi[j] / i * (i - 1); 11 | } 12 | } 13 | return accumulate(phi.begin(), phi.end(), 0LL) - 1; 14 | } 15 | 16 | int main() { 17 | cout << sol(8) << endl; 18 | cout << sol(1000000) << endl; 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /project-euler/volume02/73.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | 5 | int sol(int n) { 6 | int ret(0); 7 | for (int d = 2; d <= n; ++ d) { 8 | for (int i = 1; i < d; ++ i) if (__gcd(i, d) == 1) { 9 | ret += i * 3 > d && i * 2 < d; 10 | } 11 | } 12 | return ret; 13 | } 14 | 15 | int main() { 16 | cout << sol(8) << endl; 17 | cout << sol(12000) << endl; 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /project-euler/volume02/76.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int sol(int n) { 5 | vector dp(n + 1, 0); dp[0] = 1; 6 | for (int i = 1; i <= n; ++ i) { 7 | for (int j = i; j <= n; ++ j) { 8 | dp[j] += dp[j - i]; 9 | } 10 | } 11 | return dp[n] - 1; 12 | } 13 | 14 | int main() { 15 | cout << sol(5) << endl; 16 | cout << sol(100) << endl; 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /project-euler/volume02/79.txt: -------------------------------------------------------------------------------- 1 | 319 2 | 680 3 | 180 4 | 690 5 | 129 6 | 620 7 | 762 8 | 689 9 | 762 10 | 318 11 | 368 12 | 710 13 | 720 14 | 710 15 | 629 16 | 168 17 | 160 18 | 689 19 | 716 20 | 731 21 | 736 22 | 729 23 | 316 24 | 729 25 | 710 26 | 769 27 | 290 28 | 719 29 | 680 30 | 318 31 | 389 32 | 162 33 | 289 34 | 162 35 | 718 36 | 729 37 | 319 38 | 790 39 | 680 40 | 890 41 | 362 42 | 319 43 | 760 44 | 316 45 | 729 46 | 380 47 | 319 48 | 728 49 | 716 50 | -------------------------------------------------------------------------------- /project-euler/volume02/80.py: -------------------------------------------------------------------------------- 1 | from decimal import * 2 | 3 | getcontext().prec = 102 4 | ret = 0 5 | d = 100 6 | p = pow(10, d - 1) 7 | for n in xrange(1, 101): 8 | q = Decimal(n).sqrt() 9 | ret += sum(int(c) for c in str(q * p)[:d]) if q % 1 != 0 else 0 10 | print ret 11 | -------------------------------------------------------------------------------- /project-euler/volume02/89.py: -------------------------------------------------------------------------------- 1 | def sub(roman): 2 | result = roman 3 | replacements = [ 4 | ("VIIII", "IX"), 5 | ("IIII", "IV"), 6 | ("LXXXX", "XC"), 7 | ("XXXX", "XL"), 8 | ("DCCCC", "CM"), 9 | ("CCCC", "CD"), 10 | ] 11 | for old, new in replacements: 12 | result = result.replace(old, new) 13 | return result 14 | 15 | f = open('roman.txt', 'r') 16 | ret = 0 17 | tot = 0 18 | for l in f: 19 | tot += len(l) 20 | s = sub(l) 21 | ret += len(s) 22 | print tot - ret 23 | -------------------------------------------------------------------------------- /project-euler/volume02/92.py: -------------------------------------------------------------------------------- 1 | def f(n): 2 | if n == 1 or n == 89: 3 | return n 4 | s = 0 5 | while n > 0: 6 | s += (n % 10) * (n % 10) 7 | n /= 10 8 | return f(s) 9 | 10 | ret = 0 11 | for i in xrange(1, 10000001): 12 | x = f(i) 13 | if x == 89: 14 | ret += 1 15 | print ret 16 | -------------------------------------------------------------------------------- /project-euler/volume02/96.py: -------------------------------------------------------------------------------- 1 | from dlxsudoku import Sudoku 2 | 3 | f = open('sudoku.txt', 'r') 4 | 5 | ret = 0 6 | for l in f: 7 | s = Sudoku(l) 8 | s.solve() 9 | s = s.to_oneliner() 10 | ret += int(s[0:3]) 11 | print ret 12 | -------------------------------------------------------------------------------- /project-euler/volume02/97.py: -------------------------------------------------------------------------------- 1 | m = 10000000000 2 | print (28433 * pow(2, 7830457, m) + 1) % m 3 | -------------------------------------------------------------------------------- /project-euler/volume02/99.py: -------------------------------------------------------------------------------- 1 | from math import * 2 | 3 | ret = -1 4 | mx = 0.0 5 | for _ in xrange(0, 1000): 6 | a, b = input() 7 | if ret == -1 or b * log(a, 2) > mx: 8 | mx = b * log(a, 2) 9 | ret = _ + 1 10 | print ret 11 | -------------------------------------------------------------------------------- /project-euler/volume03/104.py: -------------------------------------------------------------------------------- 1 | from decimal import * 2 | 3 | def ok(s): 4 | for i in xrange(1, 10): 5 | if not chr(i + 48) in s: 6 | return False 7 | return True 8 | 9 | f1, f2 = 1, 1 10 | md = 1000000000 11 | ret = 2 12 | while True: 13 | ret += 1 14 | fn = (f1 + f2) % md 15 | f1, f2 = f2, fn 16 | if ok(str(fn)): 17 | t = ret * Decimal(0.20898764024997873) - Decimal(0.3494850021680094) 18 | t = 10 ** (t - int(t) + 8) 19 | if ok(str(int(t))): 20 | break 21 | print ret 22 | -------------------------------------------------------------------------------- /project-euler/volume03/108.py: -------------------------------------------------------------------------------- 1 | def solve(n): 2 | ret = 1 3 | i = 2 4 | while i * i <= n: 5 | cnt = 0 6 | while n % i == 0: 7 | cnt += 1 8 | n /= i 9 | ret *= 2 * cnt + 1 10 | i += 1 11 | if n > 1: 12 | ret *= 3 13 | return (ret + 1) / 2 14 | 15 | n = 1 16 | while True: 17 | r = solve(n) 18 | if r > 1000: 19 | break 20 | n += 1 21 | if n % 100000 == 0: 22 | print n 23 | print n 24 | -------------------------------------------------------------------------------- /project-euler/volume03/119.py: -------------------------------------------------------------------------------- 1 | ls = [] 2 | for a in xrange(2, 1000): 3 | for b in xrange(2, 50): 4 | c = str(a ** b) 5 | s = 0 6 | for x in c: 7 | s += ord(x) - ord('0') 8 | if s == a: 9 | ls.append(a ** b) 10 | ls.sort() 11 | print ls[1] 12 | print ls[9] 13 | print ls[29] 14 | -------------------------------------------------------------------------------- /project-euler/volume03/120.py: -------------------------------------------------------------------------------- 1 | def f(a): 2 | r = 2 3 | for n in xrange(1, a * a, 2): 4 | t = 2 * n * a % (a * a) 5 | if t > r: 6 | r = t 7 | return r 8 | 9 | ret = 0 10 | for a in xrange(3, 1001): 11 | ret += f(a) 12 | print ret 13 | -------------------------------------------------------------------------------- /project-euler/volume03/129.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int phi(int n) { 5 | if (__gcd(n, 10) != 1) return 0; 6 | for (int x = 1, k = 1; x; ) { 7 | x = (x * 10 + 1) % n; ++k; 8 | if (x == 0) return k; 9 | } 10 | return -1; 11 | } 12 | 13 | int run(int lim) { 14 | for (int n = 1000000; ; ++n) { 15 | if (phi(n) > lim) { 16 | return n; 17 | } 18 | } 19 | return -1; 20 | } 21 | 22 | int main() { 23 | cout << run(1000000) << endl; 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /project-euler/volume03/131.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int run(int n) { 5 | vector vs(n, 1); vs[0] = vs[1] = 0; 6 | for (int i = 2; i < n; ++i) if (vs[i]) { 7 | for (int j = i + i; j < n; j += i) vs[j] = 0; 8 | } 9 | int ret = 0; 10 | for (int x = 1; x * x * 3 + x * 3 + 1 < n; ++x) { 11 | if (vs[x * x * 3 + x * 3 + 1]) ++ret; 12 | } 13 | return ret; 14 | } 15 | 16 | int main() { 17 | cout << run(100) << endl; 18 | cout << run(1000000) << endl; 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /project-euler/volume03/137.py: -------------------------------------------------------------------------------- 1 | def run(n): 2 | fib = [0, 1] 3 | for i in xrange(2, n * 2 + 10): 4 | fib.append(fib[i - 1] + fib[i - 2]) 5 | return fib[2 * n] * fib[2 * n + 1] 6 | 7 | print run(1) 8 | print run(10) 9 | print run(15) 10 | -------------------------------------------------------------------------------- /project-euler/volume03/138.py: -------------------------------------------------------------------------------- 1 | # https://www.alpertron.com.ar/QUAD.HTM 2 | # 5x^2 + 4x + 1 = y^2, 5x^2 - 4x + 1 = y^2 3 | # x = -9x - 4y - 4 4 | # y = -20x - 9y - 8 5 | x, y = 0, 1 6 | ret = 0 7 | for i in xrange(12): 8 | x, y = -9 * x - 4 * y - 4, -20 * x - 9 * y - 8 9 | print x, y 10 | ret += abs(y) 11 | print ret 12 | -------------------------------------------------------------------------------- /project-euler/volume03/140.py: -------------------------------------------------------------------------------- 1 | # https://www.alpertron.com.ar/QUAD.HTM 2 | # 5x^2 + 14x + 1 = y^2 3 | # x = -9x - 4y - 14 4 | # y = -20x - 9y - 28 5 | st = [(0, -1), (0, 1), (-3, -2), (-3, 2), (-4, -5), (-4, 5), (2, -7), (2, 7)] 6 | sol = [] 7 | for (x, y) in st: 8 | for i in xrange(30): 9 | x, y = -9 * x - 4 * y - 14, -20 * x - 9 * y - 28 10 | if x > 0 and (not x in sol): 11 | sol.append(x) 12 | sol.sort() 13 | ret = 0 14 | for i in xrange(30): 15 | ret += sol[i] 16 | print ret 17 | -------------------------------------------------------------------------------- /project-euler/volume04/155.py: -------------------------------------------------------------------------------- 1 | from fractions import * 2 | 3 | D = [] 4 | D.append(set({Fraction(1,1)})) 5 | for n in xrange(2, 19): 6 | s = set() 7 | for a in xrange(1, n): 8 | b = n - a 9 | if b > a: 10 | continue 11 | for x in D[a-1]: 12 | for y in D[b-1]: 13 | s.add(x + y) 14 | s.add(x * y / (x + y)) 15 | D.append(s) 16 | print len(s) 17 | for i in xrange(2, 19): 18 | for x in D[i - 1]: 19 | D[0].add(x) 20 | print len(D[0]) 21 | -------------------------------------------------------------------------------- /project-euler/volume04/158.py: -------------------------------------------------------------------------------- 1 | # Eulerian(n, 2) \times \binom{26}{n} 2 | def f(n): 3 | r = 2 ** n - n - 1 4 | for i in xrange(26): 5 | r *= (i + 1) 6 | for i in xrange(n): 7 | r /= (i + 1) 8 | for i in xrange(26 - n): 9 | r /= (i + 1) 10 | return r 11 | 12 | for n in xrange(26): 13 | print f(n + 1) 14 | -------------------------------------------------------------------------------- /project-euler/volume04/163.py: -------------------------------------------------------------------------------- 1 | def mod(n, m): 2 | return n % m 3 | 4 | def T(n): 5 | return (1678 * n ** 3 + 3117 * n ** 2 + 88 * n - 345 * mod(n, 2) - 320 * mod(n, 3) - 90 * mod(n, 4) - 288 * mod(n ** 3 - n ** 2 + n, 5)) / 240 6 | 7 | print T(1) 8 | print T(2) 9 | print T(36) 10 | -------------------------------------------------------------------------------- /project-euler/volume04/168.py: -------------------------------------------------------------------------------- 1 | def run(s): 2 | r = 0 3 | for n in xrange(1, s): 4 | for k in xrange(1, 10): 5 | for d in xrange(1, 10): 6 | m = 10 * k - 1 7 | rm = (pow(10, n, m) - k % m + m) * d % m 8 | if rm == 0: 9 | s = d * (10 ** n - k) / m 10 | if len(str(s)) == n: 11 | r += s * 10 + d 12 | return r % 100000 13 | print run(100) 14 | -------------------------------------------------------------------------------- /project-euler/volume04/173.py: -------------------------------------------------------------------------------- 1 | from math import * 2 | 3 | def run(n): 4 | r = 0 5 | for a in xrange(1, n): 6 | s = max(1, a * a - n); 7 | s = int(sqrt(s)) 8 | while s * s < a * a - n: 9 | s += 1 10 | if s < a: 11 | if a % 2 == 1: 12 | r += a / 2 - s / 2 13 | else: 14 | r += (a - 1) / 2 - (s - 1) / 2 15 | return r 16 | 17 | print run(100) 18 | print run(1000000) 19 | -------------------------------------------------------------------------------- /project-euler/volume04/174.py: -------------------------------------------------------------------------------- 1 | from math import * 2 | 3 | def run(n): 4 | N = [0] * 11 5 | r = [0] * n 6 | for a in xrange(1, n): 7 | s = max(1, a * a - n); 8 | s = int(sqrt(s)) 9 | while s * s < a * a - n: 10 | s += 1 11 | if a % 2 != s % 2: 12 | s += 1 13 | for b in xrange(s, a, 2): 14 | r[a * a - b * b - 1] += 1 15 | for i in xrange(n): 16 | if r[i] <= 10 and r[i] > 0: 17 | N[r[i] - 1] += 1 18 | return N 19 | 20 | print sum(run(1000000)) 21 | -------------------------------------------------------------------------------- /project-euler/volume04/175.py: -------------------------------------------------------------------------------- 1 | def f(n, m): 2 | r = [] 3 | while m != 0: 4 | r.append(n / m) 5 | n, m = m, n % m 6 | r.reverse() 7 | r = r[:-1] 8 | if len(r) % 2 == 0: 9 | r[0] -= 1 10 | r.reverse() 11 | r.append(1) 12 | r.reverse() 13 | return r 14 | print f(13, 17) 15 | print f(123456789, 987654321) 16 | -------------------------------------------------------------------------------- /project-euler/volume04/176.py: -------------------------------------------------------------------------------- 1 | #n = 2^e * \prod p_i^f_i 2 | #f(n) = ((2e-1) \prod (2f_i+1) - 1) / 2 3 | #(2e-1) \prod (2f_i+1) = 2 * 47547 + 1 = 5 * 7 * 11 * 13 * 19 4 | #f_i = {2, 3, 5, 6, 9} 5 | #e = {3, 4, 6, 7, 10} 6 | #ans = 2^10 * 3^6 * 5^5 * 7^3 * 11^2 = 96818198400000 7 | 8 | print 96818198400000 9 | -------------------------------------------------------------------------------- /project-euler/volume04/179.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | const int N = 10000001; 4 | int d[N]; 5 | 6 | int main() { 7 | for (int i = 1; i < N; ++i) { 8 | for (int j = i; j < N; j += i) d[j]++; 9 | } 10 | int ret = 0; 11 | for (int i = 2; i + 1 < N; ++i) { 12 | ret += (d[i] == d[i + 1]); 13 | } 14 | cout << ret << endl; 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /project-euler/volume04/183.py: -------------------------------------------------------------------------------- 1 | import math 2 | import fractions 3 | # P reach max, when k = n / e 4 | def M(n): 5 | e = math.exp(1) 6 | k = round(n / e) 7 | k /= fractions.gcd(k, n) 8 | while k % 2 == 0: 9 | k /= 2 10 | while k % 5 == 0: 11 | k /= 5 12 | return k == 1 13 | 14 | def run(n): 15 | r = 0 16 | for i in xrange(5, n + 1): 17 | if M(i): 18 | d = -i 19 | else: 20 | d = i 21 | r += d 22 | return r 23 | print run(100) 24 | print run(10000) 25 | -------------------------------------------------------------------------------- /project-euler/volume04/190.py: -------------------------------------------------------------------------------- 1 | # x_i = i * x_1 2 | def P(m): 3 | s = m * (m + 1) / 2 4 | a = 2 ** s; 5 | for i in xrange(m): 6 | a *= (i + 1) ** (i + 1) 7 | b = (m + 1) ** s 8 | return a / b 9 | r = 0 10 | for m in xrange(2, 16): 11 | r += P(m) 12 | print r 13 | -------------------------------------------------------------------------------- /project-euler/volume04/197.py: -------------------------------------------------------------------------------- 1 | def f(x): 2 | r = int(2 ** (30.403243784 - x * x)) 3 | return r * 10 ** -9 4 | 5 | u = -1 6 | for i in xrange(10000): 7 | u = f(u) 8 | 9 | print u + f(u) 10 | -------------------------------------------------------------------------------- /project-euler/volume04/198.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | def run(x1, y1, x2, y2, L): 4 | u, v = x1 * y2 + x2 * y1, y1 * y2 * 2 5 | if x1 * 100 >= y1 or v > L or (x1 == 0 and y2 * y2 * 2 >= L): 6 | return 0 7 | ret = 0 8 | if x1 != 0 and v > u * 100: 9 | ret = 1 10 | u, v = x1 + x2, y1 + y2 11 | ret += run(x1, y1, u, v, L) 12 | ret += run(u, v, x2, y2, L) 13 | return ret 14 | 15 | sys.setrecursionlimit(100000) 16 | print run(0, 1, 1, 1, 10 ** 8) + 10 ** 8 / 2 - 50 17 | -------------------------------------------------------------------------------- /project-euler/volume05/206.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long LL; 4 | 5 | bool ok(LL n) { 6 | for (int i = 10; n; --i) { 7 | if (n % 10 != i % 10) return 0; 8 | n /= 100; 9 | } 10 | return true; 11 | } 12 | 13 | LL run() { 14 | for (int s = 101010101; s <= 138902662; ++s) { 15 | if (ok(s * 10ll * s * 10ll)) return s * 10ll; 16 | } 17 | return -1; 18 | } 19 | 20 | int main() { 21 | cout << run() << endl; 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /project-euler/volume05/207.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | long long run(int a, int b) { 4 | int s = 0; 5 | for (int x = 1; ; ++x) { 6 | if (x != 1 && __builtin_popcount(x) == 1) ++s; 7 | if (s && 1ll * s * b < 1ll * a * x) { 8 | return 1ll * x * (x + 1); 9 | } 10 | } 11 | return -1; 12 | } 13 | 14 | int main() { 15 | std::cout << run(1, 12345) << std::endl; 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /project-euler/volume05/225.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | bool ok(int m) { 4 | int t1 = 1, t2 = 1, t3 = 1; 5 | for (int i = 0; i < m * 100; ++i) { 6 | int x = (t1 + t2 + t3) % m; 7 | t1 = t2, t2 = t3, t3 = x; 8 | if (x == 0) return true; 9 | } 10 | return false; 11 | } 12 | 13 | int run(int n) { 14 | for (int s = 27; n; s += 2) { 15 | if (!ok(s)) --n; 16 | if (!n) return s; 17 | } 18 | return -1; 19 | } 20 | 21 | int main() { 22 | std::cout << run(124) << std::endl; 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /project-euler/volume05/228.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int run(int l, int r) { 4 | std::set> S; 5 | for (int n = l; n <= r; ++n) { 6 | for (int i = 0; i < n; ++i) { 7 | int a = i * 360, b = n; 8 | int g = std::__gcd(a, b); 9 | S.insert({a / g, b / g}); 10 | } 11 | } 12 | return S.size(); 13 | } 14 | 15 | int main() { 16 | assert(run(3, 4) == 6); 17 | std::cout << run(1864, 1909) << std::endl; 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /project-euler/volume05/233.cc: -------------------------------------------------------------------------------- 1 | // f(n) = 8 * g(n) + 4 2 | // n=2^e * \prod_i p_i^f_i \prod_j q_j^t_j, p_i % 4 = 1, q_j % 4 = 3 3 | // g(n) = (\prod_i (2f_i+1) - 1) / 2 4 | // g(n) = 52 = 2 * 2 * 3 5 | // \prod_i (2f_i+1) = 105 = 3 * 5 * 7 6 | // {1, 2, 3}, {3, 7}, {2, 10} 7 | #include 8 | 9 | using LL = long long; 10 | 11 | LL run(LL lim) { 12 | return 271204031455541309ll; 13 | } 14 | 15 | int main() { 16 | std::cout << run(100000000000ll) << std::endl; 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /project-euler/volume05/239.py: -------------------------------------------------------------------------------- 1 | from decimal import * 2 | fac = [1] * 101 3 | for i in xrange(1, 101): 4 | fac[i] = i * fac[i - 1] 5 | 6 | cache = {} 7 | 8 | def C(n, m): 9 | return fac[n] / fac[n - m] / fac[m] 10 | 11 | def f(n, m): 12 | if (n, m) in cache: 13 | return cache[(n, m)] 14 | ret = fac[n] 15 | for k in xrange(1, m + 1): 16 | ret -= C(m, k) * f(n - k, m - k) 17 | cache[(n, m)] = ret 18 | return ret 19 | 20 | getcontext().prec = 12 21 | print Decimal(C(25, 3) * f(75 + 22, 22)) / Decimal(fac[100]) 22 | -------------------------------------------------------------------------------- /project-euler/volume06/271.py: -------------------------------------------------------------------------------- 1 | def run(pl): 2 | delta, mul = 1, 1 3 | for p in pl: 4 | cnt = 0 5 | for x in xrange(1, p): 6 | if pow(x, 3, p) == 1: 7 | cnt += 1 8 | if cnt == 1: 9 | delta *= p 10 | else: 11 | mul *= p 12 | print delta, mul 13 | x, r = 1, 0 14 | n = delta * mul 15 | while x < n: 16 | if x * x * x % mul == 1: 17 | r += x 18 | x += delta 19 | return r - 1 20 | 21 | print run([7, 13]) 22 | print run([2,3,5,7,11,13,17,19,23,29,31,37,41,43]) 23 | -------------------------------------------------------------------------------- /project-euler/volume07/301.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int ret = 0; 5 | for (unsigned int n = 1 << 30; n; --n) { 6 | ret += (n ^ (n << 1) ^ (n * 3)) == 0; 7 | } 8 | std::cout << ret << std::endl; 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /project-euler/volume07/316.py: -------------------------------------------------------------------------------- 1 | # g(n) = \sum 10 ^ k - |n|, where first k digist equals to last k digits 2 | def g(n): 3 | s = str(n) 4 | ret = 1 5 | for k in xrange(1, len(s) + 1): 6 | a, b = s[:k], s[-k:] 7 | if a == b: 8 | ret += 10 ** k 9 | return ret - len(s) 10 | 11 | def run(n, m): 12 | ret = 0 13 | for i in xrange(2, n): 14 | ret += g(m / i) 15 | return ret 16 | 17 | print g(535) 18 | print run(10 ** 3, 10 ** 6) 19 | print run(10 ** 6, 10 ** 16) 20 | -------------------------------------------------------------------------------- /project-euler/volume07/317.py: -------------------------------------------------------------------------------- 1 | from math import pi 2 | v, h, g = 20, 100, 9.81 3 | 4 | print pi * (2 * g * v * h + v * v * v) ** 2 / (4 * g ** 3) 5 | -------------------------------------------------------------------------------- /project-euler/volume07/321.py: -------------------------------------------------------------------------------- 1 | # M(n) = n * (n + 2) 2 | def run(n): 3 | # x = 3x + y + 2 4 | # y = 8x + 3y + 8 5 | # (x, y) = (0, 1), (1, 5) 6 | ok = [] 7 | x, y = 0, 1; 8 | for i in xrange(n): 9 | x, y = 3 * x + y + 2, 8 * x + 3 * y + 8; 10 | ok.append(x) 11 | x, y = 1, 5; 12 | for i in xrange(n): 13 | ok.append(x) 14 | x, y = 3 * x + y + 2, 8 * x + 3 * y + 8; 15 | ok.sort() 16 | ret = 0 17 | for i in xrange(n): 18 | ret += ok[i] 19 | return ret 20 | 21 | print run(5) 22 | print run(40) 23 | -------------------------------------------------------------------------------- /project-euler/volume07/323.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using LL = long long; 4 | 5 | double run() { 6 | double ret = 0, p = 1; 7 | for (int i = 0; i < 100; ++i) { 8 | ret += 1 - pow(1 - p, 32); 9 | p *= 0.5; 10 | } 11 | return ret; 12 | } 13 | 14 | int main() { 15 | std::cout.precision(20); 16 | std::cout << run() << std::endl; 17 | return 0; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /project-euler/volume07/327.py: -------------------------------------------------------------------------------- 1 | import math 2 | 3 | def M(C, R): 4 | if C > R: 5 | return R + 1 6 | tc = C - 2 7 | for i in xrange(C, R + 1): 8 | C = int(2 * math.ceil((C - 1.0) / tc) + C - 1) 9 | return C 10 | 11 | def run(cl, cr, R): 12 | ret = 0 13 | for i in xrange(cl, cr + 1): 14 | ret += M(i, R) 15 | return ret 16 | 17 | assert M(3, 6) == 123 18 | assert M(4, 6) == 23 19 | assert run(3, 4, 6) == 146 20 | assert run(3, 10, 10) == 10382 21 | print run(3, 40, 30) 22 | -------------------------------------------------------------------------------- /project-euler/volume08/371.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | double run(int n) { 4 | double E0 = 0, E1 = 0; 5 | int t = n / 2 - 1; 6 | for (int i = t; i >= 0; --i) { 7 | E1 = (2 * (t - i) * E1 + n) / (n - 1 - i); 8 | E0 = (2 * (t - i) * E0 + E1 + n) / (n - 1 - i); 9 | } 10 | return E0; 11 | } 12 | 13 | int main() { 14 | std::cout.precision(20); 15 | std::cout << run(1000) << std::endl; 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /project-euler/volume10/463.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int f(int n) { 4 | if (n == 1 || n == 3) return n; 5 | if (n % 2 == 0) return f(n / 2); 6 | if (n % 4 == 1) return 2 * f(n / 4 * 2 + 1) - f(n / 4); 7 | if (n % 4 == 3) return 3 * f(n / 4 * 2 + 1) - 2 * f(n / 4); 8 | return -1; 9 | } 10 | 11 | int main() { 12 | for (int i = 1; i <= 100; ++i) { 13 | std::cout << f(i) << std::endl; 14 | } 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /project-euler/volume10/479.py: -------------------------------------------------------------------------------- 1 | # (a_k+b_k)(b_k+c_k)(c_k+a_k) = 1 - k^2 2 | M = 10 ** 9 + 7 3 | 4 | def inv(n): 5 | return pow(n, M - 2, M) 6 | 7 | def S(n): 8 | r = 0 9 | for k in xrange(1, n + 1): 10 | a = 1 - k * k 11 | if a == 0: 12 | continue 13 | r += a * (pow(a, n, M) - 1) * inv(a - 1) 14 | r %= M 15 | r = (r + M) % M 16 | return r 17 | 18 | print S(4) 19 | print S(10 ** 6) 20 | -------------------------------------------------------------------------------- /project-euler/volume12/568.py: -------------------------------------------------------------------------------- 1 | from math import log 2 | 3 | def run(n): 4 | x = log(log(n)+0.57721566490153286060651209,10)-n*log(2,10) 5 | return int(pow(10, 7 + x-int(x))) 6 | 7 | print run(123456789) 8 | 9 | -------------------------------------------------------------------------------- /project-euler/volume12/573.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | double run(int n) { 4 | double res = 1.0, now = 1.0; 5 | for (int i = 2; i <= n; i++) { 6 | now = now * (n - i + 1) / n; 7 | res += now; 8 | } 9 | return res; 10 | } 11 | 12 | int main() { 13 | std::cout.precision(10); 14 | std::cout << run(3) << std::endl; 15 | std::cout << run(4) << std::endl; 16 | std::cout << run(5) << std::endl; 17 | std::cout << run(10) << std::endl; 18 | std::cout << run(1000000) << std::endl; 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /project-euler/volume12/577.m: -------------------------------------------------------------------------------- 1 | Total[CoefficientList[Series[1/((1-x)^5(1+x+x^2)^2), {x, 0, 12342}], x]] 2 | -------------------------------------------------------------------------------- /project-euler/volume12/582.m: -------------------------------------------------------------------------------- 1 | Sum[Length[Solve[3*a*a + 3*a*d + d*d == c*c && a > 0 && c > 0 && c <= 10^100 , {a, c}, Integers]], {d, 1, 100}] 2 | -------------------------------------------------------------------------------- /project-euler/volume12/599.py: -------------------------------------------------------------------------------- 1 | m = 88179840 2 | c = [0, 0, 19053144, 17404632, 3289734, 19675656, 13976640, 1591128, 6753434, 4262412, 261156, 1076040, 664825, 17640, 87500, 58800, 420, 3528, 3010, 0, 56, 84, 0, 0, 1] 3 | 4 | def calc(color): 5 | ret, p = 0, 1 6 | for x in c: 7 | ret += p * x 8 | p *= color 9 | return ret / m 10 | 11 | print calc(2) 12 | print calc(10) 13 | -------------------------------------------------------------------------------- /project-euler/volume13/601.py: -------------------------------------------------------------------------------- 1 | from fractions import * 2 | 3 | def lcm(n, m): 4 | return n * m / gcd(n, m); 5 | 6 | def P(s, N): 7 | N -= 1 8 | a = 1 9 | for i in xrange(2, s + 1): 10 | a = lcm(a, i) 11 | b = lcm(a, s + 1); 12 | return N / a - N / b 13 | 14 | ret = 0 15 | for i in xrange(1, 32): 16 | ret += P(i, 4 ** i) 17 | print ret - 1 18 | -------------------------------------------------------------------------------- /project-euler/volume13/613.m: -------------------------------------------------------------------------------- 1 | N[Integrate[3 * Pi / 2 - ArcTan[(30 - y) / x] - ArcTan[(40 - x) / y], {x, 0, 40}, {y, 0, 30 - 3 * x / 4}] / (Pi * 2 * 30 * 40 / 2), 10] 2 | -------------------------------------------------------------------------------- /rosecode/1.py: -------------------------------------------------------------------------------- 1 | n = 1000000 * 5 2 | mark = [True] * n 3 | p = [] 4 | for i in xrange(2, n): 5 | if mark[i]: 6 | p.append(i) 7 | for x in p: 8 | if x * i >= n: 9 | break 10 | mark[i * x] = False 11 | if i % x == 0: 12 | break 13 | print p[10000 - 1] 14 | print p[78200 - 1] 15 | -------------------------------------------------------------------------------- /rosecode/10.py: -------------------------------------------------------------------------------- 1 | from itertools import * 2 | 3 | ret = 0 4 | for p in permutations(range(6)): 5 | find = True 6 | for i in xrange(6): 7 | for j in xrange(i): 8 | if i + p[i] == j + p[j] or i - p[i] == j - p[j]: 9 | find = False 10 | ret += find 11 | print ret 12 | -------------------------------------------------------------------------------- /rosecode/2.py: -------------------------------------------------------------------------------- 1 | x, y = 1, 1 2 | while sum(map(int, list(str(x)))) <= 100: 3 | z = x + y 4 | x, y = z, x 5 | print x 6 | -------------------------------------------------------------------------------- /rosecode/3.py: -------------------------------------------------------------------------------- 1 | n = 1000000 2 | mark = [True] * n 3 | p = [] 4 | for i in xrange(2, n): 5 | if mark[i]: 6 | p.append(i) 7 | for x in p: 8 | if x * i >= n: 9 | break 10 | mark[i * x] = False 11 | if i % x == 0: 12 | break 13 | ret = 0 14 | for x in p: 15 | y = int(str(x)[::-1]) 16 | if x == y: 17 | ret += x 18 | print ret 19 | -------------------------------------------------------------------------------- /rosecode/392.py: -------------------------------------------------------------------------------- 1 | def C(n): 2 | if n <= 4: 3 | return 2 ** (n - 1) 4 | r, d = 8, 5 5 | for i in xrange(4, n): 6 | r += d 7 | d += 1 8 | return r 9 | 10 | for i in xrange(1, 20): 11 | print C(i) 12 | print C(10 ** 6) 13 | -------------------------------------------------------------------------------- /rosecode/396.py: -------------------------------------------------------------------------------- 1 | def G(n, k): 2 | if n <= 1: 3 | return n 4 | ret, t = 0, 0 5 | while n > 0: 6 | n, c = divmod(n, k) 7 | if c > 0: 8 | ret += c * (k + 1) ** G(t, k) 9 | t += 1 10 | return ret 11 | 12 | r = 13 13 | for i in xrange(2, 51): 14 | r = G(r, i) - 1 15 | print r 16 | -------------------------------------------------------------------------------- /rosecode/398.py: -------------------------------------------------------------------------------- 1 | p = [2L, 3L, 5L, 7L, 11L, 13L, 17L, 19L, 23L, 29L, 31L, 37L, 41L, 43L, 47L] 2 | ret, upp = 0, 10 ** 15 - 2 3 | 4 | def search(d, now): 5 | global ret 6 | if now > ret: 7 | print now 8 | ret = now 9 | if d < 0: return 10 | while now <= upp: 11 | search(d - 1, now) 12 | now *= p[d] 13 | 14 | search(len(p) - 1, 1) 15 | print ret 16 | -------------------------------------------------------------------------------- /rosecode/4.py: -------------------------------------------------------------------------------- 1 | n = 1000000 2 | mark = [True] * n 3 | p = [] 4 | for i in xrange(2, n): 5 | if mark[i]: 6 | p.append(i) 7 | for x in p: 8 | if x * i >= n: 9 | break 10 | mark[i * x] = False 11 | if i % x == 0: 12 | break 13 | dis, last = -1, -1 14 | for i in xrange(1, len(p)): 15 | if p[i] - p[i - 1] == 2: 16 | if last != -1: 17 | dis = max(dis, p[i] - last) 18 | last = p[i] 19 | print dis 20 | -------------------------------------------------------------------------------- /rosecode/428.py: -------------------------------------------------------------------------------- 1 | from fractions import * 2 | 3 | def run(n): 4 | fib = [1] * n 5 | for i in xrange(2, n): 6 | fib[i] = (fib[i - 1] + fib[i - 2]) % 5 7 | f = [x + 1 for x in fib] 8 | for i in xrange(1, n): 9 | f[i] += f[i - 1] 10 | s = [Fraction(x, f[-1] * 2) for x in f] 11 | t = [x / (1 - x) for x in s] 12 | r = 1 / t[0] 13 | for i in xrange(1, n): 14 | r += 1 / (t[i] - t[i - 1]) 15 | return r 16 | 17 | print run(3) 18 | print run(1919) 19 | -------------------------------------------------------------------------------- /rosecode/5.py: -------------------------------------------------------------------------------- 1 | n = 1000000 2 | mark = [True] * n 3 | p = [] 4 | for i in xrange(2, n): 5 | if mark[i]: 6 | p.append(i) 7 | for x in p: 8 | if x * i >= n: 9 | break 10 | mark[i * x] = False 11 | if i % x == 0: 12 | break 13 | 14 | ret = 0 15 | for x in p: 16 | if x >= 1000: break 17 | for y in p: 18 | if y == x: break 19 | a = int(str(x) + str(y)) 20 | b = int(str(y) + str(x)) 21 | if mark[a] and mark[b]: 22 | ret += 1 23 | print ret 24 | -------------------------------------------------------------------------------- /rosecode/6.py: -------------------------------------------------------------------------------- 1 | def to(n, b): 2 | d = [] 3 | while n: 4 | d.append(str(n % b)) 5 | n /= b 6 | d.reverse() 7 | return ''.join(d) 8 | 9 | ret = 0 10 | for i in xrange(1, 10000000): 11 | x = to(i, 4) 12 | y = to(i, 6) 13 | if x == x[::-1] and y == y[::-1]: 14 | ret += i 15 | print ret 16 | -------------------------------------------------------------------------------- /rosecode/60.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int cnt = 0, p = 1; 5 | for (int i = 1; i <= 1000000; ++i) { 6 | p = p * 3ll % 1000000000; 7 | static bool mark[10]; 8 | for (int x = 1; x <= 9; ++x) mark[x] = 0; 9 | for (int x = p; x; x /= 10) mark[x % 10] = 1; 10 | int s = 0; 11 | for (int x = 1; x <= 9; ++x) s += mark[x]; 12 | cnt += (s == 9) * i; 13 | } 14 | printf("%d\n", cnt); 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /rosecode/7.py: -------------------------------------------------------------------------------- 1 | def to(n, b): 2 | d = [] 3 | while n: 4 | d.append(str(n % b)) 5 | n /= b 6 | d.reverse() 7 | return ''.join(d) 8 | 9 | for i in xrange(1, 10000000): 10 | x = to(i, 8) 11 | y = to(int(str(i)[::-1]), 9) 12 | if x == y: 13 | print x 14 | -------------------------------------------------------------------------------- /rosecode/8.py: -------------------------------------------------------------------------------- 1 | from decimal import * 2 | getcontext().prec = 100 3 | Decimal(11) / Decimal(59) 4 | -------------------------------------------------------------------------------- /rosecode/9.py: -------------------------------------------------------------------------------- 1 | def check(n): 2 | s = [2, 3, 4, 7] 3 | while n: 4 | if not (n % 10) in s: return False 5 | n /= 10 6 | return True 7 | 8 | ret = 0 9 | for a in xrange(100, 1000): 10 | if not check(a): continue 11 | for b in [2, 3, 5, 7]: 12 | for c in [2, 3, 5, 7]: 13 | if not check(a * b) or not check(a * c): continue 14 | if check(a * (b * 10 + c)): 15 | ret += 1 16 | print ret 17 | -------------------------------------------------------------------------------- /russian-code-cup/2011/elimination-round/A.py: -------------------------------------------------------------------------------- 1 | n = 1000 2 | f = [0] * n 3 | for i in xrange(0, n - 1): 4 | f[i + 1] = (f[i] + 1) * 0.5 + (f[i] + 2 + i) * 0.5 5 | for it in xrange(int(raw_input())): 6 | print '%.10f' % f[int(raw_input()) - 1] 7 | -------------------------------------------------------------------------------- /russian-code-cup/2011/elimination-round/B.py: -------------------------------------------------------------------------------- 1 | n = int(raw_input()) 2 | a = [x - 1 - i for i, x in enumerate(map(int, raw_input().split()))] 3 | x, y = max(a), min(a) 4 | print x - y + min(x, -y) 5 | -------------------------------------------------------------------------------- /russian-code-cup/2011/qualification-round-2/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | const double pi = acos(-1.0); 6 | 7 | int main() { 8 | int n, r, s = 0; 9 | scanf("%d%d", &n, &r); 10 | std::vector a(n); 11 | for (int i = 0; i < n; ++i) { 12 | scanf("%d", &a[i]); 13 | s += a[i]; 14 | } 15 | for (int i = 0; i < n; ++i) { 16 | printf("%.10f\n", r * r * pi * a[i] / s); 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /russian-code-cup/2016/elimination-round/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, t, t0; 6 | scanf("%d%d%d", &n, &t, &t0); 7 | for (int i = 0; i < n; ++i) { 8 | int m; 9 | scanf("%d", &m); 10 | int mx = 0, ret = 0, sum = 0; 11 | for (int j = 1; j <= m; ++j) { 12 | int x; 13 | scanf("%d", &x); 14 | sum += x; 15 | mx = std::max(mx, x); 16 | if (sum <= t) ret = j; 17 | if (sum - mx + t0 <= t) ret = j; 18 | } 19 | printf("%d\n", ret); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /russian-code-cup/2016/warmup-round/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n; scanf("%d", &n); 6 | vector a(n); 7 | for (int i = 0; i < n; ++i) scanf("%d", &a[i]); 8 | sort(a.begin(), a.end(), greater()); 9 | printf("%d\n", (a[0] + a[1]) / 2); 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /russian-code-cup/2017/qualification-round-1/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int T; 6 | scanf("%d", &T); 7 | for (int cas = 1; cas <= T; ++cas) { 8 | int k, x, y; 9 | scanf("%d%d%d", &k, &x, &y); 10 | if (x > y) { 11 | int e = std::max(y + 2, k); 12 | printf("%d\n", e - x); 13 | } else { 14 | int e = std::max(x + 2, k); 15 | printf("%d\n", e - y); 16 | } 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /russian-code-cup/2017/qualification-round-2/B.py: -------------------------------------------------------------------------------- 1 | from fractions import * 2 | 3 | def lcm(a, b): return a * b / gcd(a, b) 4 | 5 | for it in xrange(int(raw_input())): 6 | a, b, c, d = map(int, raw_input().split()) 7 | x, y = lcm(a, c), gcd(b, d) 8 | g = gcd(x, y) 9 | print x / g, y / g 10 | -------------------------------------------------------------------------------- /russian-code-cup/2017/warmup-round/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n; 6 | scanf("%d", &n); 7 | std::vector a(n); 8 | long long sum = 0; 9 | for (int i = 0; i < n; ++i) { 10 | scanf("%d", &a[i]); 11 | sum += a[i]; 12 | } 13 | for (int i = 0; i < n; ++i) { 14 | if (sum - a[i] == a[i]) { 15 | for (int j = 0; j < n; ++j) { 16 | if (i != j) printf("%d ", a[j]); 17 | } 18 | printf("%d\n", a[i]); 19 | break; 20 | } 21 | } 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /sgu/100.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b; scanf("%d%d", &a, &b); 5 | printf("%d\n", a + b); 6 | return 0; 7 | } 8 | -------------------------------------------------------------------------------- /sgu/102.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int N, ret; 5 | scanf("%d", &N); ret = N; 6 | for (int i = 2; i * i <= N; ++ i) { 7 | if (N % i == 0) { 8 | ret = ret / i * (i - 1); 9 | while (N % i == 0) N /= i; 10 | } 11 | } 12 | if (N > 1) ret = ret / N * (N - 1); 13 | printf("%d\n", ret); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /sgu/105.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int N; scanf("%d", &N); 5 | if (N % 3 == 0) printf("%d\n", N / 3 * 2); 6 | else printf("%d\n", N / 3 * 2 + N % 3 - 1); 7 | return 0; 8 | } 9 | -------------------------------------------------------------------------------- /sgu/107.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int N; scanf("%d", &N); 5 | if (N <= 8) puts("0"); 6 | else if (N == 9) puts("8"); 7 | else { 8 | printf("%d", 72); N -= 10; 9 | for (int i = 0; i < N; ++ i) printf("0"); 10 | puts(""); 11 | } 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /sgu/111.py: -------------------------------------------------------------------------------- 1 | from math import sqrt 2 | 3 | def isqrt(s): 4 | d = len(s) 5 | n = int(s) 6 | if d % 2 == 0: 7 | x = 7 * 10 ** ((d - 2) // 2) 8 | else: 9 | x = 2 * 10 ** ((d - 1) // 2) 10 | x = (x + (n + x - 1) // x) >> 1 11 | while True: 12 | y = (x + (n + x - 1) // x) >> 1 13 | if y == x: 14 | break 15 | x = y 16 | if x * x > n: 17 | x -= 1 18 | return x 19 | 20 | print(isqrt(input())) 21 | -------------------------------------------------------------------------------- /sgu/112.py: -------------------------------------------------------------------------------- 1 | a, b = map(int, input().split()) 2 | print(a ** b - b ** a) 3 | -------------------------------------------------------------------------------- /sgu/113.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int T; scanf("%d", &T); 5 | while (T --) { 6 | int N; scanf("%d", &N); 7 | int cnt = 0; 8 | for (int i = 2; i * i <= N; ++ i) { 9 | while (N % i == 0) cnt ++, N /= i; 10 | } 11 | if (N > 1) cnt ++; 12 | if (cnt == 2) puts("Yes"); 13 | else puts("No"); 14 | } 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /sgu/117.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int pow_mod(int a, int n, int p) { 4 | int ret = 1; 5 | for (a %= p; n; n >>= 1) { 6 | if (n & 1) ret = ret * a % p; 7 | a = a * a % p; 8 | } 9 | return ret; 10 | } 11 | 12 | int main() { 13 | int ret = 0, N, M, K; 14 | scanf("%d%d%d", &N, &M, &K); 15 | for (int i = 0; i < N; ++ i) { 16 | int x; scanf("%d", &x); 17 | ret += (pow_mod(x, M, K) == 0); 18 | } 19 | printf("%d\n", ret); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /sgu/118.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int T; scanf("%d", &T); 5 | while (T --) { 6 | int N; scanf("%d", &N); 7 | int ret = 0, now = 1; 8 | for (int i = 0; i < N; ++ i) { 9 | int x; scanf("%d", &x); x %= 9; 10 | now = now * x % 9; 11 | ret = (ret + now) % 9; 12 | } 13 | if (ret == 0) ret = 9; 14 | printf("%d\n", ret); 15 | } 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /sgu/123.py: -------------------------------------------------------------------------------- 1 | fib = [1] * 41 2 | k = int(input()) 3 | for i in range(2, k): 4 | fib[i] = fib[i - 1] + fib[i - 2] 5 | print(sum(fib[:k])) 6 | -------------------------------------------------------------------------------- /sgu/126.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | 5 | int64 gcd(int64 a, int64 b) { 6 | return !b ? a : gcd(b, a % b); 7 | } 8 | 9 | int main() { 10 | int64 a, b; 11 | scanf("%lld%lld", &a, &b); 12 | int64 g = gcd(a, b); 13 | int64 c = (a + b) / g; 14 | if (c & (c - 1)) puts("-1"); 15 | else { 16 | printf("%d\n", __builtin_ctz(c)); 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /sgu/127.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int cnt[10] = {}; 5 | int n, k; 6 | scanf("%d%d", &k, &n); 7 | for (int i = 0; i < n; ++i) { 8 | int x; 9 | scanf("%d", &x); 10 | cnt[x / 1000]++; 11 | } 12 | int ret = 2; 13 | for (int i = 0; i < 10; ++i) if (cnt[i]) { 14 | ret += (cnt[i] + k - 1) / k; 15 | } 16 | printf("%d\n", ret); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /sgu/130.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int k; scanf("%d", &k); 5 | long long ret = 1; 6 | for (int i = 1; i <= k; ++ i) ret = ret * (i + k) / i; 7 | ret = ret / (k + 1); 8 | printf("%lld %d\n", ret, k + 1); 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /sgu/135.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | 5 | int main() { 6 | int n; 7 | scanf("%d", &n); 8 | int64 r = 1; 9 | for (int i = 1; i <= n; ++i) r += i; 10 | printf("%lld\n", r); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /sgu/139.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a[16]; 5 | int zero = 0, inv = 0; 6 | for (int i = 0; i < 16; ++i) { 7 | scanf("%d", &a[i]); 8 | if (a[i] == 0) zero = i; 9 | for (int j = 0; j < i; ++j) inv += a[j] > a[i]; 10 | } 11 | zero = 3 - zero / 4 + 3 - zero % 4; 12 | if ((inv ^ (15 - zero) ^ 1) & 1) puts("YES"); 13 | else puts("NO"); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /sgu/154.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | 5 | int main() { 6 | auto count = [](int64 n) { 7 | int64 ret = 0; 8 | for (int64 p = 5; p <= n; p *= 5) ret += n / p; 9 | return ret; 10 | }; 11 | int q; 12 | scanf("%d", &q); 13 | int l = 1, r = q * 5; 14 | while (l < r) { 15 | int m = (l + r - 1) >> 1; 16 | if (count(m) >= q) r = m; 17 | else l = m + 1; 18 | } 19 | if (count(l) == q) printf("%d\n", l); 20 | else puts("No solution"); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /sgu/162.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | double a, b, c, d, e, f; 6 | scanf("%lf%lf%lf%lf%lf%lf", &a, &b, &c, &f, &e, &d); 7 | a = a * a; 8 | b = b * b; 9 | c = c * c; 10 | d = d * d; 11 | e = e * e; 12 | f = f * f; 13 | printf("%.4f\n", sqrt(a * d * (b + c + e + f - a - d) + b * e * (a + c + d + f - b - e) + c * f * (a + b + d + e - c - f) - a * b * f - b * c * d - c * a * e - d * e * f) / 12); 14 | return 0; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sgu/169.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | if (n == 1) puts("8"); 7 | else if ((n - 1) % 6 == 0) puts("4"); 8 | else if ((n - 1) % 3 == 0) puts("3"); 9 | else puts("1"); 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /sgu/175.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int phi(int n, int q) { 4 | if (n == 1) return 1; 5 | int m = n / 2; 6 | if (q <= m) return n - m + phi(m, m + 1 - q); 7 | else return phi(n - m, n + 1 - q); 8 | } 9 | 10 | int main() { 11 | int n, q; 12 | scanf("%d%d", &n, &q); 13 | printf("%d\n", phi(n, q)); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /sgu/178.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | long long n, x = 0; 5 | scanf("%lld", &n); 6 | while ((1ll << (x + 1)) * (x + 1) <= n) ++x; 7 | printf("%lld\n", x); 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /sgu/184.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int p, m, c, k, r, v; 6 | scanf("%d%d%d%d%d%d", &p, &m, &c, &k, &r, &v); 7 | printf("%d\n", std::min(p / k, std::min(m / r, c / v))); 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /sgu/186.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | int n; 7 | scanf("%d", &n); 8 | std::vector a(n); 9 | for (int i = 0; i < n; ++i) { 10 | scanf("%d", &a[i]); 11 | } 12 | std::sort(a.begin(), a.end()); 13 | int ret = 0; 14 | for (int i = 0, j = n - 1; i < j; ) { 15 | if (--a[i] == 0) ++i; 16 | --j; 17 | ++ret; 18 | } 19 | printf("%d\n", ret); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /sgu/193.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | if n & 1 == 1: 3 | print(n >> 1) 4 | elif n & 3 == 0: 5 | print((n >> 1) - 1) 6 | else: 7 | print((n >> 1) - 2) 8 | -------------------------------------------------------------------------------- /sgu/196.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, m; 6 | scanf("%d%d", &n, &m); 7 | std::vector d(n); 8 | for (int i = 0; i < m; ++i) { 9 | int u, v; 10 | scanf("%d%d", &u, &v); 11 | d[--u]++; 12 | d[--v]++; 13 | } 14 | long long ret = 0; 15 | for (auto &&u: d) ret += 1ll * u * u; 16 | printf("%lld\n", ret); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /sgu/551.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | void run() { 5 | int n, t1, t2; cin >> n >> t1 >> t2; 6 | int l = 0, r = n * max(t1, t2); 7 | while (l < r) { 8 | int m = (l + r - 1) >> 1; 9 | if (m / t1 + m / t2 >= n) r = m; 10 | else l = m + 1; 11 | } 12 | int m = l / t1 + (l % t1 != 0) + l / t2 + (l % t2 != 0); 13 | int f = max(t1 * (l / t1 + (l % t1 != 0)), t2 * (l / t2 + (l % t2 != 0))); 14 | cout << m << " " << f << endl; 15 | } 16 | 17 | int main() { 18 | run(); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /snarknews-winter-series/2020/round1/F.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | int n, m; 7 | scanf("%d%d", &n, &m); 8 | std::vector f(m + 1); 9 | double mx = 0; 10 | for (int i = 1; i <= m; ++i) { 11 | for (int j = 1; j <= n; ++j) { 12 | f[i] += std::max(j, f[i - 1]); 13 | } 14 | f[i] /= n; 15 | mx = std::max(mx, f[i]); 16 | } 17 | printf("%.10f\n", mx); 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /snarknews-winter-series/2020/round3/D.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n; 6 | scanf("%d", &n); 7 | std::vector a; 8 | for (int i = 0, x; i < n; ++i) { 9 | scanf("%d", &x); 10 | while (!a.empty() && x >= a.back()) a.pop_back(); 11 | a.push_back(x); 12 | printf("%d\n", (int)a.size()); 13 | } 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /spoj/ADACHES2.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | const int N = 1e7 + 1, mod = 1e9 + 7; 5 | 6 | int64 a[N]; 7 | 8 | int main() { 9 | a[0] = a[1] = 1; 10 | for (int n = 4; n < N; ++n) { 11 | a[n] = ((n + 1) * a[n - 1] - (n - 2) * a[n - 2] - (n - 5) * a[n - 3] + (n - 3) * a[n - 4]) % mod; 12 | if (a[n] < 0) a[n] += mod; 13 | } 14 | int T; 15 | scanf("%d", &T); 16 | for (int cas = 1; cas <= T; ++cas) { 17 | int n; 18 | scanf("%d", &n); 19 | printf("%lld\n", a[n]); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /spoj/ADAM1.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | 5 | int main() { 6 | int T; 7 | scanf("%d", &T); 8 | for (int cas = 1; cas <= T; ++cas) { 9 | int p, q, c; 10 | scanf("%d%d%d", &p, &q, &c); 11 | int n; 12 | scanf("%d", &n); 13 | int ret = 0; 14 | for (int i = 0; i < n; ++i) { 15 | int x, y; 16 | scanf("%d%d", &x, &y); 17 | if ((int64)x * x + (int64)y * y - (int64)x * p - (int64)y * q + c <= 0) ++ret; 18 | } 19 | printf("%d\n", ret); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /spoj/ADARAIN.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, m, w; 6 | scanf("%d%d%d", &n, &m, &w); 7 | std::vector s(w + 1); 8 | for (int i = 0, x, y; i < n; ++i) { 9 | scanf("%d%d", &x, &y); 10 | s[x] += 1; s[y + 1] -= 1; 11 | } 12 | for (int i = 1; i <= w; ++i) s[i] += s[i - 1]; 13 | for (int i = 0, x; i < m; ++i) { 14 | scanf("%d", &x); 15 | printf("%d\n", s[x]); 16 | } 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /spoj/ADAUSORT.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | int n; 7 | scanf("%d", &n); 8 | std::vector a(n), id(n); 9 | for (int i = 0; i < n; ++i) { 10 | scanf("%d", &a[i]); 11 | id[i] = i; 12 | } 13 | std::sort(id.begin(), id.end(), [&](int x, int y) { 14 | return a[x] < a[y] || (a[x] == a[y] && x > y); 15 | }); 16 | for (int i = 0; i < n; ++i) { 17 | if (i) putchar(' '); 18 | printf("%d", id[i] + 1); 19 | } 20 | puts(""); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /spoj/AGPREFX.py: -------------------------------------------------------------------------------- 1 | s = raw_input() 2 | p = int(raw_input()) 3 | m = raw_input() 4 | print m[:p] + "LUISS" + m[p + len(s):] 5 | -------------------------------------------------------------------------------- /spoj/ARCTAN.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int T; scanf("%d", &T); 5 | while (T--) { 6 | long long A ,n, m; scanf("%lld", &A); 7 | for (m=A; m>=1; m--) { 8 | if ((A*A+1)%m==0) break; 9 | } 10 | n=(A*A+1)/m; 11 | printf("%lld\n", A*2+n+m); 12 | } 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /spoj/DOUGHNUT.cc: -------------------------------------------------------------------------------- 1 | #include 2 | int main() { 3 | int t, c, k, w; 4 | scanf("%d", &t); 5 | while(t--) { 6 | scanf("%d %d %d", &c, &k, &w); 7 | if(c*w <= k) 8 | printf("yes\n"); 9 | else 10 | printf("no\n"); 11 | } 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /spoj/ESYR.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | const std::set sp = { 6 | "987654312678", 7 | "987898765678", 8 | "987896545674", 9 | "456789234576", 10 | "987896512307", 11 | "987654888999", 12 | "999999993425"}; 13 | 14 | int main() { 15 | int T; 16 | scanf("%d", &T); 17 | for (int cas = 1; cas <= T; ++cas) { 18 | static char s[1000]; 19 | scanf("%s", s); 20 | if (sp.count(s)) puts("Special Number"); 21 | else puts("Just a number"); 22 | } 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /spoj/FACEFRND.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const int SIZE=10000; 5 | const int MAXN=105; 6 | 7 | bool C[SIZE]; 8 | int F[MAXN]; 9 | int N, M; 10 | 11 | int main() 12 | { 13 | memset(C, 0, sizeof(C)); 14 | scanf("%d", &N); 15 | for (int i=1; i<=N; i++) 16 | { 17 | scanf("%d%d", &F[i], &M); 18 | for (int x, j=1; j<=M; j++) 19 | { 20 | scanf("%d", &x); 21 | C[x]=true; 22 | } 23 | } 24 | for (int i=1; i<=N; i++) C[F[i]]=false; 25 | int ret=0; 26 | for (int i=0; i> 1, mod) 12 | return (a * b + a * (b - a + mod)) % mod, (a * a + b * b) % mod; 13 | 14 | 15 | for _ in xrange(input()): 16 | n = input() % p2 17 | m = fib(n, p1)[0] 18 | print fib(m, mod)[0] 19 | -------------------------------------------------------------------------------- /spoj/GCD2.py: -------------------------------------------------------------------------------- 1 | from fractions import gcd 2 | for _ in range(int(input())): 3 | a, b = map(int, input().split()) 4 | print(gcd(a, b)) 5 | -------------------------------------------------------------------------------- /spoj/JGTLE.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | 5 | int main() { 6 | int T; 7 | scanf("%d", &T); 8 | for (int cas = 1; cas <= T; ++cas) { 9 | int64 a, b, c; 10 | scanf("%lld%lld%lld", &a, &b, &c); 11 | printf("Case %d: %lld\n", cas, a * (b * (b + 1) / 2) * (c * (c + 1) / 2)); 12 | } 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /spoj/MOHIB.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int T; scanf("%d", &T); 6 | for (int _ = 0; _ < T; ++ _) { 7 | int x, avg; scanf("%d%d", &x, &avg); 8 | int n = avg - x + 1; 9 | int sum = n * avg - x; 10 | if (n <= 2) printf("%d\n", sum); 11 | else printf("%d\n", sum - (n - 2) * (n - 1) / 2); 12 | } 13 | return 0; 14 | } 15 | 16 | 17 | -------------------------------------------------------------------------------- /spoj/OPMODULO.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | 5 | int main() { 6 | int64 l, r; 7 | scanf("%lld%lld", &l, &r); 8 | int64 s = 1; 9 | int64 ret = 0; 10 | for (; s <= r; s *= 2) ret += (s >= l) * s; 11 | printf("%lld\n", ret); 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /spoj/PBBN2.py: -------------------------------------------------------------------------------- 1 | base = 2 ** 16384 2 | for _ in range(int(input())): 3 | a, b, c, d = list(map(int, input().split())) 4 | n = (a ** b) ^ (c ** d) 5 | r = 0 6 | while n: 7 | r += n % base 8 | n //= base 9 | print(r) 10 | -------------------------------------------------------------------------------- /spoj/SNIM.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int T; 6 | scanf("%d", &T); 7 | for (int cas = 1; cas <= T; ++cas) { 8 | int n; 9 | scanf("%d", &n); 10 | std::vector a(n); 11 | for (int i = 0; i < n; ++i) { 12 | scanf("%d", &a[i]); 13 | } 14 | int ret = 0; 15 | for (int i = n - 1; i >= 0; i -= 2) { 16 | ret ^= a[i] - a[i - 1]; 17 | } 18 | if (ret) puts("TAK"); 19 | else puts("NIE"); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /spoj/SOLVEIT.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, q; 6 | scanf("%d%d", &n, &q); 7 | std::set s; 8 | for (int i = 0; i < q; ++i) { 9 | int op, x; 10 | scanf("%d%d", &op, &x); 11 | if (op == 1) { 12 | s.insert(x); 13 | } else { 14 | auto it = s.lower_bound(x); 15 | if (it == s.end()) puts("-1"); 16 | else printf("%d\n", *it); 17 | } 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /spoj/SUMMATION.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const int mod = 1e8 + 7; 4 | 5 | int main() { 6 | int T; 7 | scanf("%d", &T); 8 | for (int cas = 1; cas <= T; ++cas) { 9 | int n; 10 | scanf("%d", &n); 11 | int ret = 0, p = 1; 12 | for (int i = 1; i < n; ++i) { 13 | p = p * 2 % mod; 14 | } 15 | for (int i = 0; i < n; ++i) { 16 | int x; 17 | scanf("%d", &x); 18 | ret = (ret + x) % mod; 19 | } 20 | printf("Case %d: %lld\n", cas, 1ll * ret * p % mod); 21 | } 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /spoj/TANDC.py: -------------------------------------------------------------------------------- 1 | mod = 10 ** 9 + 7 2 | for i in range(int(input())): 3 | m, r = map(int, input().split()) 4 | print(((pow(m, r, mod * (m - 1)) - 1 + mod * (m - 1)) % (mod * (m - 1)) // (m - 1) + mod - r) % mod) 5 | -------------------------------------------------------------------------------- /spoj/TEST.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int a; 8 | while ((cin >> a)&&(a != 42)) 9 | cout << a << endl; 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /spoj/THFANDM.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using int64 = long long; 6 | 7 | int64 x, t, p, q, v; 8 | 9 | int main() { 10 | int T; 11 | scanf("%d", &T); 12 | for (int cas = 1; cas <= T; ++cas) { 13 | assert(scanf("%lld%lld%lld%lld%lld", &x, &p, &q, &t, &v) == 5); 14 | assert(x - q <= p && p <= x + q); 15 | int64 s = p + v * t - q; 16 | printf("%lld\n", std::max(s - x, 0)); 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /spoj/WPC5A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | 5 | int main() { 6 | int T; 7 | scanf("%d", &T); 8 | for (int cas = 1; cas <= T; ++cas) { 9 | int64 n, ret = 1; 10 | scanf("%lld", &n); 11 | for (int64 i = 2; i * i <= n; ++i) if (n % i == 0) { 12 | int c = 0; 13 | while (n % i == 0) c += 2, n /= i; 14 | ret *= c + 1; 15 | } 16 | if (n > 1) ret *= 3; 17 | printf("%lld\n", ret / 2); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /topcoder/2020 Humblefool Prelim/CardDrawPoints.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 2 3 | 0 4 | 0 5 | 6 | 0.0 7 | -- Example 1 8 | 2 9 | 1 10 | 1 11 | 12 | 1.0 13 | -- Example 2 14 | 3 15 | 1 16 | 1 17 | 1 18 | 19 | 3.0 20 | -- Example 3 21 | 2 22 | 1 23 | 3 24 | 25 | 1.0 26 | -- Example 4 27 | 6 28 | 0 29 | 4 30 | 0 31 | 0 32 | 0 33 | 1 34 | 35 | 2.4000000000000004 36 | -- Example 5 37 | 6 38 | 0 39 | 7 40 | 0 41 | 0 42 | 0 43 | 1 44 | 45 | 1.625 46 | -- Example 6 47 | 4 48 | 2 49 | 2 50 | 2 51 | 2 52 | 53 | 2.857142857142857 54 | -------------------------------------------------------------------------------- /topcoder/2020 Humblefool Prelim/NonSimilarTriangles.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 3 3 | 3 4 | 4 5 | 5 6 | 7 | 1 8 | -- Example 1 9 | 6 10 | 1 11 | 1 12 | 1 13 | 1 14 | 1 15 | 1 16 | 17 | 1 18 | -- Example 2 19 | 6 20 | 2 21 | 2 22 | 2 23 | 3 24 | 3 25 | 3 26 | 27 | 3 28 | -- Example 3 29 | 6 30 | 1 31 | 2 32 | 4 33 | 8 34 | 16 35 | 24 36 | 37 | 0 38 | -- Example 4 39 | 14 40 | 10 41 | 3 42 | 10 43 | 4 44 | 10 45 | 5 46 | 10 47 | 6 48 | 10 49 | 7 50 | 10 51 | 8 52 | 10 53 | 9 54 | 55 | 50 56 | -- Example 5 57 | 3 58 | 5 59 | 5 60 | 10 61 | 62 | 0 63 | -------------------------------------------------------------------------------- /topcoder/2020 Humblefool Prelim/ScoringJudges.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 6 3 | 60 4 | 30 5 | 20 6 | 40 7 | 10 8 | 50 9 | 10 | 105.0 11 | -- Example 1 12 | 7 13 | 47 14 | 47 15 | 47 16 | 47 17 | 47 18 | 47 19 | 47 20 | 21 | 141.0 22 | -- Example 2 23 | 8 24 | 1 25 | 1 26 | 1 27 | 3 28 | 3 29 | 4 30 | 4 31 | 4 32 | 33 | 7.75 34 | -------------------------------------------------------------------------------- /topcoder/Greed-2.0-RC-7.1.0.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zimpha/competitive-programming/147cb2be02917d12fdbe488c084567c9d0a7d76c/topcoder/Greed-2.0-RC-7.1.0.jar -------------------------------------------------------------------------------- /topcoder/SRM 452/IOIString.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 1 3 | IO? 4 | 5 | 1 6 | -- Example 1 7 | 1 8 | ???? 9 | 10 | 4 11 | -- Example 2 12 | 1 13 | ?II 14 | 15 | 0 16 | -- Example 3 17 | 1 18 | I??O??I 19 | 20 | 16 21 | -- Example 4 22 | 2 23 | ???I???????O??? 24 | ???????????O??IO????????I??? 25 | 26 | 438952513 27 | -------------------------------------------------------------------------------- /topcoder/SRM 452/IncreasingNumber.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 2 3 | 12 4 | 5 | 4 6 | -- Example 1 7 | 3 8 | 111 9 | 10 | 9 11 | -- Example 2 12 | 452 13 | 10 14 | 15 | 0 16 | -- Example 3 17 | 6 18 | 58 19 | 20 | 38 21 | -------------------------------------------------------------------------------- /topcoder/SRM 452/NotTwo.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 3 3 | 2 4 | 5 | 4 6 | -- Example 1 7 | 3 8 | 3 9 | 10 | 5 11 | -- Example 2 12 | 8 13 | 5 14 | 15 | 20 16 | -------------------------------------------------------------------------------- /topcoder/SRM 774/LandSplitter.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 12 3 | 3 4 | 3 5 | 6 | 54 7 | -- Example 1 8 | 10 9 | 3 10 | 4 11 | 12 | 33 13 | -- Example 2 14 | 47 15 | 1 16 | 47 17 | 18 | 0 19 | -- Example 3 20 | 70 21 | 40 22 | 50 23 | 24 | -1 25 | -- Example 4 26 | 47 27 | 4 28 | 7 29 | 30 | 945 31 | -------------------------------------------------------------------------------- /topcoder/SRM 775/FairSplit.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 7 3 | 7 4 | 1 5 | 15 6 | 7 | 3 8 | -- Example 1 9 | 101 10 | 200 11 | 1 12 | 100 13 | 14 | 0 15 | -- Example 2 16 | 1 17 | 4 18 | 5 19 | 10 20 | 21 | 11 22 | -- Example 3 23 | 4 24 | 17 25 | 12 26 | 33 27 | 28 | 129 29 | -- Example 4 30 | 465 31 | 585 32 | 264 33 | 352 34 | 35 | 0 -------------------------------------------------------------------------------- /topcoder/SRM 775/IterateOverACube.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 3 3 | 9 4 | 5 | 3 6 | 2 7 | 0 8 | 0 9 | -- Example 1 10 | 3 11 | 10 12 | 13 | 3 14 | 0 15 | 1 16 | 2 17 | -- Example 2 18 | 4747 19 | 106968940722 20 | 21 | 3 22 | 4746 23 | 4746 24 | 4746 25 | -- Example 3 26 | 4 27 | 32 28 | 29 | 3 30 | 0 31 | 2 32 | 3 33 | -------------------------------------------------------------------------------- /topcoder/SRM 778/CollectingCoins.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 5 3 | 3 4 | 1 5 | 1 6 | 1 7 | 3 8 | 9 | 4 10 | -- Example 1 11 | 5 12 | 4 13 | 2 14 | 1 15 | 2 16 | 2 17 | 2 18 | 3 19 | 20 | 10 21 | -- Example 2 22 | 10 23 | 17 24 | 2 25 | 10 26 | 20 27 | 2 28 | 30 29 | 40 30 | 31 | 300 32 | -------------------------------------------------------------------------------- /topcoder/SRM 778/DominoPlacement.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 1 3 | .. 4 | 5 | 2 6 | -- Example 1 7 | 2 8 | .# 9 | .. 10 | 11 | 3 12 | -- Example 2 13 | 3 14 | .#. 15 | #.. 16 | ... 17 | 18 | 20 19 | -- Example 3 20 | 5 21 | #######.##### 22 | ...#....#.... 23 | ...#....#.... 24 | ...#....#.... 25 | ...#....##### 26 | 27 | 426089093 28 | -------------------------------------------------------------------------------- /topcoder/SRM 779/ArraySorting.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 2 3 | 10 4 | 8 5 | 6 | 2 7 | 1 8 | 8 9 | -- Example 1 10 | 2 11 | 6 12 | 9 13 | 14 | 2 15 | 6 16 | 9 17 | -- Example 2 18 | 4 19 | 9 20 | 8 21 | 10 22 | 4 23 | 24 | 4 25 | 1 26 | 8 27 | 10 28 | 10 29 | -- Example 3 30 | 5 31 | 3 32 | 7 33 | 7 34 | 7 35 | 6 36 | 37 | 5 38 | 3 39 | 7 40 | 7 41 | 7 42 | 7 43 | -------------------------------------------------------------------------------- /topcoder/SRM 779/ParadePlanner.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 10 3 | 47 4 | 0 5 | 10 6 | 0 7 | 1 8 | 1 9 | 7 10 | 2 11 | 7 12 | 3 13 | 4 14 | 2 15 | 3 16 | 17 | 2 18 | -- Example 1 19 | 4 20 | 47 21 | 2147483647 22 | 0 23 | 24 | 72 25 | -- Example 2 26 | 6 27 | 4747 28 | 0 29 | 12 30 | 0 31 | 1 32 | 1 33 | 2 34 | 2 35 | 3 36 | 3 37 | 4 38 | 4 39 | 5 40 | 0 41 | 5 42 | 43 | 12 44 | -- Example 3 45 | 7 46 | 47 47 | 1000000000 48 | 8 49 | 0 50 | 1 51 | 0 52 | 1 53 | 0 54 | 2 55 | 0 56 | 3 57 | 58 | 46 59 | -- Example 4 60 | 2 61 | 40007 62 | 1234567890 63 | 0 64 | 65 | 0 66 | -------------------------------------------------------------------------------- /topcoder/SRM 779/SubstringQueries.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | aaaaaaaaa 3 | 1 4 | 5 | 0 6 | -- Example 1 7 | zaba 8 | 2 9 | 10 | 7 11 | -- Example 2 12 | acaa 13 | 2 14 | 15 | 10 16 | -- Example 3 17 | aa 18 | 4 19 | 20 | 0 21 | -------------------------------------------------------------------------------- /topcoder/SRM 780/BeatTheStar.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 2 3 | 1 4 | 5 | 0.0 6 | -- Example 1 7 | 5 8 | 5 9 | 10 | 0.625 11 | -- Example 2 12 | 5 13 | 1 14 | 15 | 0.125 16 | -- Example 3 17 | 5 18 | 2 19 | 20 | 0.125 21 | -- Example 4 22 | 9 23 | 7 24 | 25 | 0.328125 26 | -------------------------------------------------------------------------------- /topcoder/SRM 780/RestrictedLeaves.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 5 3 | -1 4 | 0 5 | 0 6 | 0 7 | 0 8 | 9 | 8 10 | -- Example 1 11 | 7 12 | -1 13 | 0 14 | 0 15 | 1 16 | 2 17 | 1 18 | 2 19 | 20 | 21 21 | -- Example 2 22 | 10 23 | -1 24 | 0 25 | 0 26 | 1 27 | 2 28 | 1 29 | 2 30 | 1 31 | 4 32 | 4 33 | 34 | 75 35 | -------------------------------------------------------------------------------- /topcoder/SRM 781/EpicPartition.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 1 3 | 4 | 5 | -- Example 1 6 | 2 7 | 8 | 9 | -- Example 2 10 | 4 11 | 12 | aaabababbbbabbcccccccaac 13 | -- Example 3 14 | 8 15 | 16 | abaaaaaabaabbaabbbbbbbbbbbbccccccccaaccccccacaac 17 | -------------------------------------------------------------------------------- /topcoder/SRM 781/RandomPartition.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 2 3 | 1 4 | 2 5 | 1 6 | 14 7 | 13 8 | 13 9 | 10 | 1 11 | -- Example 1 12 | 8 13 | 17 14 | 29 15 | 1 16 | 2 17 | 1 18 | 10 19 | 9 20 | 1729 21 | 8 22 | 9271 23 | 9 24 | 10 25 | 26 | 593461 27 | -- Example 2 28 | 4 29 | 1 30 | 7 31 | 2 32 | 9 33 | 10 34 | 1729 35 | 17 36 | 29 37 | 38 | 315441 39 | -------------------------------------------------------------------------------- /topcoder/SRM 781/RoseDressGame.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 3 3 | 1 4 | 47 5 | 7 6 | 7 | Coco 8 | -- Example 1 9 | 2 10 | 2 11 | 3 12 | 13 | Yves 14 | -- Example 2 15 | 3 16 | 12 17 | 20 18 | 24 19 | 20 | Yves 21 | -------------------------------------------------------------------------------- /topcoder/SRM 782/PaintItBlack.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 2 3 | 0 4 | 1 5 | 0 6 | 1 7 | 1 8 | 9 | 3 10 | 0 11 | 1 12 | 0 13 | -- Example 1 14 | 3 15 | 0 16 | 2 17 | 0 18 | 1 19 | 2 20 | 1 21 | 2 22 | 23 | 0 24 | -- Example 2 25 | 4 26 | 2 27 | 4 28 | 0 29 | 1 30 | 2 31 | 3 32 | 4 33 | 1 34 | 2 35 | 3 36 | 0 37 | 38 | 5 39 | 2 40 | 3 41 | 0 42 | 1 43 | 2 44 | -------------------------------------------------------------------------------- /topcoder/TCO 2017 Round 1B/CoinConstruction.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 6 3 | 4 | 3 5 | 3 6 | 4 7 | 7 8 | -- Example 1 9 | 26 10 | 11 | 6 12 | 1 13 | 1 14 | 10 15 | 10 16 | 100 17 | 100 18 | -- Example 2 19 | 7 20 | 21 | 7 22 | 1 23 | 1 24 | 1 25 | 1 26 | 1 27 | 1 28 | 1 29 | -- Example 3 30 | 1 31 | 32 | 1 33 | 999999999 34 | -------------------------------------------------------------------------------- /topcoder/TCO 2017 Round 1B/WaterAndOxygen.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 64 3 | 70 4 | 3 5 | 7 6 | 7 | 12.0 8 | -- Example 1 9 | 99 10 | 102 11 | 1 12 | 1 13 | 14 | 99.0 15 | -- Example 2 16 | 101 17 | 99 18 | 1 19 | 1 20 | 21 | 99.66666666666667 22 | -- Example 3 23 | 123456789 24 | 987654321 25 | 123 26 | 456 27 | 28 | 1003713.731707317 29 | -- Example 4 30 | 987654321 31 | 123456789 32 | 456 33 | 123 34 | 35 | 1758643.7307692308 36 | -- Example 5 37 | 0 38 | 0 39 | 13 40 | 27 41 | 42 | 0.0 43 | -------------------------------------------------------------------------------- /topcoder/TCO 2017 Round 1C/EllysRPS.html: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zimpha/competitive-programming/147cb2be02917d12fdbe488c084567c9d0a7d76c/topcoder/TCO 2017 Round 1C/EllysRPS.html -------------------------------------------------------------------------------- /topcoder/TCO 2017 Round 2A/FoxAndCake2.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 74 3 | 109 4 | 5 | Possible 6 | -- Example 1 7 | 1000000000 8 | 1000000000 9 | 10 | Possible 11 | -- Example 2 12 | 1 13 | 58 14 | 15 | Impossible 16 | -------------------------------------------------------------------------------- /topcoder/TCO 2017 Round 2B/DengklekGaneshAndChains.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 4 3 | topc 4 | oder 5 | open 6 | twob 7 | 3 8 | 2 9 | 1 10 | 3 11 | 12 | wotrod 13 | -- Example 1 14 | 4 15 | ssh 16 | she 17 | see 18 | sea 19 | 4 20 | 2 21 | 3 22 | 2 23 | 3 24 | 25 | ssshesesee 26 | -- Example 2 27 | 5 28 | wri 29 | ter 30 | who 31 | are 32 | you 33 | 1 34 | 3 35 | 36 | you 37 | -- Example 3 38 | 2 39 | harus 40 | imfyo 41 | 2 42 | 5 43 | 5 44 | 45 | yoimfushar 46 | -------------------------------------------------------------------------------- /topcoder/TCO 2017 Round 2B/DengklekGaneshAndDetention.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 3 3 | 0 4 | 1 5 | 25 6 | 100 7 | 8 | 1.375 9 | -- Example 1 10 | 3 11 | 20 12 | 2 13 | 10 14 | 57 15 | 16 | 1.06 17 | -- Example 2 18 | 8 19 | 10 20 | 3 21 | 10 22 | 29 23 | 24 | 7.8002283556316 25 | -- Example 3 26 | 820968 27 | 776629771 28 | 777021349 29 | 200921492 30 | 999997457 31 | 32 | 8.428130292928278E10 33 | -------------------------------------------------------------------------------- /topcoder/TCO 2018 Round 1A/Deadfish.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 3 3 | 4 | 3 5 | -- Example 1 6 | 5 7 | 8 | 4 9 | -- Example 2 10 | 15 11 | 12 | 5 13 | -- Example 3 14 | 61 15 | 16 | 5 17 | -- Example 4 18 | 200000 19 | 20 | 207 21 | -------------------------------------------------------------------------------- /topcoder/TCO 2018 Round 1A/RedDragonInn.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 3 3 | 2 4 | 5 | 17 6 | -- Example 1 7 | 8 8 | 13 9 | 10 | 223 11 | -- Example 2 12 | 42 13 | 1234 14 | 15 | 103739 16 | -------------------------------------------------------------------------------- /topcoder/TCO 2019 Round 1A/EllysAndXor.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 3 3 | 42 4 | 27 5 | 38 6 | 7 | 44 8 | -- Example 1 9 | 8 10 | 666 11 | 133 12 | 438 13 | 123 14 | 893 15 | 674 16 | 462 17 | 209 18 | 19 | 976 20 | -- Example 2 21 | 1 22 | 42 23 | 24 | 42 25 | -- Example 3 26 | 6 27 | 123 28 | 456 29 | 789 30 | 987 31 | 654 32 | 321 33 | 34 | 975 35 | -- Example 4 36 | 10 37 | 42 38 | 13 39 | 17 40 | 666 41 | 811 42 | 314 43 | 1 44 | 5 45 | 2 46 | 1000 47 | 48 | 1007 49 | -------------------------------------------------------------------------------- /topcoder/TCO 2019 Round 2A/Byes.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 3 3 | 1 4 | 5 | 3 6 | -- Example 1 7 | 4 8 | 1 9 | 10 | 6 11 | -- Example 2 12 | 1234567890123 13 | 0 14 | 15 | 2199023255552 16 | -- Example 3 17 | 200 18 | 4 19 | 20 | 202 21 | -- Example 4 22 | 1 23 | 1 24 | 25 | 3 -------------------------------------------------------------------------------- /topcoder/TCO 2019 Round 2A/RulerMaker.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 3 3 | 4 | 3 5 | 47 6 | 50 7 | 49 8 | -- Example 1 9 | 7 10 | 11 | 7 12 | 38 13 | 26 14 | 35 15 | 47 16 | 31 17 | 39 18 | 37 19 | -------------------------------------------------------------------------------- /topcoder/TCO 2019 Round 2A/YetAnotherTokenGame.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 1 3 | 47 4 | 5 | William 6 | -- Example 1 7 | 5 8 | 1 9 | 1 10 | 1 11 | 1 12 | 1 13 | 14 | William 15 | -- Example 2 16 | 4 17 | 3 18 | 1 19 | 1 20 | 1 21 | 22 | William 23 | -- Example 3 24 | 6 25 | 3 26 | 42 27 | 47 28 | 3 29 | 42 30 | 47 31 | 32 | Xenia 33 | -- Example 4 34 | 6 35 | 300 36 | 42 37 | 47 38 | 3 39 | 42 40 | 47 41 | 42 | William 43 | -- Example 5 44 | 3 45 | 1 46 | 3 47 | 5 48 | 49 | Xenia 50 | -------------------------------------------------------------------------------- /topcoder/TCO17 Beijing/Ellys8Bit.sample: -------------------------------------------------------------------------------- 1 | -- Example 0 2 | 1 3 | 4 | 255 5 | -- Example 1 6 | 2 7 | 8 | 383 9 | -- Example 2 10 | 3 11 | 12 | 447 13 | -- Example 3 14 | 1000 15 | 16 | 7032 17 | -- Example 4 18 | 133742 19 | 20 | 1087088 21 | -- Example 5 22 | 537655880 23 | 24 | 1125899983585796 25 | -------------------------------------------------------------------------------- /topcoder/TCO17 Beijing/EllysPrimePals.html: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zimpha/competitive-programming/147cb2be02917d12fdbe488c084567c9d0a7d76c/topcoder/TCO17 Beijing/EllysPrimePals.html -------------------------------------------------------------------------------- /yandex-algorithm/2017/round1/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using ll = long long; 4 | 5 | int main() { 6 | ll n, a; 7 | scanf("%lld%lld", &n, &a); 8 | ll s = n % 500; 9 | ll ret = 0; 10 | for (int i = 0; i < 500; ++i) { 11 | ll x = a + i, y = n - x; 12 | if (y < a) continue; 13 | ret = std::max(ret, (500 - x % 500) % 500 + (500 - y % 500) % 500); 14 | } 15 | printf("%lld\n", ret); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /yandex-algorithm/2017/warmup-round/A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | for (int i = 1; i <= n; ++i) { 7 | if (n % i) { 8 | printf("%d\n", i); 9 | return 0; 10 | } 11 | } 12 | printf("%d\n", n + 1); 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /yandex-algorithm/2017/warmup-round/B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int a[4]; 6 | for (int i = 0; i < 4; ++i) scanf("%d", a + i); 7 | std::sort(a, a + 4); 8 | if (a[0] + a[1] + a[2] > a[3]) { 9 | do { 10 | if (a[0] + a[2] == a[1] + a[3]) { 11 | puts("Yes"); 12 | return 0; 13 | } 14 | } while (std::next_permutation(a, a + 4)); 15 | puts("No"); 16 | } else { 17 | puts("No"); 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /yandex-algorithm/2017/warmup-round/C.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main() { 7 | int n; 8 | scanf("%d", &n); 9 | std::vector a(n); 10 | for (int i = 0; i < n; ++i) { 11 | scanf("%d", &a[i]); 12 | } 13 | std::sort(a.begin(), a.end()); 14 | int ret = 0; 15 | for (int i = 0; i < n; ++ret) { 16 | if (i + 1 < n && a[i + 1] - a[i] <= 2) i += 2; 17 | else i += 1; 18 | } 19 | printf("%d\n", ret); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /yukicoder/11.py: -------------------------------------------------------------------------------- 1 | w = int(input()) 2 | h = int(input()) 3 | n = int(input()) 4 | 5 | X = set() 6 | Y = set() 7 | for i in range(n): 8 | x, y = input().split() 9 | X.add(x) 10 | Y.add(y) 11 | print(h * len(X) + w * len(Y) - n - len(X) * len(Y)) 12 | -------------------------------------------------------------------------------- /yukicoder/16.py: -------------------------------------------------------------------------------- 1 | mod = 10 ** 6 + 3 2 | x, n = list(map(int, input().split())) 3 | a = list(map(int, input().split())) 4 | r = 0 5 | for e in a: 6 | r += pow(x, e, mod) 7 | print(r % mod) 8 | -------------------------------------------------------------------------------- /yukicoder/18.py: -------------------------------------------------------------------------------- 1 | s = input() 2 | t = [''] * len(s) 3 | for i, x in enumerate(s): 4 | t[i] = chr(ord('A') + ((ord(x) - ord('A') - i - 1) % 26 + 26) % 26) 5 | print(''.join(t)) 6 | -------------------------------------------------------------------------------- /yukicoder/21.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | k = int(input()) 3 | a = [int(input()) for i in range(n)] 4 | group = [[] for i in range(k)] 5 | def search(d, m): 6 | if d == n: 7 | if m == k: 8 | avg = [sum(x) / len(x) for x in group] 9 | return max(avg) - min(avg) 10 | else: 11 | return 0 12 | ret = 0 13 | for i in range(min(m + 1, k)): 14 | group[i].append(a[d]) 15 | ret = max(ret, search(d + 1, max(m, i + 1))) 16 | group[i].pop(-1) 17 | return ret 18 | 19 | print(int(search(0, 0))) 20 | -------------------------------------------------------------------------------- /yukicoder/22.py: -------------------------------------------------------------------------------- 1 | n, k = list(map(int, input().split())) 2 | s = input() 3 | stack = [] 4 | mate = [0] * n 5 | for i, c in enumerate(s): 6 | if c == '(': 7 | stack.append(i) 8 | else: 9 | mate[stack[-1]] = i 10 | mate[i] = stack[-1] 11 | stack.pop(-1) 12 | print(mate[k - 1] + 1) 13 | -------------------------------------------------------------------------------- /yukicoder/23.py: -------------------------------------------------------------------------------- 1 | h, a, d = list(map(int, input().split())) 2 | 3 | mem = [-1] * (h + 1) 4 | def dp(c): 5 | if c <= 0: return 0 6 | if mem[c] >= 0: return mem[c] 7 | mem[c] = min(1 + dp(c - a), 1.5 + dp(c - d)) 8 | return mem[c] 9 | print(dp(h)) 10 | -------------------------------------------------------------------------------- /yukicoder/24.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | candidate = set([str(i) for i in range(10)]) 3 | invalid = set() 4 | for i in range(n): 5 | q = input().split() 6 | q, r = set(q[:4]), q[-1] 7 | if r == "YES": 8 | candidate = candidate.intersection(q) 9 | else: 10 | invalid |= q 11 | print(*(candidate - invalid)) 12 | -------------------------------------------------------------------------------- /yukicoder/25.py: -------------------------------------------------------------------------------- 1 | from fractions import gcd 2 | 3 | def valid(n): 4 | while n % 2 == 0: 5 | n //= 2 6 | while n % 5 == 0: 7 | n //= 5 8 | return n == 1 9 | 10 | n = int(input()) 11 | m = int(input()) 12 | g = gcd(n, m) 13 | n //= g 14 | m //= g 15 | if valid(m): 16 | q, r = divmod(n, m) 17 | if q > 0: 18 | ret = str(q).rstrip('0')[-1] 19 | else: 20 | ret = -1 21 | while r != 0: 22 | q, r = divmod(r * 10, m) 23 | if q != 0: 24 | ret = q 25 | print(ret) 26 | else: 27 | print(-1) 28 | -------------------------------------------------------------------------------- /yukicoder/26.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | p = [1, 2, 3] 3 | m = int(input()) 4 | for i in range(m): 5 | x, y = list(map(int, input().split())) 6 | p[x - 1], p[y - 1] = p[y - 1], p[x - 1] 7 | for i in range(3): 8 | if p[i] == n: 9 | print(i + 1) 10 | -------------------------------------------------------------------------------- /yukicoder/27.py: -------------------------------------------------------------------------------- 1 | def count(a, b): 2 | n = max(b) 3 | dp = [1e9] * (n + 1) 4 | dp[0] = 0 5 | for x in a: 6 | for i in range(x, n + 1): 7 | dp[i] = min(dp[i], dp[i - x] + 1) 8 | return sum([dp[x] for x in b]) 9 | 10 | v = list(map(int, input().split())) 11 | ret = 1e9 12 | for x in range(1, 31): 13 | for y in range(1, 31): 14 | for z in range(1, 31): 15 | ret = min(ret, count([x, y, z], v)) 16 | print(ret) 17 | -------------------------------------------------------------------------------- /yukicoder/29.py: -------------------------------------------------------------------------------- 1 | cnt = [0] * 10 2 | for i in range(int(input())): 3 | a, b, c = list(map(int, input().split())) 4 | cnt[a - 1] += 1 5 | cnt[b - 1] += 1 6 | cnt[c - 1] += 1 7 | ret, rem = 0, 0 8 | for i in range(10): 9 | ret += cnt[i] // 2; 10 | rem += cnt[i] % 2 11 | print(ret + rem // 4) 12 | -------------------------------------------------------------------------------- /yukicoder/30.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | m = int(input()) 3 | edges = [[] for i in range(n)] 4 | flag = [False] * n 5 | for i in range(m): 6 | p, r, q = list(map(int, input().split())) 7 | edges[q - 1].append((p - 1, r)) 8 | flag[q - 1] = True 9 | dp = [[-1] * n for i in range(n)] 10 | 11 | def dfs(i, j): 12 | res = 0 13 | if dp[i][j] >= 0: return dp[i][j] 14 | if i == j: return int(not flag[i]) 15 | for k, c in edges[i]: 16 | res += dfs(k, j) * c 17 | dp[i][j] = res 18 | return res 19 | 20 | for i in range(n - 1): 21 | print(dfs(n - 1, i)) 22 | -------------------------------------------------------------------------------- /yukicoder/3000.py: -------------------------------------------------------------------------------- 1 | s = [('pfnovu', 'orange'), ('axqwuf', 'cipher'), ('mbgrihcdejkolsty', 'bqsuftlmdxynzvwj')] 2 | mp = {} 3 | for a, b in s: 4 | for x, y in zip(a, b): 5 | mp[x] = y 6 | mp['z'] = 'k' 7 | s = input() 8 | t = [mp[x] for x in s] 9 | print(''.join(t)) 10 | -------------------------------------------------------------------------------- /yukicoder/3001.py: -------------------------------------------------------------------------------- 1 | x, y = map(float, input().split()) 2 | print(min(x, 1 - y), x - min(x, y)) 3 | -------------------------------------------------------------------------------- /yukicoder/3017.py: -------------------------------------------------------------------------------- 1 | s, k = map(int, input().split()) 2 | print(s % k) 3 | -------------------------------------------------------------------------------- /yukicoder/3019.py: -------------------------------------------------------------------------------- 1 | print 42 2 | -------------------------------------------------------------------------------- /yukicoder/3020.py: -------------------------------------------------------------------------------- 1 | x = raw_input() 2 | cnt = [0] * 5 3 | for c in x: 4 | if c == 'Y': 5 | cnt[0] += 1 6 | elif c == 'E': 7 | cnt[1] += 1 8 | elif c == 'A': 9 | cnt[2] += 1 10 | elif c == 'H': 11 | cnt[3] += 1 12 | else: 13 | cnt[4] += 1 14 | for x in cnt: 15 | print x, 16 | -------------------------------------------------------------------------------- /yukicoder/3021.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | q = int(raw_input()) 4 | for i in xrange(q): 5 | x1, x2, y1, y2 = map(int, raw_input().split(' ')) 6 | print 'SELECT count(*) FROM point WHERE x >= %d and x <= %d and y >= %d and y <= %d;' % (x1, x2, y1, y2) 7 | sys.stdout.flush() 8 | 9 | -------------------------------------------------------------------------------- /yukicoder/3022.py: -------------------------------------------------------------------------------- 1 | n = int(raw_input()) 2 | a = ord('p') - ord('a') 3 | b = ord('d') - ord('a') 4 | c = ord('f') - ord('a') 5 | d = ord('b') - ord('a') 6 | for i in xrange(d, n + d): 7 | if not (i % a): 8 | print 'FizzBuzz' 9 | elif not (i % b): 10 | print 'Fizz' 11 | elif not (i % c): 12 | print 'Buzz' 13 | else: 14 | print i 15 | -------------------------------------------------------------------------------- /yukicoder/3025.py: -------------------------------------------------------------------------------- 1 | print 'void' 2 | -------------------------------------------------------------------------------- /yukicoder/3026.py: -------------------------------------------------------------------------------- 1 | n = int(raw_input()) 2 | print pow(n, 3, 10 ** 9 + 7) 3 | -------------------------------------------------------------------------------- /yukicoder/3027.py: -------------------------------------------------------------------------------- 1 | a=[7, 8, 9, 4, 5, 6, 1, 2, 3, 0] 2 | print a[int(raw_input()) - 1] 3 | -------------------------------------------------------------------------------- /yukicoder/3028.py: -------------------------------------------------------------------------------- 1 | x = [2, 4, 9, 18, 37, 75, 150, 300, 600, 1200] 2 | n = int(raw_input()) 3 | if n == -1: 4 | print '600>>9-n' 5 | else: 6 | print x[n - 1] 7 | -------------------------------------------------------------------------------- /yukicoder/3029.py: -------------------------------------------------------------------------------- 1 | m = int(raw_input()) 2 | m = 177635683940025046467781066894531 % m 3 | if m % 2 == 0: 4 | print 'even' 5 | else: 6 | print 'odd' 7 | -------------------------------------------------------------------------------- /yukicoder/32.py: -------------------------------------------------------------------------------- 1 | l = int(input()) 2 | m = int(input()) 3 | n = int(input()) 4 | ret = n % 25 5 | m += n // 25 6 | ret += m % 4 7 | l += m // 4 8 | ret += l % 10 9 | print(ret) 10 | -------------------------------------------------------------------------------- /yukicoder/33.py: -------------------------------------------------------------------------------- 1 | n, d, t = list(map(int, input().split())) 2 | pos = dict() 3 | for x in map(int, input().split()): 4 | y = (x % d + d) % d 5 | if y in pos: 6 | pos[y].append(x) 7 | else: 8 | pos[y] = [x] 9 | ret = 0 10 | for k, v in pos.items(): 11 | seg = [] 12 | for x in v: 13 | seg.append((x - d * t, x + d * t)) 14 | seg.sort() 15 | l, r = seg[0] 16 | for e in seg[1:]: 17 | if e[0] <= r: 18 | r = max(r, e[1]) 19 | else: 20 | ret += (r - l) // d + 1 21 | l, r = e 22 | ret += (r - l) // d + 1 23 | print(ret) 24 | -------------------------------------------------------------------------------- /yukicoder/337.py: -------------------------------------------------------------------------------- 1 | n, p = map(int, raw_input().split()) 2 | if p == n * p: print '=' 3 | else: print '!=' 4 | -------------------------------------------------------------------------------- /yukicoder/35.py: -------------------------------------------------------------------------------- 1 | cnt, ret = 0, 0 2 | for i in range(int(input())): 3 | t, s = input().split() 4 | t = (int(t) * 12) // 1000 5 | cnt += min(len(s), t) 6 | if t < len(s): 7 | ret += len(s) - t 8 | print(cnt, ret) 9 | -------------------------------------------------------------------------------- /yukicoder/37.py: -------------------------------------------------------------------------------- 1 | T = int(input()) 2 | n = int(input()) 3 | c = list(map(int, input().split())) 4 | v = list(map(int, input().split())) 5 | f = [0] * (T + 1) 6 | for i in range(n): 7 | g = [x for x in f] 8 | total, need = 0, 0 9 | while v[i]: 10 | total += v[i] 11 | need += c[i] 12 | v[i] >>= 1 13 | for j in range(need, T + 1): 14 | g[j] = max(g[j], f[j - need] + total) 15 | f = g 16 | print(max(f)) 17 | -------------------------------------------------------------------------------- /yukicoder/38.py: -------------------------------------------------------------------------------- 1 | kr, kb = list(map(int, input().split())) 2 | s = input() 3 | ret = 10 4 | for mask in range(1 << 20): 5 | t = [] 6 | k = 0 7 | for c in s: 8 | if c == 'W' or (mask >> k & 1): 9 | t.append(c) 10 | if c != 'W': k += 1 11 | n = len(t) 12 | flag = True 13 | for i, c in enumerate(t): 14 | if c == 'R' and i + kr < n and t[i + kr] == 'R': flag = False 15 | if c == 'B' and i + kb < n and t[i + kb] == 'B': flag = False 16 | if not flag: break 17 | if flag: ret = max(ret, n) 18 | print(ret) 19 | -------------------------------------------------------------------------------- /yukicoder/39.py: -------------------------------------------------------------------------------- 1 | n = list(input()) 2 | ret = ''.join(n) 3 | for i in range(len(n)): 4 | for j in range(i): 5 | n[i], n[j] = n[j], n[i] 6 | ret = max(ret, ''.join(n)) 7 | n[i], n[j] = n[j], n[i] 8 | print(ret) 9 | -------------------------------------------------------------------------------- /yukicoder/40.py: -------------------------------------------------------------------------------- 1 | d = int(input()) 2 | a = list(map(int, input().split())) 3 | 4 | for i in range(d, 2, -1): 5 | a[i - 2] += a[i] 6 | 7 | d = min(2, d) 8 | for i in range(d, -1, -1): 9 | d = i 10 | if a[i]: break 11 | print(d) 12 | for i in range(d + 1): 13 | if i == 0: 14 | print(str(a[i]), end='') 15 | else: 16 | print(' ' + str(a[i]), end='') 17 | print() 18 | -------------------------------------------------------------------------------- /yukicoder/41.py: -------------------------------------------------------------------------------- 1 | n, mod = 10 ** 5, 10 ** 9 + 9 2 | dp = [0] * n 3 | dp[0] = 1 4 | for d in range(1, 10): 5 | for i in range(d, n): 6 | dp[i] += dp[i - d] 7 | dp[i] %= mod 8 | for i in range(1, n): 9 | dp[i] = (dp[i] + dp[i - 1]) % mod 10 | 11 | for _ in range(int(input())): 12 | m = int(input()) 13 | print(dp[m // 111111]) 14 | -------------------------------------------------------------------------------- /yukicoder/44.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | f = [1, 1] 3 | for i in range(2, n + 1): 4 | f.append(f[-1] + f[-2]) 5 | print(f[-1]) 6 | -------------------------------------------------------------------------------- /yukicoder/45.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | v = list(map(int, input().split())) 3 | f = [0] * n 4 | g = [0] * n 5 | f[0] = v[0] 6 | for i in range(1, n): 7 | f[i] = g[i - 1] + v[i] 8 | g[i] = max(f[i - 1], g[i - 1]) 9 | print(max(f[-1], g[-1])) 10 | -------------------------------------------------------------------------------- /yukicoder/46.py: -------------------------------------------------------------------------------- 1 | a, b = list(map(int, input().split())) 2 | print((b + a - 1) // a) 3 | -------------------------------------------------------------------------------- /yukicoder/469.py: -------------------------------------------------------------------------------- 1 | import random as rnd 2 | 3 | rnd.seed(2333) 4 | n, q = list(map(int, input().split())) 5 | seed = [rnd.randint(0, 2 ** 60) for i in range(n)] + [0] 6 | now = 0 7 | mem = {0 : 0} 8 | for i in range(q): 9 | c = input() 10 | if c[0] == '?': 11 | print(mem[now]) 12 | else: 13 | _, l, r, k = c.split() 14 | now += int(k) * (seed[int(l)] - seed[int(r)]) 15 | if not now in mem: 16 | mem[now] = i + 1 17 | -------------------------------------------------------------------------------- /yukicoder/47.py: -------------------------------------------------------------------------------- 1 | n = int(input()) - 1 2 | print(len(bin(n)) - 2 if n else 0) 3 | -------------------------------------------------------------------------------- /yukicoder/48.py: -------------------------------------------------------------------------------- 1 | x = int(input()) 2 | y = int(input()) 3 | l = int(input()) 4 | ret = 0 5 | if y < 0: 6 | ret += 2 7 | elif x != 0: 8 | ret += 1 9 | ret += (abs(x) + l - 1) // l + (abs(y) + l - 1) // l 10 | print(ret) 11 | -------------------------------------------------------------------------------- /yukicoder/486.py: -------------------------------------------------------------------------------- 1 | s = raw_input() 2 | result = None 3 | for i in xrange(len(s) - 2): 4 | t = s[i: i + 3] 5 | if t == 'OOO' and result is None: 6 | result = 'East' 7 | if t == 'XXX' and result is None: 8 | result = 'West' 9 | if result is None: 10 | result = 'NA' 11 | print result 12 | -------------------------------------------------------------------------------- /yukicoder/487.py: -------------------------------------------------------------------------------- 1 | M = int(raw_input()) 2 | print (2017 + pow(2017 * 2017, 2017, M)) % M 3 | -------------------------------------------------------------------------------- /yukicoder/49.py: -------------------------------------------------------------------------------- 1 | s = input() 2 | r, o, l = 0, 0, 0 3 | for c in s: 4 | if c == '*' or c == '+': 5 | if l == 0: r += o 6 | else: r *= o 7 | l = 0 if c == '*' else 1 8 | o = 0 9 | else: 10 | o = o * 10 + int(c) 11 | if l == 0: r += o 12 | else: r *= o 13 | print(r) 14 | -------------------------------------------------------------------------------- /yukicoder/589.py: -------------------------------------------------------------------------------- 1 | n = int(raw_input()) 2 | print n + 1 - 2 ** (bin(n).count("1")) 3 | -------------------------------------------------------------------------------- /yukicoder/591.py: -------------------------------------------------------------------------------- 1 | a = input() 2 | b = input() 3 | print('(' + a + b + a + ')/') 4 | -------------------------------------------------------------------------------- /yukicoder/597.py: -------------------------------------------------------------------------------- 1 | n = input() 2 | s = [raw_input() for i in xrange(n)] 3 | print ''.join(s) 4 | -------------------------------------------------------------------------------- /yukicoder/598.py: -------------------------------------------------------------------------------- 1 | N = int(input()) 2 | X = int(input()) 3 | A = int(input()) 4 | B = int(input()) 5 | print(min((X + A - 1) // A, (2 ** (N - 1) - X + B - 1) // B)) 6 | -------------------------------------------------------------------------------- /yukicoder/600.py: -------------------------------------------------------------------------------- 1 | s = 'abcdefghijklmnopqrstuvwxyz' 2 | def gen(level, n): 3 | if n == 1: 4 | return s[level % 26] 5 | elif n == 2: 6 | return s[level % 26] + s[level % 26] 7 | elif n % 2 == 0: 8 | u = s[level % 26] * 2 9 | return u + gen(level + 1, n // 2 - 1) + u 10 | else: 11 | return s[level % 26] + gen(level + 1, n - 1) + s[level % 26] 12 | 13 | print(gen(0, int(input()))) 14 | -------------------------------------------------------------------------------- /yukicoder/601.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int cnt[2][2]; 6 | memset(cnt, 0, sizeof(cnt)); 7 | int n; 8 | scanf("%d", &n); 9 | for (int i = 0; i < n; ++i) { 10 | int x, y; 11 | scanf("%d%d", &x, &y); 12 | cnt[x & 1][y & 1]++; 13 | } 14 | int turns = 0; 15 | for (int i = 0; i < 2; ++i) { 16 | for (int j = 0; j < 2; ++j) { 17 | turns += cnt[i][j] / 2; 18 | } 19 | } 20 | if (turns & 1) puts("Alice"); 21 | else puts("Bob"); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /yukicoder/604.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using int64 = long long; 4 | using int128 = __int128_t; 5 | 6 | int main() { 7 | int64 A, B, C; 8 | std::cin >> A >> B >> C; 9 | int64 l = 1, r = C; 10 | while (l < r) { 11 | int64 m = (l + r - 1) >> 1; 12 | int64 k = m / A; 13 | int128 u = m - k + (int128)k * B; 14 | if (u >= C) r = m; 15 | else l = m + 1; 16 | } 17 | std::cout << l << std::endl; 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /yukicoder/605.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | double a, b; 6 | scanf("%lf%lf", &a, &b); 7 | printf("%.10f\n", 2 * acos(-1.0) * (b - a)); 8 | } 9 | -------------------------------------------------------------------------------- /yukicoder/609.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using int64 = long long; 6 | 7 | int main() { 8 | int n; 9 | scanf("%d", &n); 10 | std::vector a(n); 11 | for (int i = 0; i < n; ++i) { 12 | scanf("%d", &a[i]); 13 | } 14 | std::sort(a.begin(), a.end()); 15 | int64 ret = 0; 16 | for (int i = 0; i < n; ++i) { 17 | ret += std::abs(a[i] - a[n / 2]); 18 | } 19 | printf("%lld\n", ret); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /yukicoder/610.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | a = list(map(int, input().split())) 3 | b = list(map(int, input().split())) 4 | order = [0] * n 5 | for i, x in enumerate(a): 6 | order[x - 1] = i 7 | mx = -1 8 | can = [] 9 | for x in b: 10 | if order[x - 1] > mx: 11 | can.append(x) 12 | mx = max(mx, order[x - 1]) 13 | can.sort() 14 | for x in can: 15 | print(x) 16 | -------------------------------------------------------------------------------- /yukicoder/615.py: -------------------------------------------------------------------------------- 1 | n, k = map(int, input().split()) 2 | a = list(map(int, input().split())) 3 | a.sort() 4 | b = [a[i] - a[i - 1] for i in range(1, n)] 5 | b.sort() 6 | b.reverse() 7 | ret = sum(b) 8 | for i in range(k - 1): 9 | ret -= b[i] 10 | print(ret) 11 | -------------------------------------------------------------------------------- /yukicoder/8.py: -------------------------------------------------------------------------------- 1 | for _ in xrange(int(raw_input())): 2 | n, k = map(int, raw_input().split()) 3 | if (n - 1) % (k + 1) == 0: print 'Lose' 4 | else: print 'Win' 5 | -------------------------------------------------------------------------------- /yukicoder/9.py: -------------------------------------------------------------------------------- 1 | from heapq import * 2 | 3 | n = int(input()) 4 | a = list(map(int, input().split())) 5 | b = list(map(int, input().split())) 6 | 7 | ret = n 8 | for i in range(n): 9 | pq = [(x, 0) for x in a] 10 | heapify(pq) 11 | mx = 0 12 | for j in range(n): 13 | e = b[(i + j) % n] 14 | u = heappop(pq) 15 | u = (u[0] + e // 2, u[1] + 1) 16 | heappush(pq, u) 17 | mx = max([e[1] for e in pq]) 18 | ret = min(ret, mx) 19 | print(ret) 20 | -------------------------------------------------------------------------------- /yukicoder/9000.py: -------------------------------------------------------------------------------- 1 | print('Hello World!') 2 | -------------------------------------------------------------------------------- /yukicoder/9001.py: -------------------------------------------------------------------------------- 1 | n = sum(map(int, input().split())) 2 | s = input() 3 | print(n, s) 4 | -------------------------------------------------------------------------------- /yukicoder/9002.py: -------------------------------------------------------------------------------- 1 | n = int(raw_input()) 2 | a = ord('p') - ord('a') 3 | b = ord('d') - ord('a') 4 | c = ord('f') - ord('a') 5 | d = ord('b') - ord('a') 6 | for i in xrange(d, n + d): 7 | if not (i % a): 8 | print 'FizzBuzz' 9 | elif not (i % b): 10 | print 'Fizz' 11 | elif not (i % c): 12 | print 'Buzz' 13 | else: 14 | print i 15 | -------------------------------------------------------------------------------- /yukicoder/9003.py: -------------------------------------------------------------------------------- 1 | print('decimal') 2 | print(input()) 3 | -------------------------------------------------------------------------------- /yukicoder/9004.py: -------------------------------------------------------------------------------- 1 | print('') 2 | -------------------------------------------------------------------------------- /yukicoder/9005.py: -------------------------------------------------------------------------------- 1 | print(0) 2 | -------------------------------------------------------------------------------- /yukicoder/9006.py: -------------------------------------------------------------------------------- 1 | s = input() 2 | print(s[::-1]) 3 | -------------------------------------------------------------------------------- /yukicoder/9007.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | print(0, n) 3 | -------------------------------------------------------------------------------- /yukicoder/9008.py: -------------------------------------------------------------------------------- 1 | input() 2 | print(sum(map(int, input().split()))) 3 | -------------------------------------------------------------------------------- /yukicoder/9009.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | print(sum([int(input()) for i in range(n)])) 3 | -------------------------------------------------------------------------------- /yukicoder/9010.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | print('Yes' if (n % 4 == 0 and n % 100 != 0) or n % 400 == 0 else 'No') 3 | -------------------------------------------------------------------------------- /yukicoder/9011.py: -------------------------------------------------------------------------------- 1 | print(sum(map(int, list(input())))) 2 | -------------------------------------------------------------------------------- /yukicoder/9012.py: -------------------------------------------------------------------------------- 1 | print('') 2 | --------------------------------------------------------------------------------