├── .gitignore ├── LICENSE ├── README.md └── src ├── codecraft2017 ├── a.cpp ├── b.cpp └── c.cpp ├── codeforces ├── 365 │ ├── cities.cpp │ ├── mishkagame.cpp │ └── sum.cpp ├── anticube.cpp ├── calendar.cpp ├── camp.cpp ├── cf544 │ ├── islands.c │ └── strings.c ├── cf569 │ ├── inventory.py │ ├── music.c │ └── symmetric.c ├── cf586 │ ├── dentist.c │ ├── schedule.c │ └── shop.c ├── cf591 │ ├── branding.c │ └── hp.c ├── chocolate.cpp ├── cinema.cpp ├── dance.cpp ├── diffisgood.cpp ├── educational145 │ ├── one.py │ └── two.py ├── gcd.py ├── gen.cpp ├── grasshopper.cpp ├── holiday.cpp ├── linearfunction.cpp ├── magic.cpp ├── magic.py ├── matrix.cpp ├── numbers.cpp ├── pouring.cpp ├── presents.cpp ├── rebus.py ├── recycle.cpp ├── robin.cpp ├── robots.cpp ├── round 507 │ ├── one.cpp │ └── two.cpp ├── round 508 │ ├── four.cpp │ ├── one.cpp │ ├── three.cpp │ └── two.cpp ├── round858 │ ├── five.go │ ├── one.go │ ├── three.go │ └── two.go ├── sith.cpp └── worldtour.cpp ├── codesprint ├── aorb.cpp ├── dist.cpp ├── roads.cpp └── stacks.cpp ├── cookoff ├── cook63 │ ├── asp.c │ ├── palindrome.java │ └── stem.py └── cook74 │ ├── one.cpp │ ├── three.cpp │ └── two.cpp ├── hacker cup ├── qualifier │ ├── dnd.cpp │ └── lazyloading.cpp └── round1 │ ├── manicmoving.cpp │ └── progresspie.cpp ├── hourrank └── counter.cpp ├── long ├── april15 │ ├── brokphon.hs │ ├── cseq.hs │ ├── cseq.java │ ├── frmq.java │ ├── piano.hs │ └── primefac.java ├── april16 │ ├── balloons.cpp │ ├── color.cpp │ ├── fibq.cpp │ ├── magic.cpp │ └── watson.cpp ├── aug15 │ ├── GravityGuy.java │ ├── cookmach.py │ ├── wout.c │ └── wout1.c ├── aug16 │ ├── chahg.cpp │ ├── chchcl.cpp │ ├── chefcrun.cpp │ ├── chefrrun.cpp │ ├── cheftre.cpp │ ├── ebola.cpp │ ├── goodprob.cpp │ ├── maxgrid.cpp │ ├── shaikhgn.cpp │ └── tricont.cpp ├── jul16 │ └── chefarc.cpp ├── jun15 │ ├── anti2.c │ ├── cbarg.hs │ ├── cbarg.py │ ├── polygons.c │ ├── polygons.py │ ├── prob.py │ ├── steady.c │ └── steady.py ├── jun16 │ ├── binop.cpp │ ├── chcoinsg.cpp │ ├── chearmy.cpp │ ├── chefark.cpp │ ├── chsqarray.cpp │ ├── devarray.cpp │ └── frjump.cpp ├── march15 │ ├── cnote.c │ ├── cnote.py │ ├── devclass.py │ ├── qchef.py │ ├── signwave.py │ └── strsub.c ├── may15 │ └── chefrp.hs ├── nov15 │ ├── cakes.c │ ├── chefshop.c │ ├── chstamp.cpp │ ├── chstamp.java │ ├── kfunc.c │ ├── kfunc.py │ ├── recrecov.c │ └── smplsum.c ├── oct15 │ ├── hypotenuse.c │ ├── pershifts.c │ ├── shifts.c │ ├── spheres.c │ ├── subinc.c │ ├── timeasr.py │ └── wdtbam.py ├── sep15 │ ├── input │ ├── question1.c │ ├── question2.c │ ├── question3.py │ ├── question4.c │ ├── question5.py │ └── rebxor.java └── sept16 │ ├── eight.cpp │ ├── five.cpp │ ├── four.cpp │ ├── nine.cpp │ ├── one.cpp │ ├── seven.cpp │ ├── six.cpp │ ├── ten.cpp │ ├── three.cpp │ └── two.cpp ├── ltime27 └── mnmx.py ├── practice ├── 117c.cpp ├── Kefa.java ├── Trie.java ├── acode.cpp ├── aggrcow.c ├── aiboh.cpp ├── akbar.cpp ├── alicecube.cpp ├── almost.cpp ├── amazingmaze.cpp ├── arbitrage.cpp ├── bigbang.cpp ├── binarysearch │ ├── books.cpp │ ├── chefandwords.cpp │ ├── devubrother.cpp │ ├── eko.cpp │ ├── multable.cpp │ ├── present.cpp │ ├── r2d2droids.cpp │ ├── renting.cpp │ ├── sumfour.cpp │ └── watto.cpp ├── bit.c ├── brckets.c ├── brckts2.cpp ├── buglife.cpp ├── buglife.java ├── candy.c ├── capcity.cpp ├── capple.py ├── chefAndEquality.c ├── chefandchains.py ├── chefd.c ├── chefstone.c ├── chefstone.py ├── chmaze.cpp ├── cleanup.hs ├── cntprime.c ├── coins.py ├── colorful.cpp ├── cooling.hs ├── copying.cpp ├── cornet.cpp ├── courage.c ├── cowpic.cpp ├── cowsandcars.cpp ├── cstreet.cpp ├── cthulhu.cpp ├── cycles.cpp ├── dcepca03.cpp ├── desert.cpp ├── dice.c ├── digjump.cpp ├── digvijay.c ├── dijkstra.cpp ├── dilemma.cpp ├── div.c ├── div2.c ├── divfact.cpp ├── dorms.cpp ├── doubleprofiles.cpp ├── dp │ ├── acquire.cpp │ ├── activ.cpp │ ├── assign.cpp │ ├── bagofmice.cpp │ ├── balnum.cpp │ ├── barcode.cpp │ ├── beewalk.cpp │ ├── blackorwhite.cpp │ ├── bridge.cpp │ ├── bridgehard.cpp │ ├── cleanrbt.cpp │ ├── colorstripe.cpp │ ├── commando.cpp │ ├── cyclerace.cpp │ ├── dima.and.salad-366C.cpp │ ├── divseq.cpp │ ├── fisher.cpp │ ├── flowers.cpp │ ├── fpolice.cpp │ ├── funnygames.cpp │ ├── georgeandjob.cpp │ ├── good.cpp │ ├── goodg.cpp │ ├── grandpawalk.cpp │ ├── guardians.cpp │ ├── harmonychest.cpp │ ├── helix.cpp │ ├── hist2.cpp │ ├── increase.sequence-466D.cpp │ ├── jump.cpp │ ├── mblast.cpp │ ├── parseq.cpp │ ├── pashmak.cpp │ ├── permut1.cpp │ ├── pokemon.cpp │ ├── recu.cpp │ ├── redgreen.cpp │ ├── ridinglift.cpp │ ├── roman.cpp │ ├── savetoys.cpp │ ├── seinfeld.cpp │ ├── serejabracket.cpp │ ├── slow.cpp │ ├── socola.cpp │ ├── tetrahedron.cpp │ ├── treeland.cpp │ ├── trip.cpp │ ├── trt.cpp │ └── vladiktrip.cpp ├── dquery.c ├── ds │ ├── archeology.cpp │ ├── brandnewfunction.cpp │ ├── cardshuffle.cpp │ ├── casino.cpp │ ├── choosing.the.commander-817E.cpp │ ├── cot.cpp │ ├── divcon.cpp │ ├── enemyisweak.cpp │ ├── gss6.cpp │ ├── helpr2d2.cpp │ ├── interestingarray.cpp │ ├── mkthnum.cpp │ ├── orderset-treap.cpp │ ├── qmax.cpp │ ├── sasha.cpp │ └── vitya.and.strange.lesson-842D.cpp ├── eagle.java ├── eagle1.cpp ├── easynumberchallenge.c ├── edist.cpp ├── eternal.cpp ├── exponentiation.c ├── factcg2.c ├── farida.c ├── fctrl2.hs ├── flow │ ├── alamode.cpp │ ├── angels.cpp │ ├── baby.cpp │ ├── bandwidth.cpp │ ├── black.cpp │ ├── coconuts.cpp │ ├── collect.cpp │ ├── course.cpp │ ├── dangtunnels.cpp │ ├── dijkdijk.cpp │ ├── dinic.cpp │ ├── gaswars.cpp │ ├── goinghome.cpp │ ├── greed.cpp │ ├── intergalactic.cpp │ ├── matching.cpp │ ├── mobivina.cpp │ ├── mtotalf.cpp │ ├── naming.cpp │ ├── netadmin.cpp │ ├── optimalmarks.cpp │ ├── pothole.cpp │ ├── power.cpp │ ├── profit.cpp │ ├── quest4.cpp │ ├── robbing.cpp │ ├── routered.cpp │ ├── stead.cpp │ ├── taxi.cpp │ ├── tours.cpp │ └── vertexcover.cpp ├── frequent.c ├── gcd2.py ├── gcdq.c ├── generouskefa.cpp ├── godsend.cpp ├── goincycle.cpp ├── graph │ ├── applemantree.cpp │ ├── bookofevil.cpp │ ├── ceilcommander.cpp │ ├── checkposts.cpp │ ├── civ.cpp │ ├── completethegraph.cpp │ ├── dima.and.bacteria-400.D.cpp │ ├── disquery.cpp │ ├── driversdissatisfaction.cpp │ ├── foxandminimal.cpp │ ├── george.cpp │ ├── goodintentions.cpp │ ├── greg.cpp │ ├── ilyatree.cpp │ ├── inverse.cpp │ ├── jzzhu.and.cities-449B.cpp │ ├── lecturerooms.cpp │ ├── luckytree.cpp │ ├── qtree2.cpp │ ├── qtree4.cpp │ ├── qtree5.cpp │ ├── raymondnetwork.cpp │ ├── touristreform.cpp │ ├── validsets.cpp │ ├── xenia.cpp │ └── zerotree.cpp ├── graphcut.cpp ├── greatball.cpp ├── gss1.c ├── gss3.c ├── gss4.c ├── gss5.c ├── haybale.c ├── horrible.c ├── iceskating.cpp ├── inberland.cpp ├── infograph.cpp ├── kgss.c ├── kingspath.cpp ├── kquery.c ├── kqueryo.cpp ├── ladder │ ├── almostarithmetic.cpp │ ├── beautifulmatrix.cpp │ ├── beautifulnumbers.cpp │ ├── bitplusplus.cpp │ ├── boredom.cpp │ ├── boyorgirl.cpp │ ├── bubblesortgraph.cpp │ ├── buildperm.cpp │ ├── capitalization.cpp │ ├── chess.cpp │ ├── commondivisor.cpp │ ├── cutribbon.cpp │ ├── digits.cpp │ ├── dragons.cpp │ ├── dubstep.cpp │ ├── dzysequence.cpp │ ├── elections.cpp │ ├── fence.cpp │ ├── football.cpp │ ├── gregarray.cpp │ ├── hello.cpp │ ├── ilyamatrix.cpp │ ├── ktree.cpp │ ├── ladder.cpp │ ├── languages.cpp │ ├── lucky.cpp │ ├── mafia.cpp │ ├── magnets.cpp │ ├── maximumabsurdity.cpp │ ├── maximumxor.cpp │ ├── modifiedgcd.cpp │ ├── oddeven.cpp │ ├── palindrometransformation.cpp │ ├── petyaandstrings.cpp │ ├── physicspractical.cpp │ ├── puzzle.cpp │ ├── ringroad.cpp │ ├── systemofequations.cpp │ ├── team.cpp │ ├── toaddornot.cpp │ ├── tprimes.cpp │ ├── waytoolong.cpp │ ├── wifi.cpp │ ├── xorandor.cpp │ └── youngphysicist.cpp ├── laser.cpp ├── lca.cpp ├── lite.c ├── luckfour.hs ├── luckyfour.py ├── magicgrid.cpp ├── mail.cpp ├── martian.c ├── mathbond.java ├── maths.c ├── maxcount.c ├── meetingparty.cpp ├── merge.c ├── mime2.py ├── misc │ ├── karen.and.game-815A.cpp │ ├── little.elephant.and.array-220B.cpp │ ├── max.or.subarray.cpp │ └── okabe.and.boxes-821C.cpp ├── missile.cpp ├── mixtures.c ├── mows.cpp ├── mpilot.c ├── msched.cpp ├── multq3.c ├── nochange.cpp ├── nondecreasingdigits.cpp ├── notinberland.cpp ├── nsteps.c ├── numbers │ ├── cardgame.cpp │ ├── cprime.cpp │ ├── euler │ │ ├── 1.py │ │ ├── 10.c │ │ ├── 12.c │ │ ├── 13.py │ │ ├── 15.c │ │ ├── 18.c │ │ ├── 2.py │ │ ├── 20.py │ │ ├── 21.c │ │ ├── 22.py │ │ ├── 25.py │ │ ├── 26.hs │ │ ├── 3.py │ │ ├── 4.py │ │ ├── 42.py │ │ ├── 47.c │ │ ├── 48.hs │ │ ├── 5.py │ │ ├── 53.py │ │ ├── 6.py │ │ ├── 69.cpp │ │ ├── 70.cpp │ │ ├── 72.cpp │ │ ├── 8.py │ │ ├── 81.c │ │ ├── 82.c │ │ ├── 83.c │ │ ├── 9.c │ │ ├── fix.py │ │ ├── fixed │ │ ├── p096_sudoku.txt │ │ └── sudoku.cpp │ ├── gcdex.cpp │ ├── lcmsum.cpp │ ├── primeornot.cpp │ └── xmax.cpp ├── onp.py ├── paradox.c ├── paradox.java ├── party.c ├── party.py ├── phidias.cpp ├── philosophers.cpp ├── phonelst.java ├── picadilly.cpp ├── pigbank.c ├── pleaselikeme.hs ├── police.cpp ├── pour1.cpp ├── powersoftwo.cpp ├── prime.c ├── prime1.c ├── primepalindrome.hs ├── prladdu.py ├── psort.cpp ├── psycho2.c ├── psychon.c ├── pt07z.java ├── qtree.cpp ├── que.cpp ├── racetime.cpp ├── ranklist.c ├── rebxor.c ├── ren2013g.c ├── reverse.cpp ├── ribbons.c ├── righteous.cpp ├── ringroad.cpp ├── rmqsq.c ├── roadmap.cpp ├── roads.cpp ├── rock.c ├── salman.cpp ├── segsqrss.c ├── shoelaces.cpp ├── snake.cpp ├── snape.py ├── soldier.cpp ├── solve2.java ├── st_queries.c ├── st_queries.py ├── staircase.cpp ├── strings │ ├── countgoodsubstrings.451.D.cpp │ ├── cubewalls.cpp │ ├── equivalent.cpp │ ├── goodsubstrings.cpp │ └── nhay.cpp ├── submerge.cpp ├── subst1.c ├── subway.cpp ├── subxor.java ├── sysadmin.cpp ├── tdkprime.c ├── temple.cpp ├── test.hs ├── tfriends.cpp ├── tickets.py ├── topological.cpp ├── trafficn.cpp ├── triangles.cpp ├── tsort.c ├── twends.c ├── twopaths.cpp ├── usubqsub.c ├── variable.cpp ├── volleyball.cpp ├── wachovia.c ├── windvane.cpp ├── wout.c ├── xor.py ├── xorseg.cpp └── yodaness.py ├── recreation ├── a.blend.of.springtime.cpp ├── a.tide.of.riverscape.cpp ├── and.graph.cpp ├── bear.and.friendship.condition.cpp ├── bus.of.characters.cpp ├── chess.placing.cpp ├── cutemall.cpp ├── equalize.cpp ├── fair.cpp ├── high.school.become.human.py ├── infinity.gauntlet.py ├── inverse.colouring.cpp ├── make_it_equal.cpp ├── maximum.value.cpp ├── packets.cpp ├── petr.and.permutations.cpp ├── prepare.for.merge.sort.cpp ├── reach.median.cpp ├── row.cpp ├── sereja.and.suffixes.cpp ├── three.displays.cpp ├── trips.cpp ├── valid.bfs?.cpp └── weakened.common.divisor.cpp ├── rs ├── equalornotequal.rs └── trianglesonarectangle.rs └── snackdown ├── game.cpp ├── givcandy.cpp ├── kgood.cpp ├── mmsum.cpp ├── ndiffpal.cpp └── table.cpp /.gitignore: -------------------------------------------------------------------------------- 1 | *.hi 2 | *.class 3 | *.pyc 4 | *.in 5 | *.out 6 | in 7 | out 8 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 Param Singh 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /src/codecraft2017/a.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | const int mod = 1e9 + 7; 8 | 9 | char s[100100]; 10 | map mp; 11 | 12 | int main(void) { 13 | scanf("%s", s); 14 | int l = strlen(s); 15 | for (int i = 0; i < l; i++) 16 | mp[s[i]]++; 17 | // Bulbasaur 18 | int ans = min(mp['B'], mp['u'] / 2); 19 | ans = min(ans, mp['l']); 20 | ans = min(ans, mp['b']); 21 | ans = min(ans, mp['a'] / 2); 22 | ans = min(ans, mp['s']); 23 | ans = min(ans, mp['r']); 24 | printf("%d\n", ans); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /src/codecraft2017/b.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | const int mod = 1e9 + 7; 8 | 9 | int freq[500100]; 10 | int a[100100]; 11 | 12 | int main(void) { 13 | int n; 14 | scanf("%d", &n); 15 | for (int i = 1; i <= n; i++) { 16 | scanf("%d", &a[i]); 17 | freq[a[i]]++; 18 | } 19 | int ans = 1; 20 | for (int g = 2; g <= 1e5; g++) { 21 | int cnt = 0; 22 | for (int x = g; x <= 1e5; x+=g) 23 | cnt += freq[x]; 24 | ans = max(ans, cnt); 25 | } 26 | printf("%d\n", ans); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /src/codeforces/365/cities.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | typedef long long lli; 3 | 4 | lli a[100100]; 5 | int done[100100]; 6 | 7 | int main(void) { 8 | int n, k; 9 | scanf("%d %d", &n, &k); 10 | lli sum = 0; 11 | lli ans = 0; 12 | for (int i = 1; i <= n; i++) { 13 | scanf("%lld", a+i); 14 | ans += a[i] * a[i-1]; 15 | sum += a[i]; 16 | } 17 | ans += a[n] * a[1]; 18 | for (int i = 0; i < k; i++) { 19 | int id; 20 | scanf("%d", &id); 21 | int s = sum; 22 | int prev = id - 1 == 0 ? n : id - 1; 23 | int next = id + 1 == n + 1 ? 1 : id + 1; 24 | if (done[prev] == 0) 25 | s -= a[prev]; 26 | if (done[next] == 0) 27 | s -= a[next]; 28 | s -= a[id]; 29 | ans += a[id] * s; 30 | done[id] = 1; 31 | sum -= a[id]; 32 | } 33 | std::cout << ans << std::endl; 34 | return 0; 35 | } 36 | 37 | -------------------------------------------------------------------------------- /src/codeforces/365/mishkagame.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int n; 5 | scanf("%d", &n); 6 | int w = 0, l = 0, t = 0; 7 | for (int i = 0; i < n; i++) { 8 | int m, c; 9 | scanf("%d %d", &m, &c); 10 | if (m > c) 11 | w++; 12 | else if (m < c) 13 | l++; 14 | else 15 | t++; 16 | } 17 | if (w > l) 18 | printf("Mishka\n"); 19 | else if (l > w) 20 | printf("Chris\n"); 21 | else 22 | printf("Friendship is magic!^^\n"); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /src/codeforces/anticube.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int a[100100]; 5 | 6 | int main(void) { 7 | int n; 8 | scanf("%d", &n); 9 | long long int m = -1; 10 | for (int i = 0; i < n; i++) { 11 | scanf("%d", a+i); 12 | if (m < a[i]) 13 | m = a[i]; 14 | } 15 | long long int s = 0; 16 | for (int i = 0; i < n; i++) { 17 | if (a[i] != m) 18 | s += a[i]; 19 | } 20 | cout << m - s + 1 << endl; 21 | return 0; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /src/codeforces/calendar.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(void) { 5 | int y; 6 | scanf("%d", &y); 7 | int leap = (y % 400 == 0 || (y % 4 == 0 && y % 100 != 0)); 8 | int d = 0; 9 | for (int i = y + 1; ; i++) { 10 | int flag = (i % 400 == 0 || (i % 4 == 0 && i % 100 != 0)); 11 | if (flag) 12 | d = (d + 2) % 7; 13 | else 14 | d = (d + 1) % 7; 15 | if (d == 0) { 16 | if (leap && flag) { 17 | printf("%d\n", i); 18 | break; 19 | } 20 | else if (!leap && !flag) { 21 | printf("%d\n", i); 22 | break; 23 | } 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/codeforces/camp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | string s; 5 | int main(void) { 6 | int i = 1; 7 | while (s.length() < 1000) { 8 | string n; 9 | int dup = i; 10 | while (dup != 0) { 11 | n += ((dup % 10) + '0'); 12 | dup /= 10; 13 | } 14 | reverse(n.begin(), n.end()); 15 | s += n; 16 | i++; 17 | } 18 | int num; 19 | scanf("%d", &num); 20 | cout << s[num-1] << endl; 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /src/codeforces/cf544/strings.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(void) { 6 | int k; 7 | char *q = (char *) calloc(101, 4); 8 | scanf("%d", &k); 9 | scanf("%s", q); 10 | int l = strlen(q); 11 | int* seen = (int *) calloc(26, 4); 12 | int* start = (int *) calloc(101, 4); 13 | int c = 0; 14 | int i; 15 | for (i = 0; i < l; i++) { 16 | int index = q[i] - 'a'; 17 | if (!seen[index]) { 18 | start[i] = 1; 19 | seen[index] = 1; 20 | c++; 21 | } 22 | } 23 | if (c >= k) { 24 | printf("YES\n"); 25 | int count = 1; 26 | printf("%c", q[0]); 27 | for (i = 1; i < l; i++) { 28 | if (start[i] == 1) { 29 | if (count < k) { 30 | printf("\n%c", q[i]); 31 | count++; 32 | } 33 | else { 34 | printf("%c", q[i]); 35 | } 36 | } 37 | else { 38 | printf("%c", q[i]); 39 | } 40 | } 41 | } 42 | else { 43 | printf("NO\n"); 44 | } 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /src/codeforces/cf569/inventory.py: -------------------------------------------------------------------------------- 1 | n = int(input()) 2 | seen = [0 for _ in range(100001)] 3 | arr = list(map(int, input().split())) 4 | notseen = [] 5 | 6 | for i in arr: 7 | seen[i] += 1 8 | 9 | for i in range(1, n+1): 10 | if seen[i] == 0: 11 | notseen.append(i) 12 | 13 | for i in range(n): 14 | if seen[arr[i]] > 1 or arr[i] > n: 15 | nxt = notseen.pop() 16 | print(nxt, end = " ") 17 | seen[nxt] += 1 18 | seen[arr[i]] -= 1 19 | else: 20 | print(arr[i], end = " ") 21 | -------------------------------------------------------------------------------- /src/codeforces/cf569/music.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int t, s, q; 5 | scanf("%d%d%d", &t, &s, &q); 6 | int ans = 1; 7 | while (s*q < t) { 8 | ans++; 9 | s *= q; 10 | } 11 | printf("%d\n", ans); 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /src/codeforces/cf586/schedule.c: -------------------------------------------------------------------------------- 1 | // Author: Param Singh 2 | 3 | #include 4 | int main(void) { 5 | int n; 6 | scanf("%d", &n); 7 | int uni = 0; 8 | int free = 0; 9 | int first = 1; 10 | int i; 11 | for (i = 0; i < n; i++) { 12 | int x; 13 | scanf("%d", &x); 14 | if (first && x == 1) { 15 | uni++; 16 | first = 0; 17 | } 18 | else if (!first) { 19 | if (x == 1) { 20 | uni++; 21 | if (free <= 1) 22 | uni += free; 23 | free = 0; 24 | } 25 | else { 26 | free++; 27 | } 28 | } 29 | } 30 | printf("%d\n", uni); 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /src/codeforces/cf591/branding.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(void) { 5 | char alphabet[26]; 6 | int pos[26]; 7 | int n, m; 8 | int i, j; 9 | for (i = 0; i < 26; i++) { 10 | alphabet[i] = 'a' + i; 11 | pos[i] = i; 12 | } 13 | scanf("%d %d", &n, &m); 14 | char s[n+1]; 15 | scanf("%s", s); 16 | char* a[n+1]; 17 | for (i = 0; i < n; i++) { 18 | a[i] = alphabet + (s[i] - 'a'); 19 | } 20 | for (i = 0; i < m; i++) { 21 | char x, y; 22 | scanf(" %c %c", &x, &y); 23 | alphabet[pos[y-'a']] = x; 24 | alphabet[pos[x-'a']] = y; 25 | int temp = pos[x-'a']; 26 | pos[x - 'a'] = pos[y - 'a']; 27 | pos[y - 'a'] = temp; 28 | } 29 | for (j = 0; j < n; j++) { 30 | printf("%c", *(a[j])); 31 | } 32 | printf("\n"); 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /src/codeforces/cf591/hp.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int l, p, q; 5 | scanf("%d", &l); 6 | scanf("%d", &p); 7 | scanf("%d", &q); 8 | float ans = ((float)(p) * l) / (float)(p+q); 9 | printf("%f\n", ans); 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /src/codeforces/chocolate.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | long long gcd(int a, int b) { 5 | while (b != 0) { 6 | int temp = b; 7 | b = a % b; 8 | a = temp; 9 | } 10 | return a; 11 | } 12 | 13 | int main(void) { 14 | int n, a, b, p, q; 15 | scanf("%d %d %d %d %d", &n, &a, &b, &p, &q); 16 | long long x = (a * (long long) b) / gcd(a, b); 17 | long long ca = n / a; 18 | long long cb = n / b; 19 | long long cc = n / x; 20 | long long ans = (ca - cc) * p + cb * q; 21 | if (p > q) 22 | ans += ((p - q) * cc); 23 | printf("%lld\n", ans); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /src/codeforces/dance.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int arr[1000100]; 5 | 6 | int main(void) { 7 | int n, q; 8 | scanf("%d %d", &n, &q); 9 | int oo = 0, eo = 0; 10 | while (q--) { 11 | int t; 12 | scanf("%d", &t); 13 | if (t == 1) { 14 | int ch; 15 | scanf("%d", &ch); 16 | oo += ch; 17 | eo += ch; 18 | } 19 | else { 20 | int pos0 = eo % n; 21 | if (pos0 < 0) 22 | pos0 += n; 23 | if (pos0 % 2 == 0) { 24 | eo++; 25 | oo--; 26 | } 27 | else { 28 | eo--; 29 | oo++; 30 | } 31 | } 32 | } 33 | for (int i = 0; i < n; i++) { 34 | int pos; 35 | if (i % 2 == 0) { 36 | pos = (i + eo) % n; 37 | } 38 | else { 39 | pos = (i + oo) % n; 40 | } 41 | if (pos < 0) 42 | pos += n; 43 | arr[pos] = i+1; 44 | } 45 | 46 | for (int i = 0; i < n; i++) 47 | printf("%d ", arr[i]); 48 | return 0; 49 | } 50 | 51 | 52 | -------------------------------------------------------------------------------- /src/codeforces/diffisgood.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char s[100100]; 5 | int freq[30] = {0}; 6 | 7 | 8 | int main(void) { 9 | int n; 10 | scanf("%d", &n); 11 | scanf("%s", s); 12 | if (n > 26) 13 | printf("-1\n"); 14 | else { 15 | for (int i = 0; i < n; i++) 16 | freq[s[i]-'a']++; 17 | int cnt = 0; 18 | for (int i = 0; i < 26; i++) { 19 | if (freq[i] > 1) 20 | cnt += freq[i] - 1; 21 | } 22 | printf("%d\n", cnt); 23 | } 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /src/codeforces/educational145/one.py: -------------------------------------------------------------------------------- 1 | from collections import defaultdict 2 | 3 | t = int(input()) 4 | for _ in range(t): 5 | chars = map(int, input()[::]) 6 | freqs = defaultdict(int) 7 | for char in chars: 8 | freqs[char] += 1 9 | max_freq = max(freqs.values()) 10 | if max_freq == 1 or max_freq == 2: 11 | print(4) 12 | elif max_freq == 3: 13 | print(6) 14 | else: 15 | print(-1) 16 | -------------------------------------------------------------------------------- /src/codeforces/educational145/two.py: -------------------------------------------------------------------------------- 1 | from decimal import Decimal 2 | 3 | t = int(input()) 4 | for _ in range(t): 5 | num_chips = int(input()) 6 | root = int(Decimal(num_chips).sqrt()) 7 | if root * root == num_chips: 8 | print(root - 1) 9 | else: 10 | print(root) 11 | -------------------------------------------------------------------------------- /src/codeforces/gcd.py: -------------------------------------------------------------------------------- 1 | a, b = map(int, raw_input().split()) 2 | # gcd(a, b) = gcd(b, a % b) 3 | 4 | if a == b: 5 | print a 6 | else: 7 | print 1 8 | -------------------------------------------------------------------------------- /src/codeforces/gen.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int a[500100]; 5 | int n, k; 6 | 7 | int main(void) { 8 | scanf("%d %d", &n, &k); 9 | for (int i = 0; i < n; i++) 10 | scanf("%d", a+i); 11 | int steps = 0; 12 | while (true) { 13 | int mn = a[0], mni = 0, mx = a[0], mxi = 0; 14 | for (int i = 1; i < n; i++) { 15 | if (a[i] < mn) { 16 | mn = a[i]; 17 | mni = i; 18 | } 19 | if (a[i] > mx) { 20 | mx = a[i]; 21 | mxi = i; 22 | } 23 | } 24 | if (mn == mx) 25 | break; 26 | else { 27 | steps++; 28 | a[mni]++; 29 | a[mxi]--; 30 | printf("step %d: ", steps); 31 | for (int i = 0; i < n; i++) 32 | printf("%d ", a[i]); 33 | printf("\n"); 34 | } 35 | } 36 | return 0; 37 | } 38 | 39 | 40 | -------------------------------------------------------------------------------- /src/codeforces/grasshopper.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int visited[100100]; 4 | char strip[100100]; 5 | int jump[100100]; 6 | int n; 7 | 8 | int dfs(int u) { 9 | visited[u] = 1; 10 | int nxt; 11 | if (strip[u] == '<') 12 | nxt = u - jump[u]; 13 | else 14 | nxt = u + jump[u]; 15 | if (nxt < 0 || nxt >= n) 16 | return 1; 17 | else { 18 | if (visited[nxt] == 1) 19 | return 0; 20 | else 21 | return dfs(nxt); 22 | } 23 | } 24 | 25 | int main(void) { 26 | scanf("%d", &n); 27 | scanf("%s", strip); 28 | for (int i = 0; i < n; i++) 29 | scanf("%d", jump+i); 30 | int flag = dfs(0); 31 | if (flag == 0) 32 | printf("INFINITE\n"); 33 | else 34 | printf("FINITE\n"); 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /src/codeforces/holiday.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(void) { 5 | int n; 6 | scanf("%d", &n); 7 | int confirm = (n / 7) * 2; 8 | int rem = n % 7; 9 | if (rem == 6) 10 | printf("%d %d\n", confirm + 1, confirm + 2); 11 | else if (rem >= 2) 12 | printf("%d %d\n", confirm, confirm + 2); 13 | else if (rem >= 1) 14 | printf("%d %d\n", confirm, confirm + 1); 15 | else if (rem == 0) 16 | printf("%d %d\n", confirm, confirm); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /src/codeforces/magic.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef unsigned long long int lli; 4 | 5 | 6 | lli n, k; 7 | lli need[100100]; 8 | lli have[100100]; 9 | lli a[100100]; 10 | 11 | int valid(lli val) { 12 | for (int i = 0; i < n; i++) { 13 | a[i] = need[i] * val; 14 | } 15 | lli total = 0; 16 | for (int i = 0; i < n; i++) 17 | if (a[i] > have[i]) { 18 | total += a[i] - have[i]; 19 | if (total > k) 20 | return 1; 21 | } 22 | if (total > k) 23 | return 1; 24 | else 25 | return 0; 26 | } 27 | 28 | int main(void) { 29 | cin >> n >> k; 30 | for (int i = 0; i < n; i++) 31 | cin >> need[i]; 32 | for (int i = 0; i < n; i++) 33 | cin >> have[i]; 34 | lli lo = 0, hi = 1e10; 35 | while (lo < hi) { 36 | lli mid = lo + (hi - lo) / 2; 37 | if (valid(mid)) { 38 | hi = mid; 39 | } 40 | else { 41 | lo = mid + 1; 42 | } 43 | } 44 | cout << (lo - 1) << endl; 45 | return 0; 46 | } 47 | 48 | -------------------------------------------------------------------------------- /src/codeforces/magic.py: -------------------------------------------------------------------------------- 1 | need = [] 2 | have = [] 3 | a = [0 for _ in range(100100)] 4 | n = 0 5 | k = 0 6 | def valid(val): 7 | for i in range(n): 8 | a[i] = need[i] * val 9 | total = 0 10 | for i in range(n): 11 | if a[i] > have[i]: 12 | total += a[i] - have[i] 13 | if total > k: 14 | return 1 15 | else: 16 | return 0 17 | 18 | n, k = map(int, raw_input().split()) 19 | need = map(int, raw_input().split()) 20 | have = map(int, raw_input().split()) 21 | lo = 0 22 | hi = 10**18 23 | while lo < hi: 24 | mid = (lo + hi) / 2 25 | if valid(mid): 26 | hi = mid 27 | else: 28 | lo = mid + 1 29 | print lo-1 30 | -------------------------------------------------------------------------------- /src/codeforces/numbers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int n, k; 5 | scanf("%d %d", &n, &k); 6 | if (n < k) 7 | printf("%d\n", k); 8 | else { 9 | int div = n / k; 10 | printf("%lld\n", (div + 1) * (long long) k); 11 | } 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /src/codeforces/pouring.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define pi 3.14159265358979323846 3 | 4 | int main(void) { 5 | int d, h, v, e; 6 | scanf("%d %d %d %d", &d, &h, &v, &e); 7 | double s = (4 * v) / (pi * d * d); 8 | double ans = (double) (h) / (s - e); 9 | if (ans < 0) 10 | printf("NO\n"); 11 | else 12 | printf("YES\n%lf\n", ans); 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /src/codeforces/presents.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int n; 5 | scanf("%d", &n); 6 | if (n % 3 != 0) 7 | printf("%d", (n / 3) * 2 + 1); 8 | else 9 | printf("%d", (n / 3) * 2); 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /src/codeforces/robin.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long int lli; 4 | 5 | int a[500100]; 6 | int n, k; 7 | 8 | int main(void) { 9 | scanf("%d %d", &n, &k); 10 | for (int i = 0; i < n; i++) 11 | scanf("%d", a+i); 12 | sort(a, a+n); 13 | lli steps = 0; 14 | int mn = a[0], mx = a[n-1]; 15 | int nmn = 1, nmx = n - 2; 16 | lli cmn = 1, cmx = 1; 17 | while (steps < k) { 18 | lli mnd = (a[nmn] - mn) * cmn; 19 | lli mxd = (mx - a[nmd]) * cmx; 20 | if (mnd < mxd) { 21 | mn = a[nmn]; 22 | nmn++; 23 | cmn++; 24 | 25 | 26 | -------------------------------------------------------------------------------- /src/codeforces/robots.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long int lli; 4 | 5 | long long int id[100100]; 6 | 7 | int main(void) { 8 | long long int n; 9 | long long int k; 10 | cin >> n >> k; 11 | for (int i = 1; i <= n; i++) 12 | scanf("%lld", id+i); 13 | lli val; 14 | for (lli i = 1; i <= n; i++) 15 | if (k <= (i * (i + 1) / 2)) { 16 | val = i; 17 | break; 18 | } 19 | k -= (val - 1) * val / 2; 20 | cout << id[k] << endl; 21 | return 0; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /src/codeforces/round 507/one.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | typedef long double ld; 5 | const int inf = 1e9 + 8; 6 | const ll infll = 1e18; 7 | 8 | 9 | int c[10010]; 10 | 11 | int main(void) { 12 | int n, a, b; 13 | scanf("%d %d %d", &n, &a, &b); 14 | for (int i = 1; i <= n; i++) 15 | scanf("%d", &c[i]); 16 | int ans = 0; 17 | for (int i = 1; i <= n; i++) { 18 | if (c[i] != 2 && c[n - i + 1] != 2 && c[i] != c[n - i +1]) { 19 | printf("-1\n"); 20 | return 0; 21 | } 22 | if (c[i] == 2) { 23 | if (c[n - i + 1] == 2) { 24 | ans += min(a, b); 25 | if (n - i + 1 != i) 26 | ans += min(a, b); 27 | c[i] = c[n - i + 1] = 1; 28 | } 29 | else if (c[n - i + 1] == 1) { 30 | ans += b; 31 | c[i] = 1; 32 | } 33 | else { 34 | ans += a; 35 | c[i] = 0; 36 | } 37 | } 38 | } 39 | printf("%d\n", ans); 40 | return 0; 41 | } 42 | 43 | -------------------------------------------------------------------------------- /src/codeforces/round 507/two.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | typedef long double ld; 5 | const int inf = 1e9 + 8; 6 | const ll infll = 1e18; 7 | 8 | 9 | int main(void) { 10 | int n, k; 11 | scanf("%d %d", &n, &k); 12 | int once = 2 * k + 1; 13 | vector ans; 14 | int start = 1, end = n; 15 | int rem = n; 16 | if (n % once != 0) { 17 | int extra = n % once; 18 | int left = extra - (k + 1); 19 | if (left > 0) 20 | start += left; 21 | ans.push_back(start); 22 | rem -= extra; 23 | start += k + 1; 24 | } 25 | int cur = start + k; 26 | while (rem > 0 && cur <= n) { 27 | ans.push_back(cur); 28 | cur += k + k + 1; 29 | rem -= once; 30 | } 31 | printf("%d\n",(int) ans.size()); 32 | for (int i = 0; i < ans.size(); i++) 33 | printf("%d ", ans[i]); 34 | printf("\n"); 35 | return 0; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /src/codeforces/round 508/four.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | typedef long double ld; 5 | const int inf = 1e9 + 8; 6 | const ll infll = 1e18; 7 | 8 | 9 | int n; 10 | ll a[500100]; 11 | 12 | int main(void) { 13 | scanf("%d", &n); 14 | ll sum = 0; 15 | for (int i = 1; i <= n; i++) { 16 | scanf("%lld", &a[i]); 17 | sum += abs(a[i]); 18 | } 19 | if (n == 1) { 20 | printf("%lld\n", a[1]); 21 | return 0; 22 | } 23 | if (n == 2) { 24 | printf("%lld\n", max(a[1] - a[2], a[2] - a[1])); 25 | return 0; 26 | } 27 | ll mn = infll; 28 | int id; 29 | for (int i = 1; i < n; i++) { 30 | ll small = min(a[i], a[i + 1]); 31 | ll big = max(a[i], a[i + 1]); 32 | ll loss = abs(small) + abs(big) - abs(small - big); 33 | if (mn > loss) { 34 | id = i; 35 | mn = loss; 36 | } 37 | } 38 | printf("%lld\n", sum - mn); 39 | return 0; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /src/codeforces/round 508/one.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | typedef long double ld; 5 | const int inf = 1e9 + 8; 6 | const ll infll = 1e18; 7 | 8 | 9 | char s[100100]; 10 | int freq[30]; 11 | 12 | int main(void) { 13 | int n, k; 14 | scanf("%d %d", &n, &k); 15 | scanf("%s", s); 16 | for (int i = 0; i < n; i++) { 17 | freq[s[i] - 'A']++; 18 | } 19 | int mn = n + 1; 20 | for (int i = 0; i < k; i++) { 21 | mn = min(mn, freq[i]); 22 | } 23 | printf("%d\n", k * mn); 24 | return 0; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /src/codeforces/round 508/two.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | typedef long double ld; 5 | const int inf = 1e9 + 8; 6 | const ll infll = 1e18; 7 | 8 | 9 | 10 | int main(void) { 11 | int n; 12 | scanf("%d", &n); 13 | if (n == 1 || n == 2) { 14 | printf("No\n"); 15 | return 0; 16 | } 17 | else { 18 | printf("Yes\n"); 19 | printf("1 %d\n", n); 20 | printf("%d ", n - 1); 21 | for (int i = 1; i < n; i++) 22 | printf("%d ", i); 23 | printf("\n"); 24 | return 0; 25 | } 26 | } 27 | 28 | -------------------------------------------------------------------------------- /src/codeforces/round858/one.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | var t int 9 | fmt.Scanf("%d\n", &t) 10 | for t > 0 { 11 | t-- 12 | var a, b, c, d int 13 | fmt.Scanf("%d %d %d %d\n", &a, &b, &c, &d) 14 | if b > d { 15 | fmt.Println("-1") 16 | continue 17 | } 18 | diff := d - b 19 | a += diff 20 | b = d 21 | 22 | if a < c { 23 | fmt.Println("-1") 24 | continue 25 | } else { 26 | fmt.Printf("%d\n", diff+(a-c)) 27 | continue 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/codesprint/dist.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | vector pos[100010]; 5 | 6 | int main(void) { 7 | int n; 8 | scanf("%d", &n); 9 | int mx = -1; 10 | for (int i = 0; i < n; i++) { 11 | int x; 12 | scanf("%d", &x); 13 | pos[x].push_back(i); 14 | mx = max(x, mx); 15 | } 16 | int mn = 10000; 17 | for (int i = 0; i <= mx; i++) { 18 | if (!pos[i].empty()) { 19 | sort(pos[i].begin(), pos[i].end()); 20 | for (int j = 0; j < pos[i].size() - 1; j++) 21 | mn = min(pos[i][j + 1] - pos[i][j], mn); 22 | } 23 | } 24 | printf("%d\n", mn == 10000 ? -1 : mn); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /src/cookoff/cook63/asp.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int t; 5 | scanf("%d", &t); 6 | while (t--) { 7 | int n; 8 | scanf("%d", &n); 9 | int a[n]; 10 | int i; 11 | for (i = 0; i < n; i++) { 12 | scanf("%d", a+i); 13 | } 14 | int flag = 0; 15 | for (i = 1; i < n; i++) { 16 | int d = i; 17 | int c = 0; 18 | while (d > 0 && a[d] < a[d-1]) { 19 | int t = a[d]; 20 | a[d] = a[d-1]; 21 | a[d-1] = t; 22 | d--; 23 | c++; 24 | if (c > 1) { 25 | flag = 1; 26 | break; 27 | } 28 | } 29 | if (flag == 1) 30 | break; 31 | } 32 | if (flag == 1) 33 | printf("NO\n"); 34 | else 35 | printf("YES\n"); 36 | } 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /src/cookoff/cook63/stem.py: -------------------------------------------------------------------------------- 1 | t = int(raw_input()) 2 | for _ in range(t): 3 | n = int(raw_input()) 4 | w = raw_input().split() 5 | x = w.pop(0) 6 | l = len(x) 7 | ans = "" 8 | for i in range(l): 9 | for j in range(i, l+1): 10 | common = True 11 | sub = x[i:j] 12 | for string in w: 13 | if sub not in string: 14 | common = False 15 | break 16 | if common: 17 | if len(sub) > len(ans) or (len(sub) == len(ans) and ans > sub): 18 | ans = sub 19 | print ans 20 | -------------------------------------------------------------------------------- /src/cookoff/cook74/one.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | int main(void) { 6 | int t; 7 | scanf("%d", &t); 8 | while (t--) { 9 | ll n, b, m; 10 | scanf("%lld %lld %lld", &n, &b, &m); 11 | ll cnt = 0; 12 | while (n > 0) { 13 | ll solve = n / 2; 14 | if (n % 2 != 0) 15 | solve++; 16 | cnt += solve * m + b; 17 | n /= 2; 18 | m *= 2; 19 | } 20 | printf("%lld\n", cnt - b); 21 | } 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /src/hacker cup/qualifier/lazyloading.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int a[200]; 5 | 6 | int main(void) { 7 | int t; 8 | scanf("%d", &t); 9 | for (int test = 1; test <= t; test++) { 10 | int n; 11 | scanf("%d", &n); 12 | for (int i = 1; i <= n; i++) 13 | scanf("%d", &a[i]); 14 | sort(a + 1, a + 1 + n); 15 | int nxt = 1; 16 | int ans = 0; 17 | for (int i = n; i >= nxt; i--) { 18 | int total = a[i]; 19 | while (total < 50 && nxt < i) { 20 | total += a[i]; 21 | nxt++; 22 | } 23 | if (total >= 50) 24 | ans++; 25 | } 26 | printf("Case #%d: %d\n", test, ans); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/hacker cup/round1/progresspie.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | const ll inf = 1e18; 5 | 6 | int cost[310][310]; 7 | int p[310]; 8 | int n, m; 9 | 10 | int main(void) { 11 | int t; 12 | scanf("%d", &t); 13 | for (int c = 1; c <= t; c++) { 14 | scanf("%d %d", &n, &m); 15 | for (int i = 1; i <= n; i++) { 16 | p[i] = 1; 17 | for (int j = 1; j <= m; j++) 18 | scanf("%d", &cost[i][j]); 19 | sort(cost[i] + 1, cost[i] + 1 + m); 20 | } 21 | ll ans = 0; 22 | for (int day = 1; day <= n; day++) { 23 | ll mn = inf, use = -1; 24 | for (int i = 1; i <= day; i++) { 25 | if (p[i] > m) continue; 26 | ll add = cost[i][p[i]] + 2 * p[i] - 1; 27 | if (mn > add) { 28 | mn = add; 29 | use = i; 30 | } 31 | } 32 | ans += mn; 33 | p[use]++; 34 | } 35 | printf("Case #%d: %lld\n", c, ans); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/hourrank/counter.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long lli; 4 | 5 | int main(void) { 6 | lli t; 7 | scanf("%lld", &t); 8 | int lo = 1, hi = 50; 9 | while (lo < hi) { 10 | int mid = (lo + hi) / 2; 11 | lli t1 = 3 * ((1LL << mid) - 1); 12 | if (t1 < t) 13 | lo = mid + 1; 14 | else 15 | hi = mid; 16 | } 17 | 18 | lli t1 = 3 * ((1LL << lo) - 1); 19 | printf("%lld\n", t1 - t + 1); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /src/long/april15/brokphon.hs: -------------------------------------------------------------------------------- 1 | import Data.List 2 | import Control.Monad 3 | import qualified Data.ByteString.Char8 as B 4 | 5 | numWrongs :: (Eq a) => [a] -> Int 6 | numWrongs [] = 0 7 | numWrongs lst = let groups = map length $ group lst 8 | x = foldl' (\x y -> if y == 1 then (x+1) else (x+2)) 0 groups 9 | in if length groups == 1 10 | then 0 11 | else if last groups /= 1 12 | then if head groups /= 1 then (x-2) else (x-1) 13 | else if head groups /= 1 then (x-1) else x 14 | 15 | 16 | secondIO :: IO () 17 | secondIO = do 18 | B.getLine 19 | str <- B.getLine 20 | print $ numWrongs (b2ints str) 21 | return () 22 | 23 | main :: IO () 24 | main = readLn >>= flip replicateM_ secondIO 25 | 26 | b2ints :: B.ByteString -> [Int] 27 | b2ints = unfoldr (B.readInt . B.dropWhile (==' ')) 28 | -------------------------------------------------------------------------------- /src/long/april15/cseq.hs: -------------------------------------------------------------------------------- 1 | import Control.Monad 2 | import Data.List 3 | import qualified Data.ByteString.Char8 as B 4 | 5 | big = 10^6 + 3 6 | 7 | -- Brute force method 8 | ans :: Int -> Integer -> Integer -> Integer 9 | ans n l r = (sum . concat . (take n) $ requiredlst l r) `mod` big 10 | 11 | requiredlst l r = [r - l + 1] : iterate generate [1 .. (r-l+1)] 12 | where generate lst = 1 : zipWith (+) (tail lst) (generate lst) 13 | 14 | 15 | -- Slightly more optimised 16 | -- or maybe not 17 | facts' = 1 : 1 : 2 : zipWith (\x y -> ((x `mod` big) * (y `mod` big)) `mod` big) (drop 2 facts) [3..] 18 | 19 | facts = 1 : 1 : 2 : zipWith (*) (drop 2 facts) [3..] 20 | 21 | -- inverse x % p = (x ^ p - 2) % p 22 | 23 | fact n = foldl (*) 1 [2..n] 24 | 25 | -- ib = inverse' big 26 | mb = (\x -> x `mod` big) 27 | 28 | n `c` r = (fact n) `div` ((fact (n-r)) * (fact r)) 29 | 30 | anotherList l r = zipWith (c) [(r-l+1) .. ] [1..] 31 | 32 | ans' n l r = (sum . (take n) $ anotherList l r) `mod` big 33 | 34 | main = readLn >>= flip replicateM_ secondIO 35 | 36 | secondIO = do 37 | str <- getLine 38 | let n = read . head $ words str 39 | let [l,r] = (map read) . tail $ words str 40 | print $ ans' n l r 41 | -------------------------------------------------------------------------------- /src/long/april15/piano.hs: -------------------------------------------------------------------------------- 1 | import Control.Monad 2 | 3 | sumN n = (n * (n+1)) `div` 2 4 | 5 | numberOfCombinations step num = foldl (+) 0 $ map (sumN . rep) [1..step] 6 | where rep x = (num - x) `div` step 7 | 8 | findStep str = foldl (\acc ch -> if ch == 'T' then (acc+2) else (acc+1)) 0 str 9 | 10 | ans str octaves = numberOfCombinations (findStep str) (octaves * 12) 11 | 12 | main = readLn >>= flip replicateM_ secondIO 13 | 14 | secondIO = do 15 | str <- getLine 16 | octaves <- readLn 17 | print $ ans str octaves 18 | -------------------------------------------------------------------------------- /src/long/april15/primefac.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | class PrimeFac 3 | { 4 | public static void main(String[] args) 5 | { 6 | Scanner in = new Scanner( System.in ); 7 | int terms = in.nextInt(); 8 | for(int q = 0; q1) 26 | prod*=1+n; 27 | return prod; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/long/april16/balloons.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(void) { 5 | int t; 6 | scanf("%d", &t); 7 | while (t--) { 8 | long long int r, g, b, k; 9 | scanf("%lld %lld %lld", &r, &g, &b); 10 | scanf("%lld", &k); 11 | long long int ans = 0; 12 | ans += min(r, k-1) + min(g, k-1) + min(b, k-1); 13 | ans++; 14 | printf("%lld\n", ans); 15 | } 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /src/long/april16/color.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(void) { 5 | int t; 6 | scanf("%d", &t); 7 | while (t--) { 8 | int n; 9 | scanf("%d", &n); 10 | char *s = (char*) calloc(n+10, sizeof(char)); 11 | scanf("%s", s); 12 | int r = 0, g = 0, b = 0; 13 | for (int i = 0; i < n; i++) { 14 | if (s[i] == 'R') 15 | r++; 16 | else if (s[i] == 'G') 17 | g++; 18 | else if (s[i] == 'B') 19 | b++; 20 | } 21 | int ans = max(max(r, g), b); 22 | ans = n - ans; 23 | printf("%d\n", ans); 24 | free(s); 25 | } 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /src/long/april16/magic.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(void) { 5 | int t; 6 | scanf("%d", &t); 7 | while (t--) { 8 | long long int a, b; 9 | scanf("%lld %lld", &a, &b); 10 | if (a == 1 && b == 2) 11 | printf("Yes"); 12 | else if (a == 2 && b == 1) 13 | printf("Yes"); 14 | else if (a == 1 || b == 1) 15 | printf("No"); 16 | else if (a == 2 || b == 2) 17 | printf("Yes"); 18 | else if (a % 2 == 0 || b % 2 == 0) 19 | printf("Yes"); 20 | else 21 | printf("No"); 22 | printf("\n"); 23 | } 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /src/long/april16/watson.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MOD 1000000007 3 | using namespace std; 4 | 5 | int power(int a, int b) { 6 | if (b == 0) 7 | return 1; 8 | if (b == 1) 9 | return a; 10 | if (b % 2 == 0) { 11 | int x = power(a, b/2); 12 | x = ((long long)x * x) % MOD; 13 | return x; 14 | } 15 | else { 16 | int x = power(a, (b-1)/2); 17 | x = ((long long)x * x) % MOD; 18 | x = ((long long)x * a) % MOD; 19 | return x; 20 | } 21 | } 22 | 23 | int main(void) { 24 | int t; 25 | scanf("%d", &t); 26 | while (t--) { 27 | int n, k; 28 | scanf("%d %d", &n, &k); 29 | int ans = power(k-1, n-1); 30 | ans = (ans * (long long)k) % MOD; 31 | printf("%d\n", ans); 32 | } 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /src/long/aug15/cookmach.py: -------------------------------------------------------------------------------- 1 | # Author: Param Singh 2 | import math 3 | 4 | def power_of_two(a): 5 | x = math.log(a, 2) 6 | return x == math.ceil(x) 7 | 8 | terms = int(raw_input()) 9 | for _ in range(terms): 10 | a, b = map(int, raw_input().split()) 11 | count = 0 12 | while not power_of_two(a) and a != 1: 13 | a /= 2 14 | count += 1 15 | while a != b: 16 | if a > b: 17 | a /= 2; 18 | else: 19 | a *= 2 20 | count += 1 21 | print count 22 | 23 | 24 | -------------------------------------------------------------------------------- /src/long/aug16/chchcl.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int t; 5 | scanf("%d", &t); 6 | while (t--) { 7 | int m, n; 8 | scanf("%d %d", &m, &n); 9 | if (m % 2 == 0 || n % 2 == 0) 10 | printf("Yes\n"); 11 | else 12 | printf("No\n"); 13 | } 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /src/long/aug16/chefrrun.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int done[100100]; 5 | int depth[100100]; 6 | int a[100100]; 7 | int n; 8 | int cmp; 9 | int ans; 10 | 11 | void dfs(int u, int d) { 12 | done[u] = cmp; 13 | depth[u] = d; 14 | int nxt = (u + a[u] + 1) % n; 15 | if (done[nxt] == 0) 16 | dfs(nxt, d + 1); 17 | else if (done[nxt] != cmp) 18 | return; 19 | else 20 | ans += d - depth[nxt] + 1; 21 | } 22 | 23 | int main(void) { 24 | int t; 25 | scanf("%d", &t); 26 | while (t--) { 27 | scanf("%d", &n); 28 | for (int i = 0; i < n; i++) { 29 | scanf("%d", a+i); 30 | done[i] = 0; 31 | } 32 | ans = 0; 33 | cmp = 0; 34 | for (int i = 0; i < n; i++) { 35 | if (done[i] == 0) { 36 | cmp++; 37 | dfs(i, 0); 38 | } 39 | } 40 | printf("%d\n", ans); 41 | } 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /src/long/aug16/goodprob.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | int a[100100]; 6 | long long ans = 0; 7 | 8 | int main(void) { 9 | int n; 10 | scanf("%d", &n); 11 | for (int i = 0; i < n; i++) 12 | scanf("%d", &a[i]); 13 | 14 | for (int i = 0; i < n; i++) { 15 | int mx = a[i]; 16 | for (int j = i + 1; j < n; j++) { 17 | mx = max(mx, a[j]); 18 | if ((a[i] & a[j]) == a[i]) 19 | ans += mx; 20 | else if ((a[i] & a[j]) == a[j]) 21 | ans += mx; 22 | } 23 | } 24 | printf("%lld\n", ans); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /src/long/jun15/cbarg.hs: -------------------------------------------------------------------------------- 1 | -- so the amount of memory deallocated should be easy enough to do 2 | 3 | -- INPUT 4 | import Control.Monad 5 | import Data.List 6 | 7 | b2ints :: B.ByteString -> [Int] 8 | b2ints = unfoldr (B.readInt . B.dropWhile (== ' ')) 9 | 10 | 11 | main :: IO () 12 | main = readLn >>= flip replicateM_ secondIO 13 | 14 | 15 | secondIO :: IO () 16 | secondIO = do 17 | B.getLine 18 | str <- B.getLine 19 | let list = b2ints str 20 | print . fst $ ans list 21 | 22 | 23 | -- Computation 24 | ans list = foldr (\x y -> if x > (snd y) then ((fst y) + x - (snd y), x) else (fst y, x)) (0, 0) list 25 | -------------------------------------------------------------------------------- /src/long/jun15/cbarg.py: -------------------------------------------------------------------------------- 1 | n = int(raw_input()) 2 | for _ in range(n): 3 | raw_input() 4 | lst = map(int, raw_input().split()) 5 | prev = 0 6 | alloc = 0 7 | for x in lst: 8 | if x > prev: 9 | alloc += x - prev 10 | prev = x 11 | print alloc 12 | -------------------------------------------------------------------------------- /src/long/jun15/polygons.py: -------------------------------------------------------------------------------- 1 | # initial (probably really slow) code 2 | # let's hope python's sorting algorithm is fast enough for codechef 3 | # it's probably not :( 4 | 5 | import sys 6 | sysmin = - sys.maxint - 1 7 | 8 | def create_rect(coords): 9 | coords = map(int, coords.split()) 10 | maxx, maxy = sysmin, sysmin 11 | for i, x in enumerate(coords): 12 | if i % 2 == 0: 13 | if maxx < x: 14 | maxx = x 15 | else: 16 | if maxy < x: 17 | maxy = x 18 | 19 | return (maxx, maxy) 20 | 21 | 22 | def is_inside(a, b): 23 | xa, ya = a 24 | xb, yb = b 25 | if xa <= xb and ya <= yb: 26 | return -1 27 | else: 28 | return 1 29 | 30 | 31 | cases = int(raw_input()) 32 | for case in range(cases): 33 | polygons = int(raw_input()) 34 | lst = [] 35 | for x in range(polygons): 36 | raw_input() 37 | coords = raw_input() 38 | rep = create_rect(coords) 39 | lst.append(rep) 40 | 41 | dup = lst[:] 42 | lst = sorted(lst, cmp = is_inside) 43 | print ' '.join(map(lambda x: str(lst.index(x)), dup)) 44 | -------------------------------------------------------------------------------- /src/long/jun15/steady.py: -------------------------------------------------------------------------------- 1 | # test submission, please ignore 2 | 3 | cases = int(raw_input()) 4 | 5 | def choose(n, r): 6 | 7 | def fact(n): 8 | ans = 1 9 | for x in range(1, n+1): 10 | ans *= x 11 | return ans 12 | 13 | return fact(n) / (fact(n-r) * fact(r)) 14 | 15 | for _ in range(cases): 16 | n, m = map(int, raw_input().split()) 17 | req, sums = [], [] 18 | for i in range(m+1): 19 | req.append(choose(m+i-1, i)) 20 | sums = req[:] 21 | for i in range(n-1): 22 | ans = 0 23 | for index, x in enumerate(sums): 24 | ans += x 25 | sums[index] = req[index] * ans 26 | print sum(sums) % 1000000000 27 | 28 | 29 | -------------------------------------------------------------------------------- /src/long/jun16/chcoinsg.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | // all numbers that are powers of prime are winning positions 5 | // the first losing number is 6 because no matter what Chef removes 6 | // Misha will remove the remaining and Chef will lose 7 | // Since 1 2 3 4 5 are winning positions, any number that is not a multiple 8 | // of 6 can be reduced to a multiple of 6 9 | // therefore all multiples of 6 are losing positions 10 | // qed :) 11 | 12 | // P.S: I've done this myself, but the code might be similar to some other 13 | // code because it is very simple and thousands of people may have written 14 | // something like this. Please don't assume I'm cheating. :) 15 | 16 | int main(void) { 17 | int t; 18 | scanf("%d", &t); 19 | while (t--) { 20 | int n; 21 | scanf("%d", &n); 22 | if (n % 6 == 0) 23 | printf("Misha\n"); 24 | else 25 | printf("Chef\n"); 26 | } 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /src/long/jun16/chearmy.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char s[100100]; 5 | int main(void) { 6 | int t; 7 | scanf("%d", &t); 8 | while (t--) { 9 | long long int k; 10 | scanf("%lld", &k); 11 | k--; 12 | int l = 0; 13 | if (k == 0) 14 | s[l++] = '0'; 15 | while (k != 0) { 16 | int digit = k % 5; 17 | s[l++] = digit * 2 + '0'; 18 | k /= 5; 19 | } 20 | for (int i = l - 1; i >= 0; i--) 21 | printf("%c", s[i]); 22 | printf("\n"); 23 | } 24 | return 0; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /src/long/jun16/devarray.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int a[100010]; 5 | 6 | int main(void) { 7 | int n, q, t; 8 | scanf("%d %d", &n, &q); 9 | int mn = INT_MAX, mx = INT_MIN; 10 | for (int i = 1; i <= n; i++) { 11 | scanf("%d", a+i); 12 | mn = min(a[i], mn); 13 | mx = max(a[i], mx); 14 | } 15 | 16 | while (q--) { 17 | scanf("%d", &t); 18 | if (mn <= t && t <= mx) 19 | printf("Yes\n"); 20 | else 21 | printf("No\n"); 22 | } 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /src/long/march15/cnote.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main (void){ 3 | int terms; 4 | scanf("%d", &terms); 5 | while(terms--){ 6 | int x, y, k, n; 7 | scanf("%d%d%d%d", &x, &y, &k, &n); 8 | int req_pages = x - y; 9 | int i, flag = 0; 10 | for(i=1;i<=n;i++){ 11 | int pi, ci; 12 | scanf("%d%d", &pi, &ci); 13 | if( pi>=req_pages && ci<=k ) 14 | flag = 1; 15 | } 16 | if(flag) 17 | printf("LuckyChef\n"); 18 | else 19 | printf("UnluckyChef\n"); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/long/march15/cnote.py: -------------------------------------------------------------------------------- 1 | # http://www.codechef.com/MARCH15/problems/CNOTE 2 | 3 | for terms in range(int(raw_input())): 4 | x, y, k, n = map(int, raw_input().split()) 5 | req_pages = x - y 6 | flag = False 7 | for i in range(n): 8 | pi, ci = map(int, raw_input().split()) 9 | if pi >= req_pages and ci <= k: 10 | flag = True 11 | if flag: 12 | print "LuckyChef" 13 | else: 14 | print "UnluckyChef" 15 | -------------------------------------------------------------------------------- /src/long/march15/qchef.py: -------------------------------------------------------------------------------- 1 | n, m, k = map(int, raw_input().split()) 2 | a = map(int, raw_input().split()) 3 | same_growth = [] 4 | for index, num in enumerate(a): 5 | for j in range(index+1, n): 6 | if a[j] == num: 7 | same_growth.append((index+1, j+1)) 8 | for term in range(k): 9 | li, ri = map(int, raw_input().split()) 10 | max_diff = 0 11 | for pair in same_growth: 12 | if li <= pair[0] <= ri and li <= pair[1] <= ri: 13 | diff = abs(pair[0]-pair[1]) 14 | if diff > max_diff: 15 | max_diff = diff 16 | print max_diff 17 | -------------------------------------------------------------------------------- /src/long/may15/chefrp.hs: -------------------------------------------------------------------------------- 1 | import Control.Monad 2 | import Data.List 3 | import qualified Data.ByteString.Char8 as B 4 | 5 | f lst = if (1 `elem` lst) 6 | then Nothing 7 | else Just ((sum lst) - (minimum lst) + 2) 8 | 9 | main = readLn >>= flip replicateM_ secondIO 10 | 11 | secondIO = do 12 | B.getLine 13 | str <- B.getLine 14 | case (f $ b2ints str) of 15 | Nothing -> putStrLn "-1" 16 | Just x -> print x 17 | 18 | b2ints :: B.ByteString -> [Int] 19 | b2ints = unfoldr (B.readInt . B.dropWhile (==' ')) 20 | -------------------------------------------------------------------------------- /src/long/nov15/cakes.c: -------------------------------------------------------------------------------- 1 | // Author: Param Singh 2 | // EGRCAKE : http://www.codechef.com/NOV15/problems/EGRCAKE 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | long long int gcd(long long int a, long long int b) { 10 | int t; 11 | while (b != 0) { 12 | t = b; 13 | b = a % b; 14 | a = t; 15 | } 16 | return a; 17 | } 18 | 19 | int main(void) { 20 | int t; 21 | scanf("%d", &t); 22 | long long int k, n, m, h, p; 23 | while (t--) { 24 | scanf("%lld %lld", &n, &m); 25 | if (m == 0) { 26 | if (n != 1) 27 | printf("No 1\n"); 28 | else 29 | printf("Yes\n"); 30 | } 31 | else { 32 | h = gcd(n, m); 33 | p = m / h; 34 | k = (p * n) / m; 35 | if (k < n) 36 | printf("No %lld\n", k); 37 | else 38 | printf("Yes\n"); 39 | } 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /src/long/nov15/kfunc.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(void) { 5 | int t; 6 | scanf("%d", &t); 7 | long long int a, d, l, beg, terms; 8 | long long int n, q, r, ans, dup, z, count, sum, x; 9 | int i; 10 | while (t--) { 11 | ans = 0; 12 | scanf("%lld %lld %lld %lld", &a, &d, &l, &r); 13 | beg = a + (l-1) * d; 14 | dup = beg; 15 | terms = r - l + 1; 16 | int *flag = (int *) calloc(10, sizeof(int)); 17 | count = 0; 18 | sum = 0; 19 | while (1) { 20 | x = 1 + ((beg - 1) % 9); 21 | if (flag[x] == 1) 22 | break; 23 | else { 24 | sum += x; 25 | count++; 26 | flag[x] = 1; 27 | beg += d; 28 | } 29 | } 30 | q = terms / count; 31 | z = terms % count; 32 | ans += (q * sum); 33 | while (z--) { 34 | x = 1 + ((dup - 1) % 9); 35 | ans += x; 36 | dup += d; 37 | } 38 | printf("%lld\n", ans); 39 | } 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /src/long/nov15/kfunc.py: -------------------------------------------------------------------------------- 1 | t = int(raw_input()) 2 | for _ in range(t): 3 | ans = 0 4 | a, d, l, r = map(int, raw_input().split()) 5 | beg = a + (l-1)*d 6 | dup = beg 7 | terms = r - l + 1 8 | flag = [False for _ in range(10)] 9 | count = 0 10 | s = 0 11 | while True: 12 | x = 1 + ((beg - 1) % 9) 13 | if flag[x]: 14 | break 15 | else: 16 | s += x 17 | count += 1 18 | flag[x] = True 19 | beg += d 20 | q = terms / count 21 | z = terms % count 22 | ans += (q * s) 23 | for _ in range(z): 24 | x = 1 + ((dup - 1) % 9) 25 | ans += x 26 | dup += d 27 | print ans 28 | -------------------------------------------------------------------------------- /src/long/oct15/hypotenuse.c: -------------------------------------------------------------------------------- 1 | // Author: Param Singh 2 | // Equilateral Triangles: https://www.codechef.com/OCT15/problems/ADTRI 3 | 4 | #include 5 | #include 6 | int main(void) { 7 | int* arr = (int *) calloc(5000001, 4); 8 | int i; 9 | int count = 0; 10 | int flag; 11 | for (i = 1; i < 5000001; i++) { 12 | if (arr[i] == 0) { 13 | if ((i+1) % 4 == 1) { 14 | flag = 2; 15 | } 16 | else 17 | flag = 1; 18 | int num = i+1; 19 | int x = 1; 20 | while (num < 5000001) { 21 | if (arr[num-1] != 2) 22 | arr[num-1] = flag; 23 | num = num + i + 1; 24 | } 25 | } 26 | } 27 | int t; 28 | scanf("%d", &t); 29 | int a; 30 | count = 0; 31 | for (a = 1; a <= t; a++) { 32 | int n; 33 | scanf("%d", &n); 34 | if (arr[n-1] == 2) 35 | printf("YES\n"); 36 | else 37 | printf("NO\n"); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/long/oct15/subinc.c: -------------------------------------------------------------------------------- 1 | // Author: Param Singh 2 | // Count Subarrays: https://www.codechef.com/OCT15/problems/SUBINC 3 | 4 | #include 5 | int main(void) { 6 | int t; 7 | scanf("%d", &t); 8 | int a; 9 | for (a = 0; a < t; a++) { 10 | int n; 11 | scanf("%d", &n); 12 | int i; 13 | long long int x, count = 1, ans = 0, prev; 14 | scanf("%lld", &prev); 15 | for (i = 1; i < n; i++) { 16 | scanf("%lld", &x); 17 | if (x >= prev) { 18 | count++; 19 | } 20 | else { 21 | ans += count * (count + 1) / 2; 22 | count = 1; 23 | } 24 | prev = x; 25 | } 26 | ans += count * (count + 1) / 2; 27 | printf("%lld\n", ans); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/long/oct15/timeasr.py: -------------------------------------------------------------------------------- 1 | # Author: Param Singh 2 | # Time Measure: https://www.codechef.com/OCT15/problems/TIMEASR 3 | from math import floor 4 | t = int(raw_input()) 5 | for _ in range(t): 6 | a = float(raw_input()) 7 | for x in range(12): 8 | y1 = 2.0 * (30*x - a) / 11.0 9 | y2 = 2.0 * (30*x + a) / 11.0 10 | y3 = 2.0 * (30*x - 360 + a) / 11.0 11 | y4 = 2.0 * (30*x + 360 - a) / 11.0 12 | fy1 = round(y1) 13 | fy2 = round(y2) 14 | fy3 = round(y3) 15 | fy4 = round(y4) 16 | a1 = (30*x - 5.5*fy1) 17 | a2 = -(30*x - 5.5*fy2) 18 | a3 = 360 - (30*x - 5.5*fy3) 19 | a4 = 360 + (30*x - 5.5*fy4) 20 | eps = 1 / 120.0 21 | if abs(a-a1) <= eps and 0 <= fy1 < 60: 22 | print "%02d:%02d" % (x, fy1) 23 | if a1 == 0 or a1 == 180: 24 | continue 25 | if abs(a-a2) <= eps and 0 <= fy2 < 60: 26 | print "%02d:%02d" % (x, fy2) 27 | if a2 == 0 or a2 == 180: 28 | continue 29 | if abs(a-a3) <= eps and 0 <= fy3 < 60: 30 | print "%02d:%02d" % (x, fy3) 31 | if abs(a - a4) <= eps and 0 <= fy4 < 60: 32 | print "%02d:%02d" % (x, fy4) 33 | -------------------------------------------------------------------------------- /src/long/oct15/wdtbam.py: -------------------------------------------------------------------------------- 1 | # Author: Param Singh 2 | # Who dares to be a millionaire: https://www.codechef.com/OCT15/problems/WDTBAM 3 | 4 | t = int(raw_input()) 5 | for _ in range(t): 6 | n = int(raw_input()) 7 | correct = raw_input() 8 | chef = raw_input() 9 | winnings = map(int, raw_input().split()) 10 | ca = 0 11 | wa = 0 12 | for c, ch in zip(correct, chef): 13 | if c == ch: 14 | ca += 1 15 | else: 16 | wa += 1 17 | 18 | if wa != 0: 19 | print max(winnings[0:ca+1]) 20 | else: 21 | print winnings[n] 22 | -------------------------------------------------------------------------------- /src/long/sep15/input: -------------------------------------------------------------------------------- 1 | 2 2 | 5 3 | 0 0 4 | 1 0 5 | 2 0 6 | 0 -1 7 | 0 -2 8 | 4 9 | 5 0 10 | -5 0 11 | 0 5 12 | 0 -5 13 | -------------------------------------------------------------------------------- /src/long/sep15/question1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct position { 5 | int x, y; 6 | }; 7 | 8 | int main(void) { 9 | int t; 10 | scanf("%d", &t); 11 | int i; 12 | for (i = 0; i < t; i++) { 13 | int n, sum = 0; 14 | scanf("%d", &n); 15 | struct position arr[n*n+1]; 16 | int j, k; 17 | for (j = 0; j < n; j++) { 18 | for (k = 0; k < n; k++) { 19 | int a; 20 | scanf("%d", &a); 21 | arr[a].x = j; 22 | arr[a].y = k; 23 | } 24 | } 25 | for (j = 2; j <= n*n; j++) { 26 | sum += fabs(arr[j].x - arr[j-1].x) + fabs(arr[j].y - arr[j-1].y); 27 | } 28 | printf("%d\n", sum); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/long/sep15/question3.py: -------------------------------------------------------------------------------- 1 | # Bank Robbery 2 | # Author: Param Singh 3 | 4 | t = int(raw_input()) 5 | mil = 1000000000.0 6 | for _ in range(t): 7 | x = raw_input().split() 8 | m = int(x[0]) 9 | p = float(x[1]) 10 | if p != 1.0: 11 | c = mil * (1 - (-p)**m) / (1+p) 12 | t = mil - c 13 | print c, t 14 | else: 15 | if m % 2 == 1: 16 | print mil, mil - mil 17 | else: 18 | print mil - mil, mil 19 | -------------------------------------------------------------------------------- /src/long/sep15/question5.py: -------------------------------------------------------------------------------- 1 | # Author: Param Singh 2 | # Cracking the code 3 | 4 | i, k, s = map(int, raw_input().split()) 5 | ai, bi = map(int, raw_input().split()) 6 | diff = k - i 7 | v = diff / 2 8 | if diff % 2 == 0: 9 | val = (2 ** (4*v-s)) * (ai + bi) 10 | else: 11 | val = (2 ** (4*v - s + 1.5) * (ai + (3 ** 0.5) * bi)) 12 | print "%f" % val 13 | -------------------------------------------------------------------------------- /src/long/sept16/nine.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | struct edge { 5 | int u, v, w; 6 | edge(int a, int b, int c) { 7 | u = a, v = b, w = c; 8 | } 9 | }; 10 | vector edges; 11 | vector cuts; 12 | 13 | int main(void) { 14 | int n, m, k; 15 | scanf("%d %d %d", &n, &m, &k); 16 | int s, t; 17 | scanf("%d %d", &s, &t); 18 | s--, t--; 19 | for (int i = 0; i < m; i++) { 20 | int u, v, w; 21 | scanf("%d %d %d", &u, &v, &w); 22 | u--, v--; 23 | edges.push_back(edge(u, v, w)); 24 | } 25 | for (int i = 0; i < (1 << n); i++) { 26 | if (((i >> s) & 1) == 0) 27 | continue; 28 | if ((i >> t) & 1) 29 | continue; 30 | int ans = 0; 31 | for (int j = 0; j < edges.size(); j++) { 32 | int u = edges[j].u, v = edges[j].v, w = edges[j].w; 33 | if (((i >> u) & 1) == 0) continue; 34 | if ((i >> v) & 1) continue; 35 | ans += w; 36 | } 37 | cuts.push_back(ans); 38 | } 39 | sort(cuts.begin(), cuts.end()); 40 | printf("%d\n", cuts[k - 1]); 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /src/long/sept16/one.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char s[100100]; 5 | 6 | int main(void) { 7 | int t; 8 | scanf("%d", &t); 9 | while (t--) { 10 | scanf("%s", s); 11 | int l = strlen(s); 12 | int one = 0, zero = 0; 13 | for (int i = 0; i < l; i++) { 14 | if (s[i] == '0') 15 | zero++; 16 | if (s[i] == '1') 17 | one++; 18 | } 19 | if (zero == 1 || one == 1) 20 | printf("Yes\n"); 21 | else 22 | printf("No\n"); 23 | } 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /src/long/sept16/two.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char s[100100]; 5 | 6 | int main(void) { 7 | int t; 8 | scanf("%d", &t); 9 | while (t--) { 10 | scanf("%s", s); 11 | int l = strlen(s); 12 | int flag = 1; 13 | for (int i = 0; i < l; i++) { 14 | int j = l - 1 - i; 15 | if (s[i] == s[j] && s[i] == '.') 16 | s[i] = s[j] = 'a'; 17 | else if (s[i] == '.' && s[i] != s[j]) 18 | s[i] = s[j]; 19 | else if (s[j] == '.' && s[i] != s[j]) 20 | s[j] = s[i]; 21 | else if (s[i] != '.' && s[i] != s[j]) 22 | flag = 0; 23 | } 24 | if (flag) 25 | printf("%s\n", s); 26 | else 27 | printf("-1\n"); 28 | } 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /src/ltime27/mnmx.py: -------------------------------------------------------------------------------- 1 | # Author: Param Singh 2 | 3 | t = int(raw_input()) 4 | for _ in range(t): 5 | l = int(raw_input()) 6 | lst = map(int, raw_input().split()) 7 | x = min(lst) 8 | ans = x * (l-1) 9 | print ans 10 | -------------------------------------------------------------------------------- /src/practice/117c.cpp: -------------------------------------------------------------------------------- 1 | // http://codeforces.com/problemset/problem/117/C 2 | 3 | #include 4 | #define MAX 5010 5 | using namespace std; 6 | 7 | int adj[MAX][MAX]; 8 | int visited[MAX] = {0}; 9 | int n; 10 | 11 | int dfs(int cur, int prev) { 12 | visited[cur] = 1; 13 | for (int i = 0; i < n; i++) { 14 | if (adj[cur][i] == 1) { 15 | if (adj[i][prev] == 1) { 16 | printf("%d %d %d\n", prev+1, cur+1, i+1); 17 | return 1; 18 | } 19 | if (visited[i] == 0) 20 | if (dfs(i, cur) == 1) 21 | return 1; 22 | } 23 | } 24 | return 0; 25 | } 26 | 27 | int main(void) { 28 | scanf("%d", &n); 29 | int m = n; 30 | int i, j; 31 | for (i = 0; i < n; i++) { 32 | getchar(); 33 | for (j = 0; j < n; j++) { 34 | int c = getchar(); 35 | adj[i][j] = c - '0'; 36 | } 37 | } 38 | int flag = 0; 39 | for (i = 0; i < n; i++) { 40 | if (visited[i] == 0) { 41 | if (dfs(i, i) == 1) { 42 | flag = 1; 43 | break; 44 | } 45 | } 46 | } 47 | if (flag == 0) 48 | printf("-1\n"); 49 | return 0; 50 | } 51 | 52 | -------------------------------------------------------------------------------- /src/practice/acode.cpp: -------------------------------------------------------------------------------- 1 | // dp(x) = number of strings that can be made starting from s[x:] 2 | // dp(x) = 1 if x == len - 1 3 | // dp(x) = dp(x+1) + ( dp(x+2) if s[x:x+1] <= 26 ) 4 | 5 | #include 6 | 7 | long long int dp[5010]; 8 | int len; 9 | char* s; 10 | long long int ans(int x) { 11 | if (dp[x] != -1) 12 | return dp[x]; 13 | if (x == len-1 && s[x] != '0') 14 | return dp[x] = 1; 15 | else if (x == len - 1 && s[x] == '0') 16 | return dp[x] = 0; 17 | if (x >= len) 18 | return dp[x] = 1; 19 | else { 20 | long long int f = 0; 21 | f += ans(x+1); 22 | if (x <= len-2 && (s[x] == '1' || (s[x] == '2' && '0' <= s[x+1] && s[x+1] <= '6'))) 23 | f += ans(x+2); 24 | if (s[x] == '0') 25 | return dp[x] = 0; 26 | return dp[x] = f; 27 | } 28 | } 29 | 30 | int main(void) { 31 | while (true) { 32 | s = (char *) calloc(5010, sizeof(char)); 33 | scanf("%s", s); 34 | len = strlen(s); 35 | if (s[0] == '0' && len == 1) 36 | break; 37 | for (int i = 0; i < 5010; i++) 38 | dp[i] = -1; 39 | printf("%lld\n", ans(0)); 40 | free(s); 41 | } 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /src/practice/aiboh.cpp: -------------------------------------------------------------------------------- 1 | // dp(x, y) = number of additions required to make s[x:y] a palindrome 2 | // dp(x, x) = 0 3 | // dp(x, y) = dp(x+1, y-1) if s[x] = s[y] 4 | // dp(x, y) = min(dp(x+1, y)+1, dp(x, y-1)+1) otherwise 5 | 6 | #include 7 | using namespace std; 8 | 9 | int dp[6500][6500]; 10 | char* s; 11 | 12 | int ans(int x, int y) { 13 | if (dp[x][y] != -1) 14 | return dp[x][y]; 15 | if (x == y) 16 | return dp[x][y] = 0; 17 | if (s[x] == s[y]) 18 | return dp[x][y] = ans(x+1, y-1); 19 | int right = ans(x+1, y) + 1; // add the character at s[x] to the left of s[x:y] 20 | int left = ans(x, y-1) + 1; // add the character at s[y] to the right of s[x:y] 21 | return dp[x][y] = min(right, left); 22 | } 23 | 24 | int main(void) { 25 | int t; 26 | scanf("%d", &t); 27 | while (t--) { 28 | for (int i = 0; i < 6200; i++) 29 | for (int j = 0; j < 6200; j++) 30 | dp[i][j] = -1; 31 | s = (char*) calloc(6200, sizeof(char)); 32 | scanf("%s", s); 33 | int l = strlen(s); 34 | printf("%d\n", ans(0, l-1)); 35 | } 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /src/practice/binarysearch/devubrother.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | const ll inf = 1e18; 5 | 6 | int n, m; 7 | int a[100100]; 8 | int b[100100]; 9 | 10 | ll f(int k) { 11 | ll cnt = 0; 12 | for (int i = 1; i <= n; i++) 13 | if (a[i] < k) 14 | cnt += k - a[i]; 15 | for (int i = 1; i <= m; i++) 16 | if (b[i] > k) 17 | cnt += b[i] - k; 18 | return cnt; 19 | } 20 | 21 | int main(void) { 22 | scanf("%d %d", &n, &m); 23 | for (int i = 1; i <= n; i++) 24 | scanf("%d", &a[i]); 25 | for (int i = 1; i <= m; i++) 26 | scanf("%d", &b[i]); 27 | ll ans = inf; 28 | int lo = 0, hi = 1e9 + 1; 29 | for (int it = 0; it < 100; it++) { 30 | int mid1 = lo + (hi - lo) / 3; 31 | int mid2 = hi - (hi - lo) / 3; 32 | ll f1 = f(mid1), f2 = f(mid2); 33 | if (f1 < ans) 34 | ans = f1; 35 | if (f2 < ans) 36 | ans = f2; 37 | if (f1 >= f2) 38 | lo = mid1; 39 | else 40 | hi = mid2; 41 | } 42 | printf("%lld\n", ans); 43 | } 44 | -------------------------------------------------------------------------------- /src/practice/binarysearch/eko.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long int lli; 4 | int arr[1000100]; 5 | lli sums[1000100]; 6 | 7 | int main(void) { 8 | int n; 9 | lli m; 10 | scanf("%d %lld", &n, &m); 11 | for (int i = 0; i < n; i++) 12 | scanf("%d", &arr[i]); 13 | sort(arr, arr+n); 14 | sums[n-1] = arr[n-1]; 15 | for (int i = n-2; i >= 0; i--) 16 | sums[i] = arr[i] + sums[i+1]; 17 | lli lo = 1, hi = 3000000000; 18 | // find the first instance of wood cut being less than m 19 | while (lo < hi) { 20 | lli mid = (lo + hi) / 2; 21 | int id = lower_bound(arr, arr+n, mid) - arr; 22 | lli wood = sums[id] - (mid * (n - id)); 23 | if (wood < m) 24 | hi = mid; 25 | else 26 | lo = mid + 1; 27 | } 28 | // last instance of wood being greater than or equal to m = lo - 1 29 | printf("%lld\n", lo - 1); 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /src/practice/binarysearch/multable.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | int n, m; ll k; 5 | 6 | ll get(ll x) { 7 | ll cnt = 0; 8 | for (int i = 1; i <= n; i++) 9 | cnt += min((ll)m, x / i); 10 | return cnt; 11 | } 12 | 13 | int main(void) { 14 | scanf("%d %d %lld", &n, &m, &k); 15 | ll lo = 1, hi = (ll)n * m; 16 | while (lo < hi) { 17 | ll mid = (lo + hi) / 2; 18 | if (get(mid) >= k) 19 | hi = mid; 20 | else 21 | lo = mid + 1; 22 | } 23 | printf("%lld\n", lo); 24 | } 25 | -------------------------------------------------------------------------------- /src/practice/bit.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int* bit; 5 | int max; 6 | 7 | long long int query(int i) { 8 | long long int sum = 0; 9 | while (i > 0) { 10 | sum += bit[i]; 11 | i -= (i & (-i)); 12 | } 13 | return sum; 14 | } 15 | 16 | void update(int i, int val) { 17 | while (i <= max) { 18 | bit[i] += val; 19 | i += (i & (-i)); 20 | } 21 | } 22 | 23 | int main(void) { 24 | int t; 25 | scanf("%d", &t); 26 | while (t--) { 27 | bit = (int *) calloc(10000001, 4); 28 | int n; 29 | scanf("%d", &n); 30 | int arr[n]; 31 | int i; 32 | max = -1; 33 | for (i = 0; i < n; i++) { 34 | scanf("%d", arr+i); 35 | max = (max > arr[i]) ? max : arr[i]; 36 | } 37 | long long int ans = 0; 38 | for (i = n-1; i >= 0; i--) { 39 | ans += query(arr[i]-1); 40 | update(arr[i], 1); 41 | } 42 | printf("%lld\n", ans); 43 | free(bit); 44 | } 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /src/practice/candy.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int n = 0; 5 | scanf("%d", &n); 6 | while (n != -1) { 7 | int a[n]; 8 | int i; 9 | int sum = 0; 10 | for (i = 0; i < n; i++) { 11 | scanf("%d", a+i); 12 | sum += a[i]; 13 | } 14 | if (sum % n != 0) 15 | printf("-1\n"); 16 | else { 17 | int av = sum / n, ans = 0; 18 | for (i = 0; i < n; i++) { 19 | if (a[i] > av) 20 | ans += a[i] - av; 21 | } 22 | printf("%d\n", ans); 23 | } 24 | scanf("%d", &n); 25 | } 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /src/practice/capple.py: -------------------------------------------------------------------------------- 1 | # http://www.codechef.com/DEC14/problems/CAPPLE 2 | 3 | def pluck(trees): 4 | # check if all the elements in the list are the same 5 | different = False 6 | dummy = trees[0] 7 | for i in trees: 8 | if i != dummy: 9 | different = True 10 | break 11 | 12 | if not different: 13 | return [0]*len(trees) 14 | 15 | # find the biggest and the second biggest number in the list 16 | first, second = None, None 17 | for n in trees: 18 | if n > first: 19 | first, second = n, first 20 | elif first > n > second: 21 | second = n 22 | 23 | diff = first - second 24 | return map(lambda x: x - diff if x == first else x, trees) 25 | 26 | def time(trees): 27 | counter = 0 28 | while not all(i == 0 for i in trees): 29 | trees = pluck(trees) 30 | counter += 1 31 | return counter 32 | 33 | inputs = int(raw_input()) 34 | while inputs: 35 | length = int(raw_input()) 36 | trees = map(int, raw_input().split()) 37 | print time(trees) 38 | inputs -= 1 -------------------------------------------------------------------------------- /src/practice/chefAndEquality.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main(void){ 3 | int cases; 4 | scanf("%d", &cases); 5 | while(cases--){ 6 | int freq[100001] = {0}; 7 | int n; 8 | scanf("%d", &n); 9 | int i; 10 | for(i=0;i max){ 18 | max = freq[i]; 19 | } 20 | } 21 | printf("%d\n", n-max); 22 | } 23 | } -------------------------------------------------------------------------------- /src/practice/chefandchains.py: -------------------------------------------------------------------------------- 1 | # http://www.codechef.com/FEB15/problems/CHEFCH 2 | terms = int(raw_input()) 3 | for i in range(terms): 4 | string = raw_input() 5 | length = len(string) 6 | a = ''.join(map(lambda x: "+" if x%2 else '-', range(length))) 7 | b = ''.join(map(lambda x: "+" if x%2 else '-', range(1,length+1))) 8 | counters = [0,0] 9 | for index,ch in enumerate(string): 10 | if ch == a[index]: 11 | counters[0] += 1 12 | if ch == b[index]: 13 | counters[1] += 1 14 | if counters[0] < counters[1]: 15 | print counters[0] 16 | else: 17 | print counters[1] -------------------------------------------------------------------------------- /src/practice/chefstone.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main( void ) 4 | { 5 | int t; 6 | scanf("%d", &t); 7 | int term; 8 | for(term = 0; term maximum: 10 | maximum = t 11 | print maximum -------------------------------------------------------------------------------- /src/practice/cleanup.hs: -------------------------------------------------------------------------------- 1 | chef :: [a] -> [a] 2 | chef [] = [] 3 | chef [x] = [x] 4 | chef (x:xs) = [x] ++ chef (tail xs) 5 | 6 | assistant :: [a] -> [a] 7 | assistant [] = [] 8 | assistant [x] = [] 9 | assistant (x:xs) = [head xs] ++ assistant (tail xs) 10 | 11 | clean = do 12 | str <- getLine 13 | let [n, m] = map (\x -> read x :: Int) $ words str 14 | str_m <- getLine 15 | let done = map (\x -> read x :: Int) $ words str_m 16 | let remaining = [x | x <- [1..n], notElem x done] 17 | putStrLn . unwords $ map show (chef remaining) 18 | putStrLn . unwords $ map show (assistant remaining) 19 | 20 | main = do 21 | terms <- readLn 22 | sequence $ replicate terms clean 23 | return () 24 | -------------------------------------------------------------------------------- /src/practice/coins.py: -------------------------------------------------------------------------------- 1 | memo = {} 2 | def func(x): 3 | if x in memo: 4 | return memo[x] 5 | f = 0 6 | if x == 1: 7 | f = 1 8 | elif x > 1: 9 | f = max(x, func(x/2) + func(x/3) + func(x/4)) 10 | memo[x] = f 11 | return f 12 | 13 | while True: 14 | try: 15 | n = int(raw_input()) 16 | except: 17 | break 18 | print func(n) 19 | 20 | -------------------------------------------------------------------------------- /src/practice/colorful.cpp: -------------------------------------------------------------------------------- 1 | // http://codeforces.com/problemset/problem/246/D 2 | #include 3 | using namespace std; 4 | 5 | set added[100010]; 6 | int n, m; 7 | int u, v; 8 | int card[100100]; 9 | int color[100100]; 10 | 11 | int main(void) { 12 | scanf("%d %d", &n, &m); 13 | for (int i = 0; i <= 100000; i++) 14 | card[i] = -1; 15 | for (int i = 1; i <= n; i++) { 16 | scanf("%d", color+i); 17 | card[color[i]] = 0; 18 | } 19 | while (m--) { 20 | scanf("%d %d", &u, &v); 21 | if (color[u] != color[v]) { 22 | if (added[color[u]].find(color[v]) == added[color[u]].end()) { 23 | added[color[u]].insert(color[v]); 24 | card[color[u]]++; 25 | } 26 | if (added[color[v]].find(color[u]) == added[color[v]].end()) { 27 | added[color[v]].insert(color[u]); 28 | card[color[v]]++; 29 | } 30 | } 31 | } 32 | int id = -1; 33 | for (int i = 1; i <= 100000; i++) { 34 | if (card[i] != -1) { 35 | if (id == -1 || card[i] > card[id]) 36 | id = i; 37 | } 38 | } 39 | printf("%d\n", id); 40 | return 0; 41 | } 42 | 43 | -------------------------------------------------------------------------------- /src/practice/cooling.hs: -------------------------------------------------------------------------------- 1 | import Data.List 2 | 3 | getnum pies racks = helper 0 pies racks 4 | where helper acc p r | p == [] || r == [] = acc 5 | helper acc p r = if racks_aval /= [] 6 | then helper (acc+1) (tail p) (init r) 7 | else helper acc (tail p) r 8 | where racks_aval = filter (>=(head p)) r 9 | cool = do 10 | getLine 11 | pie_str <- getLine 12 | let pies = reverse . sort $ map (\x -> read x :: Int) $ words pie_str 13 | rack_str <- getLine 14 | let racks = sort $ map (\x -> read x :: Int) $ words rack_str 15 | print $ getnum pies racks 16 | 17 | main = do 18 | terms <- readLn 19 | sequence $ replicate terms cool 20 | return () 21 | -------------------------------------------------------------------------------- /src/practice/cowpic.cpp: -------------------------------------------------------------------------------- 1 | // 1:21 2 | #include 3 | 4 | int bit[100100] = {0}; 5 | 6 | void update(int pos, int val) { 7 | while (pos <= 100001) { 8 | bit[pos] += val; 9 | pos += pos & -pos; 10 | } 11 | } 12 | 13 | int get(int pos) { 14 | int ans = 0; 15 | while (pos > 0) { 16 | ans += bit[pos]; 17 | pos -= pos & -pos; 18 | } 19 | return ans; 20 | } 21 | 22 | int a[100100]; 23 | int pos[100100]; 24 | 25 | int main(void) { 26 | int n; 27 | scanf("%d", &n); 28 | for (int i = 1; i <= n; i++) { 29 | scanf("%d", &a[i]); 30 | pos[a[i]] = i; 31 | } 32 | long long int ans = 0; 33 | for (int i = 1; i <= n; i++) { 34 | ans += i - 1 - get(a[i]); 35 | update(a[i], 1); 36 | } 37 | long long int mn = ans; 38 | for (int i = 1; i <= n; i++) { 39 | ans -= pos[i] - 1; 40 | ans += n - pos[i]; 41 | if (ans < mn) 42 | mn = ans; 43 | } 44 | printf("%lld\n", mn); 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /src/practice/cowsandcars.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | double ans(double m, double n, double s) { 4 | return (n * (m + n - 1)) / ((m + n) * (m + n - s - 1)); 5 | } 6 | 7 | int main(void) { 8 | int m, n, s; 9 | while (scanf("%d %d %d", &m, &n, &s) != EOF) { 10 | printf("%.5lf\n", ans(m, n, s)); 11 | } 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /src/practice/cthulhu.cpp: -------------------------------------------------------------------------------- 1 | // http://codeforces.com/problemset/problem/104/C 2 | #include 3 | using namespace std; 4 | typedef pair pii; 5 | int cycles = 0; 6 | vector graph[200]; 7 | int done[200][200] = {0}; 8 | int visited[200] = {0}; 9 | int c = 0; 10 | 11 | void dfs(int cur, int prev) { 12 | c++; 13 | visited[cur] = 1; 14 | for (int i = 0; i < graph[cur].size(); i++) { 15 | int v = graph[cur][i]; 16 | if (!done[cur][v] && !done[v][cur]) { 17 | done[cur][v] = 1; 18 | done[v][cur] = 1; 19 | if (v != prev && visited[v] == 1) { 20 | cycles++; 21 | continue; 22 | } 23 | dfs(v, cur); 24 | } 25 | } 26 | } 27 | 28 | int main(void) { 29 | int n, m; 30 | scanf("%d %d", &n, &m); 31 | int u, v; 32 | while (m--) { 33 | scanf("%d %d", &u, &v); 34 | graph[u].push_back(v); 35 | graph[v].push_back(u); 36 | } 37 | dfs(1, -1); 38 | if (c != n) 39 | printf("NO\n"); 40 | else if (cycles == 1) 41 | printf("FHTAGN!\n"); 42 | else 43 | printf("NO\n"); 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /src/practice/dcepca03.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define SIZE 10040 3 | 4 | int phi[SIZE]; 5 | int sums[SIZE]; 6 | 7 | int main(void) { 8 | int i; 9 | for (i = 0; i < SIZE; i++) 10 | phi[i] = i; 11 | for (i = 2; i < SIZE; i++) { 12 | if (phi[i] == i) { 13 | for (int j = i; j < SIZE; j+=i) 14 | phi[j] -= phi[j] / i; 15 | } 16 | } 17 | sums[1] = phi[1] = 1; 18 | for (i = 2; i < SIZE; i++) 19 | sums[i] = phi[i] + sums[i-1]; 20 | int t; 21 | scanf("%d", &t); 22 | while (t--) { 23 | int n; 24 | scanf("%d", &n); 25 | long long int ans = (long long) (sums[n]) * sums[n]; 26 | printf("%lld\n", ans); 27 | } 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /src/practice/digvijay.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main(void){ 4 | int terms; 5 | scanf("%d", &terms); 6 | while(terms--){ 7 | int base, mod; 8 | scanf("%d%d", &base, &mod); 9 | char *ch = (char *)calloc(1000*sizeof(char), sizeof(char)); 10 | scanf("%s", ch); 11 | int i=0; 12 | int num = 0; 13 | while(ch[i] != '\0'){ 14 | int digit = ch[i] - '0'; 15 | num = num * base + digit; 16 | printf("%d ", num%mod); 17 | i++; 18 | } 19 | printf("\n"); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/practice/div.c: -------------------------------------------------------------------------------- 1 | /** http://www.spoj.com/problems/DIV/ */ 2 | 3 | #include 4 | #include 5 | #define MAX 1000100 6 | 7 | int seive[MAX] = {0}; 8 | 9 | int main(void) { 10 | int i, j; 11 | for (i = 2; i < MAX; i++) { 12 | if (seive[i] == 0) { 13 | for (j = i; j < MAX; j+=i) 14 | seive[j] = i; 15 | } 16 | } 17 | int c = 0; 18 | int num; 19 | for (num = 2; num <= 1000000; num++) { 20 | int dn = 1; 21 | int dup = num; 22 | int prev = seive[dup], count = 1; 23 | while (dup != 1) { 24 | dup /= seive[dup]; 25 | if (seive[dup] == prev) 26 | count++; 27 | else { 28 | dn *= count+1; 29 | count = 1; 30 | } 31 | prev = seive[dup]; 32 | } 33 | int flag = 0; 34 | prev = seive[dn]; 35 | dn /= seive[dn]; 36 | if (dn != 1) { 37 | if (seive[dn] != prev && seive[dn] == dn) 38 | flag = 1; 39 | } 40 | if (flag == 1 ) { 41 | c++; 42 | if (c % 9 == 0) 43 | printf("%d\n", num); 44 | } 45 | } 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /src/practice/dp/assign.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | typedef long long lli; 4 | 5 | lli dp[1100000]; 6 | int n; 7 | int likes[30][30]; 8 | 9 | lli ans(int mask) { 10 | if (dp[mask] != -1) 11 | return dp[mask]; 12 | 13 | int assigned = 0; 14 | for (int i = 0; i < n; i++) 15 | if ((mask >> i) & 1) 16 | assigned++; 17 | if (assigned == n) 18 | return 1; 19 | else { 20 | lli sol = 0; 21 | int student = assigned; 22 | for (int i = 0; i < n; i++) { 23 | if (likes[student][i] && ((mask >> i) & 1) == 0) 24 | sol += ans(mask | (1 << i)); 25 | } 26 | return dp[mask] = sol; 27 | } 28 | } 29 | 30 | int main(void) { 31 | int t; 32 | scanf("%d", &t); 33 | while (t--) { 34 | memset(dp, -1, sizeof(dp)); 35 | scanf("%d", &n); 36 | for (int i = 0; i < n; i++) 37 | for (int j = 0; j < n; j++) 38 | scanf("%d", &likes[i][j]); 39 | printf("%lld\n", ans(0)); 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /src/practice/dp/beewalk.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int dp[200][200][500]; 3 | int n; 4 | int dx[6] = {1, 0, -1, 0, 1, -1}; 5 | int dy[6] = {0, -1, 0, 1, 1, -1}; 6 | 7 | int ans(int x, int y, int rem) { 8 | if (dp[x][y][rem] != -1) 9 | return dp[x][y][rem]; 10 | if (x == 50 && y == 50 && rem == 0) 11 | return dp[x][y][rem] = 1; 12 | if (rem <= 0) 13 | return 0; 14 | dp[x][y][rem] = 0; 15 | for (int i = 0; i < 6; i++) 16 | dp[x][y][rem] += ans(x+dx[i], y+dy[i], rem - 1); 17 | return dp[x][y][rem]; 18 | } 19 | 20 | int main(void) { 21 | memset(dp, -1, sizeof(dp)); 22 | int t; 23 | scanf("%d", &t); 24 | while (t--) { 25 | scanf("%d", &n); 26 | printf("%d\n",ans(50, 50, n)); 27 | } 28 | return 0; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /src/practice/dp/blackorwhite.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int dp[210][210][210]; 5 | int n; 6 | int a[210]; 7 | 8 | int ans(int at, int pb, int pw) { 9 | if (at == 0) 10 | return 0; 11 | if (dp[at][pb][pw] != -1) 12 | return dp[at][pb][pw]; 13 | int w = 100000000; 14 | if (pw == n + 1 || a[at] > a[pw]) 15 | w = ans(at - 1, pb, at); 16 | int b = 100000000; 17 | if (pb == n + 1 || a[at] < a[pb]) 18 | b = ans(at - 1, at, pw); 19 | int dont = ans(at - 1, pb, pw) + 1; 20 | int ret = min(dont, min(w, b)); 21 | return dp[at][pb][pw] = ret; 22 | } 23 | 24 | int main(void) { 25 | scanf("%d", &n); 26 | while (n != -1) { 27 | memset(dp, -1, sizeof(dp)); 28 | for (int i = 1; i <= n; i++) 29 | scanf("%d", a+i); 30 | printf("%d\n", ans(n, n+1, n+1)); 31 | scanf("%d", &n); 32 | } 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /src/practice/dp/bridge.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int dp[1001]; 5 | vector > p; 6 | int a[1010]; 7 | int b[1010]; 8 | 9 | int ans(int i) { 10 | if (dp[i] != -1) 11 | return dp[i]; 12 | 13 | if (i == 0) 14 | return 1; 15 | int mx = 1; 16 | for (int j = i-1; j >= 0; j--) { 17 | if (p[j].second <= p[i].second) { 18 | mx = max(mx, ans(j) + 1); 19 | } 20 | } 21 | return dp[i] = mx; 22 | } 23 | 24 | 25 | int main(void) { 26 | int t; 27 | scanf("%d", &t); 28 | while (t--) { 29 | p.clear(); 30 | memset(dp, -1, sizeof(dp)); 31 | int n; 32 | scanf("%d", &n); 33 | for (int i = 1; i <= n; i++) 34 | scanf("%d", a+i); 35 | for (int i = 1; i <= n; i++) 36 | scanf("%d", b+i); 37 | for (int i = 1; i <= n; i++) 38 | p.push_back(make_pair(a[i], b[i])); 39 | sort(p.begin(), p.end()); 40 | int sol = 0; 41 | for (int i = 0; i < n; i++) 42 | sol = max(sol, ans(i)); 43 | printf("%d\n", sol); 44 | } 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /src/practice/dp/divseq.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | const ll mod = 1000000009; 5 | 6 | vector factors[1010]; 7 | ll dp[1010][1010]; 8 | int n, k; 9 | 10 | ll solve(int u, int prev) { 11 | if (dp[u][prev] != -1) return dp[u][prev]; 12 | if (u == n) { 13 | return 1; 14 | } 15 | else { 16 | ll ans = 0; 17 | for (int i = 0; i < factors[prev].size(); i++) 18 | ans = (ans + solve(u + 1, factors[prev][i])) % mod; 19 | for (int x = prev + prev; x <= k; x += prev) 20 | ans = (ans + solve(u + 1, x)) % mod; 21 | return dp[u][prev] = ans; 22 | } 23 | } 24 | 25 | int main(void) { 26 | scanf("%d %d", &n, &k); 27 | for (int i = 1; i <= k; i++) { 28 | for (int x = i; x <= k; x += i) 29 | factors[x].push_back(i); 30 | } 31 | memset(dp, -1, sizeof(dp)); 32 | ll ans = 0; 33 | for (int i = 1; i <= k; i++) 34 | ans = (ans + solve(1, i)) % mod; 35 | printf("%lld\n", ans); 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /src/practice/dp/flowers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MOD 1000000007 3 | using namespace std; 4 | 5 | int dp[100100]; 6 | int prefix[100100]; 7 | 8 | int main(void) { 9 | int t, k; 10 | scanf("%d %d", &t, &k); 11 | prefix[0] = dp[0] = 1; 12 | for (int i = 1; i < k; i++) { 13 | dp[i] = 1; 14 | prefix[i] = (dp[i] + prefix[i-1]) % MOD; 15 | } 16 | for (int i = k; i <= 100000; i++) { 17 | dp[i] = (dp[i-1] + dp[i-k]) % MOD; 18 | prefix[i] = (dp[i] + prefix[i-1]) % MOD; 19 | } 20 | while (t--) { 21 | int a, b; 22 | scanf("%d %d", &a, &b); 23 | int ans = (prefix[b] - prefix[a-1]) % MOD; 24 | if (ans < 0) 25 | ans += MOD; 26 | cout << ans << endl; 27 | } 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /src/practice/dp/funnygames.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | 8 | ll dp[200100]; 9 | ll pref[200100]; 10 | ll a[200100]; 11 | 12 | int main(void) { 13 | int n; 14 | scanf("%d", &n); 15 | for (int i = 1; i <= n; i++) { 16 | scanf("%lld", a+i); 17 | pref[i] = pref[i - 1] + a[i]; 18 | } 19 | // base case 20 | dp[n] = 0; 21 | // general 22 | // dp[i] = max(pref[i + 1] - dp[i + 1], pref[i + 2] - dp[i + 2] .. ) 23 | ll mx = pref[n]; 24 | for (int i = n - 1; i >= 1; i--) { 25 | dp[i] = mx; 26 | mx = max(mx, pref[i] - dp[i]); 27 | } 28 | printf("%lld\n", dp[1]); 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /src/practice/dp/georgeandjob.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | const ll inf = 1e18; 5 | 6 | ll dp[5001][5001]; 7 | int a[5010]; 8 | ll pref[5010]; 9 | int n, m, k; 10 | 11 | ll sum(int l, int r) { 12 | return pref[r] - pref[l - 1]; 13 | } 14 | 15 | ll solve(int here, int k) { 16 | if (here == n + 1) { 17 | if (k > 0) 18 | return -inf; 19 | else 20 | return 0; 21 | } 22 | 23 | if (k == 0) 24 | return 0; 25 | if (dp[here][k] != -1) 26 | return dp[here][k]; 27 | 28 | ll dont = solve(here + 1, k); 29 | ll take = -inf; 30 | if (here + m - 1 <= n) 31 | take = solve(here + m, k - 1) + sum(here, here + m - 1); 32 | return dp[here][k] = max(dont, take); 33 | } 34 | 35 | int main(void) { 36 | memset(dp, -1, sizeof(dp)); 37 | scanf("%d %d %d", &n, &m, &k); 38 | for (int i = 1; i <= n; i++) { 39 | scanf("%d", &a[i]); 40 | pref[i] = pref[i - 1] + a[i]; 41 | } 42 | printf("%lld\n", solve(1, k)); 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /src/practice/dp/good.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | 8 | int a[100100]; 9 | int dp[100100]; 10 | int d[100100]; 11 | 12 | int main(void) { 13 | int n; 14 | scanf("%d", &n); 15 | for (int i = 1; i <= n; i++) 16 | scanf("%d", &a[i]); 17 | for (int i = 1; i <= n; i++) { 18 | int x = a[i]; 19 | if (x == 1) { 20 | dp[x] = 1; 21 | continue; 22 | } 23 | for (int j = 1; j * j <= x; j++) { 24 | d[1] = 0; 25 | if (x % j == 0) { 26 | int f1 = j, f2 = x / j; 27 | dp[x] = max(dp[x], d[f1] + 1); 28 | dp[x] = max(dp[x], d[f2] + 1); 29 | } 30 | } 31 | for (int j = 1; j * j <= x; j++) { 32 | d[1] = 0; 33 | if (x % j == 0) { 34 | int f1 = j, f2 = x / j; 35 | d[f1] = max(dp[x], d[f1]); 36 | d[f2] = max(dp[x], d[f2]); 37 | } 38 | } 39 | } 40 | int ans = -inf; 41 | for (int i = 1; i <= n; i++) 42 | ans = max(ans, dp[a[i]]); 43 | printf("%d\n", ans); 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /src/practice/dp/helix.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int dp[10100][3]; 5 | int a[3][10100]; 6 | int size[3]; 7 | 8 | 9 | int ans(int l, int id) { 10 | if (dp[l][id] != -1) 11 | return dp[l][id]; 12 | if (l > size[id]) 13 | return 0; 14 | else { 15 | int x = a[id][l]; 16 | int lo = 1, hi = size[id^1]; 17 | while (lo < hi) { 18 | int mid = (lo + hi) / 2; 19 | if (a[id^1][mid] >= x) 20 | hi = mid; 21 | else 22 | lo = mid + 1; 23 | } 24 | int sol = INT_MIN; 25 | if (a[id^1][lo] == x) { 26 | sol = x + ans(lo+1, id^1); 27 | } 28 | sol = max(sol, x + ans(l+1, id)); 29 | return dp[l][id] = sol; 30 | } 31 | } 32 | 33 | int main(void) { 34 | while (true) { 35 | memset(dp, -1, sizeof(dp)); 36 | scanf("%d", size); 37 | if (size[0] == 0) 38 | break; 39 | for (int i = 1; i <= size[0]; i++) 40 | scanf("%d", &a[0][i]); 41 | scanf("%d", &size[1]); 42 | for (int i = 1; i <= size[1]; i++) 43 | scanf("%d", &a[1][i]); 44 | printf("%d\n", max(ans(1, 0), ans(1, 1))); 45 | } 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /src/practice/dp/mblast.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int dp[2100][2100]; 5 | int k; 6 | char a[2100], b[2100]; 7 | 8 | int ans(int x, int y) { 9 | if (dp[x][y] != -1) 10 | return dp[x][y]; 11 | else if (x == 0) 12 | return dp[x][y] = k * y; 13 | else if (y == 0) 14 | return dp[x][y] = k * x; 15 | else { 16 | int sol = min(min(ans(x-1, y) + k, ans(x, y-1) + k), ans(x-1, y-1) + abs(a[x] - b[y])); 17 | return dp[x][y] = sol; 18 | } 19 | } 20 | 21 | 22 | int main(void) { 23 | memset(dp, -1, sizeof(dp)); 24 | scanf("%s", a+1); 25 | scanf("%s", b+1); 26 | scanf("%d", &k); 27 | int x = strlen(a+1); 28 | int y = strlen(b+1); 29 | printf("%d\n", ans(x, y)); 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /src/practice/dp/permut1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | long long dp[15][100]; 4 | int n; 5 | long long ans(int x, int k) { 6 | if (n == 0) 7 | return 0; 8 | 9 | if (k == 0) 10 | return 1; 11 | 12 | if (dp[x][k] != -1) 13 | return dp[x][k]; 14 | 15 | long long val = 0; 16 | for (int i = 0; i < x && k - i >= 0; i++) 17 | val += ans(x - 1, k - i); 18 | 19 | return dp[x][k] = val; 20 | 21 | } 22 | 23 | int main(void) { 24 | int d, k; 25 | scanf("%d", &d); 26 | while (d--) { 27 | memset(dp, -1, sizeof(dp)); 28 | scanf("%d %d", &n, &k); 29 | long long x = 0; 30 | printf("%lld\n", ans(n, k)); 31 | } 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /src/practice/dp/redgreen.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | const int mod = 1e9 + 7; 5 | 6 | int dp[300100]; 7 | 8 | int main(void) { 9 | int r, g; 10 | scanf("%d %d", &r, &g); 11 | int total = r + g; 12 | int h = 0; 13 | while ((h * (h + 1)) / 2 <= total) 14 | h++; 15 | h--; 16 | dp[0] = 1; 17 | for (int ht = 1; ht <= h; ht++) { 18 | for (int use = r; use >= ht; use--) { 19 | dp[use] = (dp[use] + dp[use - ht]) % mod; 20 | } 21 | } 22 | int ans = 0; 23 | for (int use = max(0, (h * (h + 1) / 2) - g); use <= r; use++) 24 | ans = (ans + dp[use]) % mod; 25 | printf("%d\n", ans); 26 | } 27 | -------------------------------------------------------------------------------- /src/practice/dp/ridinglift.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | const int mod = 1e9 + 7; 5 | int dp[5010][5010]; 6 | int pref[5010][5010]; 7 | 8 | int main(void) { 9 | int n, a, b, k; 10 | scanf("%d %d %d %d", &n, &a, &b, &k); 11 | for (int i = 1; i <= n; i++) { 12 | dp[0][i] = 1; 13 | pref[0][i] = (dp[0][i] + pref[0][i - 1]) % mod; 14 | } 15 | for (int ride = 1; ride <= k; ride++) { 16 | for (int i = 1; i <= n; i++) { 17 | int dist = abs(b - i); 18 | int l = max(1, i - dist + 1); 19 | int r = min(n, i + dist - 1); 20 | dp[ride][i] = (pref[ride - 1][r] - pref[ride - 1][l - 1]) % mod; 21 | dp[ride][i] = (dp[ride][i] - dp[ride - 1][i]) % mod; 22 | if (dp[ride][i] < 0) 23 | dp[ride][i] = (dp[ride][i] + mod) % mod; 24 | pref[ride][i] = (pref[ride][i - 1] + dp[ride][i]) % mod; 25 | } 26 | } 27 | printf("%d\n", dp[k][a]); 28 | } 29 | -------------------------------------------------------------------------------- /src/practice/dp/roman.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | ll dp[101][1 << 19]; 6 | int m, d; 7 | int digit[30]; 8 | ll fact[22]; 9 | int freq[30]; 10 | 11 | ll solve(int mask, int mod) { 12 | if (mask == ((1 << d) - 1)) 13 | return mod == 0; 14 | if (dp[mod][mask] != -1) 15 | return dp[mod][mask]; 16 | ll ans = 0; 17 | for (int i = 0; i < d; i++) { 18 | if (mask & (1 << i)) continue; 19 | if (digit[i] == 0) { 20 | if (mask) 21 | ans += solve(mask | (1 << i), (mod * 10) % m); 22 | } 23 | else 24 | ans += solve(mask | (1 << i), (mod * 10 + digit[i]) % m); 25 | } 26 | return dp[mod][mask] = ans; 27 | } 28 | 29 | int main(void) { 30 | memset(dp, -1, sizeof(dp)); 31 | ll n; 32 | fact[0] = 1; 33 | for (int i = 1; i <= 20; i++) 34 | fact[i] = fact[i - 1] * i; 35 | scanf("%lld %d", &n, &m); 36 | while (n > 0) { 37 | digit[d++] = n % 10; 38 | freq[n % 10]++; 39 | n /= 10; 40 | } 41 | ll ans = solve(0, 0); 42 | for (int i = 0; i < 10; i++) 43 | ans /= fact[freq[i]]; 44 | printf("%lld\n", ans); 45 | } 46 | -------------------------------------------------------------------------------- /src/practice/dp/savetoys.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long int lli; 4 | 5 | lli dp[100100]; 6 | int a[100100]; 7 | int n; 8 | 9 | lli ans(int i) { 10 | if (dp[i] != -1) 11 | return dp[i]; 12 | 13 | if (i > n) 14 | return 0; 15 | 16 | lli sol = 0; 17 | int cnt = 0; 18 | for (int take = 1; (take <= 3) && ((i + take - 1) <= n); take++) { 19 | lli calc = 0; 20 | for (int j = 0; j < take; j++) 21 | calc += a[j+i]; 22 | if (i + take + take <= n) 23 | calc += ans(i+take+take); 24 | if (sol < calc) { 25 | cnt = take; 26 | sol = calc; 27 | } 28 | } 29 | return dp[i] = sol; 30 | } 31 | 32 | int main(void) { 33 | int t; 34 | scanf("%d", &t); 35 | while (t--) { 36 | memset(dp, -1, sizeof(dp)); 37 | scanf("%d", &n); 38 | for (int i = 1; i <= n; i++) 39 | scanf("%d", a+i); 40 | printf("%lld\n", ans(1)); 41 | } 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /src/practice/dp/seinfeld.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int k = 1; 5 | while (true) { 6 | char* c = (char *) calloc(2100, sizeof(char)); 7 | scanf("%s", c); 8 | if (c[0] == '-') break; 9 | int l = strlen(c); 10 | int open = 0, closed = 0, ans = 0; 11 | for (int i = 0; i < l; i++) { 12 | if (c[i] == '}') { 13 | if (open > 0) { 14 | open--; 15 | closed++; 16 | } 17 | else { 18 | ans++; 19 | open++; 20 | } 21 | } 22 | else { 23 | open++; 24 | } 25 | } 26 | printf("%d. %d\n", k++, ans + (open / 2)); 27 | free(c); 28 | } 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /src/practice/dp/tetrahedron.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | const int mod = 1e9 + 7; 4 | 5 | int dp[4]; 6 | int dp1[4]; 7 | 8 | int main(void) { 9 | int n; 10 | scanf("%d", &n); 11 | dp[0] = dp[1] = dp[2] = 1; 12 | for (int i = 2; i <= n; i++) { 13 | for (int x = 0; x < 4; x++) { 14 | dp1[x] = 0; 15 | for (int from = 0; from < 4; from++) { 16 | if (from == x) continue; 17 | dp1[x] = (dp1[x] + dp[from]) % mod; 18 | } 19 | } 20 | for (int x = 0; x < 4; x++) 21 | dp[x] = dp1[x]; 22 | } 23 | printf("%d\n", dp[3]); 24 | } 25 | -------------------------------------------------------------------------------- /src/practice/dp/trt.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int dp[2100][2100]; 4 | int n; 5 | int a[2100]; 6 | 7 | int ans(int l, int r) { 8 | int day = n - (r - l + 1) + 1; 9 | if (dp[l][r] != -1) 10 | return dp[l][r]; 11 | else if (l == r) { 12 | return dp[l][r] = day * a[l]; 13 | } 14 | else { 15 | int sol = std::max(ans(l+1, r) + day * a[l], ans(l, r-1) + day * a[r]); 16 | return dp[l][r] = sol; 17 | } 18 | } 19 | 20 | int main(void) { 21 | memset(dp, -1, sizeof(dp)); 22 | scanf("%d", &n); 23 | for (int i = 1; i <= n; i++) 24 | scanf("%d", a+i); 25 | printf("%d\n", ans(1, n)); 26 | return 0; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /src/practice/dp/vladiktrip.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | const int inf = 1e8; 4 | 5 | 6 | int a[5010]; 7 | int f[5010], e[5010]; 8 | int done[5010]; 9 | int dp[5010]; 10 | 11 | int main(void) { 12 | int n; 13 | scanf("%d", &n); 14 | for (int i = 1; i <= n; i++) 15 | scanf("%d", &a[i]); 16 | for (int num = 0; num <= 5000; num++) { 17 | int flag = 0; 18 | for (int i = 1; i <= n; i++) { 19 | if (a[i] == num) { 20 | e[num] = i; 21 | if (flag == 0) f[num] = i, flag = 1; 22 | } 23 | } 24 | } 25 | dp[0] = 0; 26 | for (int i = 1; i <= n; i++) { 27 | int mn = f[a[i]], mx = e[a[i]]; 28 | int cnt = 0; 29 | int val = 0; 30 | memset(done, 0, sizeof(done)); 31 | dp[i] = dp[i - 1]; 32 | for (int j = i; j >= 1; j--) { 33 | mn = min(mn, f[a[j]]); 34 | mx = max(mx, e[a[j]]); 35 | if (!done[a[j]]) { 36 | val ^= a[j]; 37 | done[a[j]] = 1; 38 | } 39 | if (j <= mn && mx <= i) 40 | dp[i] = max(dp[i], dp[j - 1] + val); 41 | } 42 | } 43 | printf("%d\n", dp[n]); 44 | } 45 | -------------------------------------------------------------------------------- /src/practice/ds/brandnewfunction.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | set fin; 5 | int a[100100]; 6 | 7 | int main(void) { 8 | int n; 9 | scanf("%d", &n); 10 | set mp; 11 | for (int i = 1; i <= n; i++) { 12 | scanf("%d", &a[i]); 13 | set n; 14 | for (int x: mp) 15 | n.insert(x | a[i]); 16 | n.insert(a[i]); 17 | mp.clear(); 18 | for (int x: n) { 19 | mp.insert(x); 20 | fin.insert(x); 21 | } 22 | } 23 | printf("%d\n", (int)fin.size()); 24 | } 25 | -------------------------------------------------------------------------------- /src/practice/ds/casino.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | 8 | int main(void) { 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /src/practice/exponentiation.c: -------------------------------------------------------------------------------- 1 | // Author: Param Singh 2 | // The Last Digit: http://www.spoj.com/problems/LASTDIG/ 3 | // Exponentiation by squaring 4 | #include 5 | 6 | int exp1(int x, long long int n) { 7 | if (n == 0) return 1; 8 | else if (n == 1) return (x % 10); 9 | else if (n % 2 == 0) return exp1(((x % 10) * (x%10)) % 10, n/2) % 10; 10 | else if (n % 2 == 1) return ((x % 10) * exp1(((x%10) * (x%10) % 10), (n-1) / 2)) % 10; 11 | return -1; 12 | } 13 | 14 | int main(void) { 15 | int t; 16 | scanf("%d", &t); 17 | while (t--) { 18 | int a; 19 | long long int b; 20 | scanf("%d %lld", &a, &b); 21 | printf("%d\n", exp1(a, b)); 22 | } 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /src/practice/factcg2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define SIZE 10000100 4 | 5 | int main(void) { 6 | int* seive = (int *) calloc(SIZE, sizeof(int)); 7 | int i, j; 8 | for (i = 2; i < SIZE; i++) { 9 | if (seive[i] == 0) { 10 | for (j = i; j < SIZE; j+=i) 11 | seive[j] = i; 12 | } 13 | } 14 | int n; 15 | int primes[1000]; 16 | while (scanf("%d", &n) != EOF) { 17 | int x = n; 18 | if (x == 1) { 19 | printf("1\n"); 20 | continue; 21 | } 22 | int count = 0; 23 | while (x != 1) { 24 | primes[count++] = seive[x]; 25 | x /= seive[x]; 26 | } 27 | printf("1 x "); 28 | for (i = count-1; i > 0; i--) 29 | printf("%d x ", primes[i]); 30 | printf("%d\n", primes[0]); 31 | } 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /src/practice/farida.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define max(a, b) a>b?a:b 4 | 5 | long long int dp[10001]; 6 | long long int arr[10001]; 7 | int n; 8 | 9 | int main(void) { 10 | int t; 11 | scanf("%d", &t); 12 | int c; 13 | for (c = 1; c <= t; c++) { 14 | scanf("%d", &n); 15 | if (n == 0) { 16 | printf("Case %d: 0\n", c); 17 | continue; 18 | } 19 | int i; 20 | for (i = 0; i < n; i++) 21 | scanf("%lld", arr+i); 22 | dp[n-1] = arr[n-1]; 23 | dp[n-2] = max(arr[n-2], arr[n-1]); 24 | for (i = n-3; i >= 0; i--) 25 | dp[i] = max(arr[i] + dp[i+2], dp[i+1]); 26 | printf("Case %d: %lld\n", c, dp[0]); 27 | } 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /src/practice/fctrl2.hs: -------------------------------------------------------------------------------- 1 | fact :: Integer -> Integer 2 | fact n = product [2..n] 3 | 4 | findfact = do 5 | n <- readLn 6 | print $ fact n 7 | 8 | main = do 9 | terms <- readLn 10 | sequence $ replicate terms findfact 11 | return () 12 | -------------------------------------------------------------------------------- /src/practice/gcd2.py: -------------------------------------------------------------------------------- 1 | # http://www.codechef.com/problems/GCD2 2 | 3 | # Using Python here isn't cheating right? ;) 4 | 5 | def gcd(a, b): 6 | if b == 0: 7 | return a 8 | else: 9 | return gcd(b, a%b) 10 | 11 | t = int(raw_input()) 12 | while t: 13 | line = raw_input().split() 14 | a = int(line[0]) 15 | b = int(line[1]) 16 | print gcd(a, b) 17 | t -= 1 -------------------------------------------------------------------------------- /src/practice/gcdq.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int hcf( int a, int b ) 4 | { 5 | while(b != 0){ 6 | int temp = b; 7 | b = a % b; 8 | a = temp; 9 | } 10 | return a; 11 | } 12 | 13 | int main( void ) 14 | { 15 | int t; 16 | scanf("%d", &t); 17 | while(t--){ 18 | int n, q; 19 | scanf("%d %d", &n, &q); 20 | int i; 21 | int arr[n]; 22 | for(i=0;i= 0; i--) 31 | right[i] = hcf(arr[i], right[i+1]); 32 | while (q--) { 33 | int l, r; 34 | scanf("%d %d", &l, &r); 35 | l--; 36 | r--; 37 | if (l == 0) 38 | printf("%d\n", right[r+1]); 39 | else if (r == n-1) 40 | printf("%d\n", left[l-1]); 41 | else 42 | printf("%d\n", hcf(left[l-1], right[r+1])); 43 | } 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/practice/generouskefa.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char s[10100]; 5 | int freq[100]; 6 | 7 | int main(void) { 8 | int n, k; 9 | scanf("%d %d", &n, &k); 10 | scanf("%s", s); 11 | for (int i = 0; i < n; i++) 12 | freq[s[i] - 'a']++; 13 | // try to assign each color to different friends 14 | // if some color gets left, you're fucked 15 | for (int i = 0; i < 26; i++) { 16 | for (int j = 0; j < k; j++) 17 | if (freq[i]) freq[i]--; 18 | if (freq[i]) { 19 | printf("NO\n"); 20 | return 0; 21 | } 22 | } 23 | printf("YES\n"); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /src/practice/godsend.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(void) { 5 | int n; 6 | scanf("%d", &n); 7 | int cnt = 0; 8 | for (int i = 0; i < n; i++) { 9 | int x; 10 | scanf("%d", &x); 11 | cnt += x % 2; 12 | } 13 | if (cnt > 0) 14 | printf("First\n"); 15 | else 16 | printf("Second\n"); 17 | return 0; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /src/practice/graph/greg.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int done[600]; 5 | int adj[600][600]; 6 | int main(void) { 7 | memset(done, 0, sizeof(done)); 8 | int n; 9 | scanf("%d", &n); 10 | for (int i = 1; i <= n; i++) { 11 | for (int j = 1; j <= n; j++) 12 | scanf("%d", &adj[i][j]); 13 | } 14 | vector order; 15 | for (int i = 1; i <= n; i++) { 16 | int x; 17 | scanf("%d", &x); 18 | order.push_back(x); 19 | } 20 | reverse(order.begin(), order.end()); 21 | vector ans; 22 | for (int i = 0; i < order.size(); i++) { 23 | int via = order[i]; 24 | done[via] = 1; 25 | long long x = 0; 26 | for (int i = 1; i <= n; i++) { 27 | for (int j = 1; j <= n; j++) { 28 | if (adj[i][j] > adj[i][via] + adj[via][j]) 29 | adj[i][j] = adj[i][via] + adj[via][j]; 30 | if (done[i] && done[j]) 31 | x += adj[i][j]; 32 | } 33 | } 34 | ans.push_back(x); 35 | } 36 | for (int i = ans.size() - 1; i >= 0; i--) 37 | printf("%I64d ", ans[i]); 38 | printf("\n"); 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /src/practice/graph/zerotree.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | ll up[100100]; 8 | ll down[100100]; 9 | int a[100100]; 10 | 11 | vector graph[100100]; 12 | 13 | void dfs(int u, int p) { 14 | for (int i = 0; i < graph[u].size(); i++) { 15 | int v = graph[u][i]; 16 | if (v != p) { 17 | dfs(v, u); 18 | up[u] = max(up[u], up[v]); 19 | down[u] = max(down[u], down[v]); 20 | } 21 | } 22 | ll val = a[u] + up[u] - down[u]; 23 | if (val < 0) 24 | up[u] -= val; 25 | else 26 | down[u] += val; 27 | } 28 | 29 | int main(void) { 30 | int n; 31 | scanf("%d", &n); 32 | for (int i = 1; i < n; i++) { 33 | int u, v; 34 | scanf("%d %d", &u, &v); 35 | graph[u].push_back(v); 36 | graph[v].push_back(u); 37 | } 38 | for (int i = 1; i <= n; i++) 39 | scanf("%d", &a[i]); 40 | dfs(1, -1); 41 | printf("%lld\n", up[1] + down[1]); 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /src/practice/haybale.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int cmp(const void* a, const void* b) { 5 | return *((int *) a) - *((int *) b); 6 | } 7 | 8 | int main(void) { 9 | int n, k, i; 10 | scanf("%d %d", &n, &k); 11 | int* arr = (int*) calloc(n, 4); 12 | while (k--) { 13 | int a, b; 14 | scanf("%d %d", &a, &b); 15 | arr[a-1]++; 16 | arr[b]--; 17 | } 18 | for (i = 1; i < n; i++) { 19 | arr[i] = arr[i] + arr[i-1]; 20 | } 21 | qsort(arr, n, 4, cmp); 22 | printf("%d\n", arr[n/2]); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /src/practice/iceskating.cpp: -------------------------------------------------------------------------------- 1 | /** http://codeforces.com/problemset/problem/217/A */ 2 | #include 3 | using namespace std; 4 | 5 | class node { 6 | public: int x, y; 7 | vector adj; 8 | int visited; 9 | }; 10 | 11 | node* graph; 12 | 13 | void dfs(int cur) { 14 | graph[cur].visited = 1; 15 | for (int i = 0; i < graph[cur].adj.size(); i++) { 16 | if (graph[graph[cur].adj[i]].visited == 0) 17 | dfs(graph[cur].adj[i]); 18 | } 19 | } 20 | 21 | int main(void) { 22 | int n; 23 | scanf("%d", &n); 24 | graph = (node*) calloc(n+10, sizeof(node)); 25 | for (int i = 0; i < n; i++) 26 | scanf("%d %d", &graph[i].x, &graph[i].y); 27 | for (int i = 0; i < n; i++) { 28 | for (int j = 0; j < n; j++) { 29 | if (graph[i].x == graph[j].x || graph[i].y == graph[j].y) 30 | graph[i].adj.push_back(j); 31 | } 32 | } 33 | int count = 0; 34 | for (int i = 0; i < n; i++) { 35 | if (graph[i].visited == 0) { 36 | count++; 37 | dfs(i); 38 | } 39 | } 40 | printf("%d\n", count-1); 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /src/practice/ladder/beautifulmatrix.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | 8 | int main(void) { 9 | for (int i = 0; i < 5; i++) { 10 | for (int j = 0; j < 5; j++) { 11 | int x; 12 | scanf("%d", &x); 13 | if (x == 1) { 14 | int ans = abs(i - 2) + abs(j - 2); 15 | printf("%d\n", ans); 16 | return 0; 17 | } 18 | } 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /src/practice/ladder/bitplusplus.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(void) { 5 | int n, x = 0; 6 | scanf("%d", &n); 7 | for (int i = 1; i <= n; i++) { 8 | char s[5]; 9 | scanf("%s", s); 10 | if (s[1] == '+') 11 | x++; 12 | else 13 | x--; 14 | } 15 | printf("%d\n", x); 16 | } 17 | -------------------------------------------------------------------------------- /src/practice/ladder/boredom.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | ll dp[100100]; 6 | ll freq[100100]; 7 | 8 | ll solve(int x) { 9 | if (x <= 0) 10 | return 0; 11 | if (dp[x] != -1) 12 | return dp[x]; 13 | 14 | ll ans = max(solve(x - 1), freq[x] * x + solve(x - 2)); 15 | return dp[x] = ans; 16 | } 17 | 18 | int main(void) { 19 | memset(dp, -1, sizeof(dp)); 20 | int n, x; 21 | scanf("%d", &n); 22 | for (int i = 1; i <= n; i++) { 23 | scanf("%d", &x); 24 | freq[x]++; 25 | } 26 | printf("%lld\n", solve(100000)); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /src/practice/ladder/boyorgirl.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | 8 | set mp; 9 | char s[100100]; 10 | 11 | int main(void) { 12 | scanf("%s", s); 13 | int l = strlen(s); 14 | for (int i = 0; i < l; i++) { 15 | mp.insert(s[i]); 16 | } 17 | if ((int)mp.size() % 2 == 0) 18 | printf("CHAT WITH HER!\n"); 19 | else 20 | printf("IGNORE HIM!\n"); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /src/practice/ladder/buildperm.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | int a[400100]; 6 | 7 | int main(void) { 8 | int n; 9 | scanf("%d", &n); 10 | for (int i = 0; i < n; i++) 11 | scanf("%d", a + i); 12 | sort(a, a + n); 13 | ll ans = 0; 14 | for (int i = 0; i < n; i++) 15 | ans += abs(i + 1 - a[i]); 16 | printf("%lld\n", ans); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /src/practice/ladder/capitalization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | 8 | char s[10010]; 9 | int main(void) { 10 | scanf("%s", s); 11 | if (s[0] >= 'a' && s[0] <= 'z') 12 | s[0] = s[0] - 'a' + 'A'; 13 | printf("%s\n", s); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /src/practice/ladder/chess.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(void) { 5 | int n; 6 | scanf("%d", &n); 7 | if (n & 1) { 8 | printf("black\n"); 9 | } 10 | else { 11 | printf("white\n"); 12 | printf("1 2\n"); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/practice/ladder/cutribbon.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | const int inf = 1e9; 4 | int n, a, b, c; 5 | int dp[5010]; 6 | 7 | int solve(int n) { 8 | if (n == 0) 9 | return 0; 10 | if (dp[n] != -1) 11 | return dp[n]; 12 | int ans = -inf; 13 | if (a <= n) 14 | ans = max(ans, solve(n - a) + 1); 15 | if (b <= n) 16 | ans = max(ans, solve(n - b) + 1); 17 | if (c <= n) 18 | ans = max(ans, solve(n - c) + 1); 19 | return dp[n] = ans; 20 | } 21 | 22 | int main(void) { 23 | memset(dp, -1, sizeof(dp)); 24 | scanf("%d %d %d %d", &n, &a, &b, &c); 25 | printf("%d\n", solve(n)); 26 | } 27 | -------------------------------------------------------------------------------- /src/practice/ladder/digits.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct num { 5 | int val, req; 6 | bool operator< (const num& a) const { 7 | if (req == a.req) 8 | return val > a.val; 9 | return req < a.req; 10 | } 11 | } digits[30], correct[30]; 12 | 13 | int main(void) { 14 | int v; 15 | scanf("%d", &v); 16 | for (int i = 1; i <= 9; i++) { 17 | digits[i].val = i; 18 | scanf("%d", &digits[i].req); 19 | correct[i].val = i; 20 | correct[i].req = digits[i].req; 21 | } 22 | sort(digits + 1, digits + 10); 23 | int len = v / digits[1].req; 24 | if (len == 0) { 25 | printf("-1\n"); 26 | return 0; 27 | } 28 | int rem = v - len * digits[1].req; 29 | for (int i = 0; i < len; i++) { 30 | for (int i = 9; i >= 1; i--) { 31 | if (correct[i].req <= digits[1].req + rem) { 32 | printf("%d", i); 33 | rem += digits[1].req - correct[i].req; 34 | break; 35 | } 36 | } 37 | } 38 | return 0; 39 | } 40 | 41 | -------------------------------------------------------------------------------- /src/practice/ladder/dragons.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct dragon { 5 | int x, y; 6 | } dragons[100100]; 7 | 8 | bool cmp(const dragon& a, const dragon& b) { 9 | if (a.x == b.x) 10 | return a.y > b.y; 11 | return a.x < b.x; 12 | } 13 | 14 | int main(void) { 15 | int s, n; 16 | scanf("%d %d", &s, &n); 17 | for (int i = 1; i <= n; i++) 18 | scanf("%d %d", &dragons[i].x, &dragons[i].y); 19 | sort(dragons + 1, dragons + 1 + n, cmp); 20 | for (int i = 1; i <= n; i++) { 21 | if (s <= dragons[i].x) { 22 | printf("NO\n"); 23 | return 0; 24 | } 25 | s += dragons[i].y; 26 | } 27 | printf("YES\n"); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /src/practice/ladder/dubstep.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char s[210]; 5 | 6 | char wub[5] = "WUB"; 7 | 8 | string ans; 9 | 10 | int main(void) { 11 | scanf("%s", s); 12 | int l = strlen(s); 13 | for (int i = 0; i < l; ) { 14 | int flag = 1; 15 | for (int cnt = 0; cnt < 3; cnt++) { 16 | if (i + cnt >= l || s[i + cnt] != wub[cnt]) 17 | flag = 0; 18 | } 19 | if (flag == 0) { 20 | ans += s[i]; 21 | i++; 22 | } 23 | else { 24 | ans += ' '; 25 | i += 3; 26 | } 27 | } 28 | int lead = 1; 29 | for (int i = 0; i < ans.length();) { 30 | char ch = ans[i]; 31 | while (lead && ans[i] == ' ') 32 | i++; 33 | lead = 0; 34 | if (ans[i] == ' ') { 35 | printf(" "); 36 | while (ans[i] == ' ') 37 | i++; 38 | } 39 | else { 40 | printf("%c", ans[i]); 41 | i++; 42 | } 43 | } 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /src/practice/ladder/dzysequence.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int n; 4 | int a[100100]; 5 | int l[100100]; 6 | int r[100100]; 7 | 8 | int main(void) { 9 | scanf("%d", &n); 10 | for (int i = 1; i <= n; i++) 11 | scanf("%d", a+i); 12 | if (n == 1) { 13 | printf("1\n"); 14 | return 0; 15 | } 16 | 17 | l[1] = 1; 18 | for (int i = 2; i <= n; i++) 19 | l[i] = a[i] > a[i - 1] ? l[i - 1] + 1 : 1; 20 | 21 | r[n] = 1; 22 | for (int i = n - 1; i >= 1; i--) 23 | r[i] = a[i + 1] > a[i] ? r[i + 1] + 1 : 1; 24 | 25 | int ans = 2; 26 | for (int i = 1; i <= n; i++) { 27 | if (2 <= i && i <= n - 1 && a[i - 1] < a[i + 1] - 1) 28 | ans = max(ans, l[i - 1] + 1 + r[i + 1]); 29 | else 30 | ans = max(ans, 1 + max(l[i - 1], r[i + 1])); 31 | } 32 | printf("%d\n", ans); 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /src/practice/ladder/fence.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | 8 | int a[200100]; 9 | int pref[200100]; 10 | 11 | int main(void) { 12 | int n, k; 13 | scanf("%d %d", &n, &k); 14 | for (int i = 1; i <= n; i++) { 15 | scanf("%d", a + i); 16 | pref[i] = pref[i - 1] + a[i]; 17 | } 18 | int ans = inf, ansid = -1; 19 | for (int i = 1; i + k - 1 <= n; i++) { 20 | if (ans > pref[i + k - 1] - pref[i - 1]) { 21 | ans = pref[i + k - 1] - pref[i - 1]; 22 | ansid = i; 23 | } 24 | } 25 | cout << ansid << endl; 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /src/practice/ladder/football.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char s[110]; 5 | 6 | int main(void) { 7 | scanf("%s", s); 8 | int l = strlen(s); 9 | int mx = 0; 10 | for (int i = 0; i < l; ) { 11 | char ch = s[i]; 12 | int cnt = 0; 13 | while (i < l && s[i] == ch) { 14 | cnt++; 15 | i++; 16 | } 17 | mx = max(cnt, mx); 18 | } 19 | printf("%s\n", mx >= 7 ? "YES" : "NO"); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /src/practice/ladder/hello.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char hello[10] = "hello"; 5 | char s[1000]; 6 | 7 | int main(void) { 8 | scanf("%s", s); 9 | int l = strlen(s); 10 | int nxt = 0; 11 | for (int i = 0; i < l; i++) { 12 | if (s[i] == hello[nxt]) { 13 | nxt++; 14 | if (nxt == 5) { 15 | printf("YES\n"); 16 | return 0; 17 | } 18 | } 19 | } 20 | printf("NO\n"); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /src/practice/ladder/ilyamatrix.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | ll pref[2001000]; 6 | ll a[2001000]; 7 | 8 | int main(void) { 9 | int cnt; 10 | scanf("%d", &cnt); 11 | int n = 0; 12 | int dup = cnt; 13 | for (int i = 1; i <= dup; i++) 14 | scanf("%lld", a+i); 15 | sort(a + 1, a + dup + 1, greater()); 16 | for (int i = 1; i <= dup; i++) 17 | pref[i] = pref[i - 1] + a[i]; 18 | ll ans = 0; 19 | while (cnt > 0) { 20 | int req = dup / cnt; 21 | ans += pref[req]; 22 | cnt /= 4; 23 | } 24 | printf("%lld\n", ans); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /src/practice/ladder/ktree.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | const int mod = 1e9 + 7; 4 | 5 | int n, k, d; 6 | int dp[200][4]; 7 | 8 | int solve(int need, int taken) { 9 | if (need < 0) 10 | return 0; 11 | if (need == 0) 12 | return taken; 13 | if (dp[need][taken] != -1) 14 | return dp[need][taken]; 15 | int ans = 0; 16 | for (int i = 1; i <= k; i++) { 17 | if (i < d) 18 | ans = (ans + solve(need - i, taken)) % mod; 19 | else 20 | ans = (ans + solve(need - i, 1)) % mod; 21 | } 22 | return dp[need][taken] = ans; 23 | } 24 | 25 | 26 | 27 | int main(void) { 28 | memset(dp, -1, sizeof(dp)); 29 | scanf("%d %d %d", &n, &k, &d); 30 | printf("%d\n", solve(n, 0)); 31 | } 32 | -------------------------------------------------------------------------------- /src/practice/ladder/lucky.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int lucky(int n) { 5 | while (n > 0) { 6 | if (n % 10 != 4 && n % 10 != 7) 7 | return 0; 8 | n = n / 10; 9 | } 10 | return 1; 11 | } 12 | 13 | 14 | int main(void) { 15 | int n; 16 | scanf("%d", &n); 17 | for (int i = 1; i <= n; i++) { 18 | if (n % i == 0 && lucky(i)) { 19 | printf("YES\n"); 20 | return 0; 21 | } 22 | } 23 | printf("NO\n"); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /src/practice/ladder/mafia.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | int a[100100]; 6 | 7 | int main(void) { 8 | ll n; 9 | scanf("%lld", &n); 10 | for (int i = 1; i <= n; i++) 11 | scanf("%d", a+i); 12 | sort(a + 1, a + n + 1); 13 | ll lo = a[n], hi = 2e9; 14 | while (lo < hi) { 15 | ll mid = (lo + hi) / 2; 16 | ll cnt = 0; 17 | for (int i = 1; i <= n; i++) 18 | cnt += mid - a[i]; 19 | if (cnt >= mid) 20 | hi = mid; 21 | else 22 | lo = mid + 1; 23 | } 24 | printf("%lld\n", lo); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /src/practice/ladder/magnets.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | 8 | int main(void) { 9 | int n, x; 10 | scanf("%d", &n); 11 | int prev = -1, cnt = 0; 12 | for (int i = 1; i <= n; i++) { 13 | scanf("%d", &x); 14 | x = x == 10 ? 0 : 1; 15 | if (prev == -1 || x != prev) 16 | cnt++; 17 | prev = x; 18 | } 19 | printf("%d\n", cnt); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /src/practice/ladder/oddeven.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | int main(void) { 6 | ll n, k; 7 | cin >> n >> k; 8 | ll even = n / 2; 9 | ll odd = n - even; 10 | if (odd >= k) { 11 | cout << 2 * (k - 1) + 1 << endl; 12 | } 13 | else { 14 | ll req = k - odd; 15 | cout << 2 * req << endl; 16 | } 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /src/practice/ladder/palindrometransformation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char s[100100]; 5 | 6 | int main(void) { 7 | int n, p; 8 | scanf("%d %d", &n, &p); 9 | p--; 10 | scanf("%s", s); 11 | int ans = 0; 12 | // adding up and downs 13 | for (int i = 0; i < n / 2; i++) 14 | ans += min(abs(s[i] - s[n - i - 1]), 26 - abs(s[i] - s[n - i - 1])); 15 | // now need to add left and right; 16 | int start, end; 17 | int first = n + 1, last = -1; 18 | if (p < n / 2) 19 | start = 0, end = n / 2 - 1; 20 | else 21 | start = n / 2, end = n - 1; 22 | for (int i = start; i <= p; i++) { 23 | if (s[i] != s[n - i - 1]) 24 | first = min(first, i); 25 | } 26 | for (int i = p; i <= end; i++) { 27 | if (s[i] != s[n - i - 1]) 28 | last = max(last, i); 29 | } 30 | int lr; 31 | if (first == n + 1 && last == -1) 32 | lr = 0; 33 | else if (first == n + 1) 34 | lr = abs(last - p); 35 | else if (last == -1) 36 | lr = abs(first - p); 37 | else 38 | lr = min(abs(p - first) + abs(last - first), abs(p - last) + abs(last - first)); 39 | ans += lr; 40 | printf("%d\n", ans); 41 | } 42 | -------------------------------------------------------------------------------- /src/practice/ladder/petyaandstrings.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | 8 | int main(void) { 9 | string s1, s2; 10 | cin >> s1 >> s2; 11 | for (int i = 0; i < s1.length(); i++) { 12 | s1[i] = tolower(s1[i]); 13 | s2[i] = tolower(s2[i]); 14 | } 15 | if (s1 == s2) 16 | printf("0\n"); 17 | else if (s1 < s2) 18 | printf("-1\n"); 19 | else 20 | printf("1\n"); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /src/practice/ladder/physicspractical.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | const int inf = 1e9; 4 | 5 | int a[100100]; 6 | 7 | int main(void) { 8 | FILE* in = fopen("input.txt", "r"); 9 | FILE* out = fopen("output.txt", "w"); 10 | int n; 11 | fscanf(in, "%d", &n); 12 | for (int i = 1; i <= n; i++) 13 | fscanf(in, "%d", a+i); 14 | sort(a + 1, a + n + 1); 15 | int ans = inf; 16 | for (int i = 1; i <= n; i++) { 17 | int mn = a[i]; 18 | int lo = 1, hi = n; 19 | int rem = i - 1; 20 | while (lo < hi) { 21 | int mid = (lo + hi) / 2; 22 | if (a[mid] > 2 * mn) 23 | hi = mid; 24 | else 25 | lo = mid + 1; 26 | } 27 | if (a[lo] > 2 * mn) 28 | rem += n - lo + 1; 29 | ans = min(ans, rem); 30 | } 31 | fprintf(out, "%d\n", ans); 32 | fclose(in); 33 | fclose(out); 34 | } 35 | -------------------------------------------------------------------------------- /src/practice/ladder/puzzle.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | const int inf = 1e9; 4 | 5 | int f[10010]; 6 | int main(void) { 7 | int n, m; 8 | scanf("%d %d", &n, &m); 9 | for (int i = 1; i <= m; i++) 10 | scanf("%d", f + i); 11 | sort(f + 1, f + m + 1); 12 | int ans = inf; 13 | for (int i = 1; i + n - 1 <= m; i++) 14 | ans = min(ans, f[i + n - 1] - f[i]); 15 | printf("%d\n", ans); 16 | } 17 | -------------------------------------------------------------------------------- /src/practice/ladder/ringroad.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | int n, m; 6 | int a[100100]; 7 | 8 | int dist(int x, int y) { 9 | if (x <= y) 10 | return y - x; 11 | else 12 | return n + y - x; 13 | } 14 | 15 | int main(void) { 16 | scanf("%d %d", &n, &m); 17 | for (int i = 1; i <= m; i++) 18 | scanf("%d", a + i); 19 | int house = 1; 20 | ll ans = 0; 21 | for (int i = 1; i <= m; i++) { 22 | ans += dist(house, a[i]); 23 | house = a[i]; 24 | } 25 | printf("%lld\n", ans); 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /src/practice/ladder/systemofequations.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(void) { 5 | int n, m; 6 | int cnt = 0; 7 | scanf("%d %d", &n, &m); 8 | for (int a = 0; a <= 1000; a++) { 9 | for (int b = 0; b <= 1000; b++) { 10 | int one = a * a + b; 11 | int two = a + b * b; 12 | if (one == n && two == m) 13 | cnt++; 14 | } 15 | } 16 | printf("%d\n", cnt); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /src/practice/ladder/team.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | 8 | int main(void) { 9 | int n; 10 | scanf("%d", &n); 11 | int cnt = 0; 12 | for (int i = 1; i <= n; i++) { 13 | int a, b, c; 14 | scanf("%d %d %d", &a, &b, &c); 15 | if (a + b + c >= 2) 16 | cnt++; 17 | } 18 | printf("%d\n", cnt); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /src/practice/ladder/toaddornot.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | ll a[100100]; 6 | ll pref[100100]; 7 | 8 | int main(void) { 9 | int n, k; 10 | scanf("%d %d", &n, &k); 11 | for (int i = 1; i <= n; i++) 12 | scanf("%lld", a+i); 13 | sort(a + 1, a + n + 1); 14 | for (int i = 1; i <= n; i++) 15 | pref[i] = pref[i - 1] + a[i]; 16 | int ans = -1; ll ansv; 17 | for (int i = 1; i <= n; ) { 18 | int x = a[i]; 19 | while (i <= n && a[i] == x) 20 | i++; 21 | int last = i - 1; 22 | int lo = 1, hi = last; 23 | while (lo < hi) { 24 | int mid = (lo + hi) / 2; 25 | ll cnt = last - mid + 1; 26 | ll req = a[last] * cnt - (pref[last] - pref[mid - 1]); 27 | if (req <= k) 28 | hi = mid; 29 | else 30 | lo = mid + 1; 31 | } 32 | if (ans < last - lo + 1) { 33 | ans = last - lo + 1; 34 | ansv = a[last]; 35 | } 36 | } 37 | printf("%d %lld\n", ans, ansv); 38 | } 39 | -------------------------------------------------------------------------------- /src/practice/ladder/tprimes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | int sieve[1001000]; 6 | set tprimes; 7 | 8 | int main(void) { 9 | for (int i = 2; i <= 1e6; i++) { 10 | if (sieve[i] == 0) { 11 | tprimes.insert((ll)i * i); 12 | for (int j = i; j <= 1e6; j += i) 13 | sieve[j] = 1; 14 | } 15 | } 16 | 17 | int n; 18 | scanf("%d", &n); 19 | for (int i = 1; i <= n; i++) { 20 | ll x; 21 | scanf("%lld", &x); 22 | if (tprimes.count(x)) 23 | printf("YES\n"); 24 | else 25 | printf("NO\n"); 26 | } 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /src/practice/ladder/waytoolong.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | char s[110]; 4 | 5 | int main(void) { 6 | int n; 7 | scanf("%d", &n); 8 | for (int i = 1; i <= n; i++) { 9 | scanf("%s", s); 10 | int l = strlen(s); 11 | if (l <= 10) 12 | printf("%s\n", s); 13 | else 14 | printf("%c%d%c\n", s[0], l - 2, s[l - 1]); 15 | } 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /src/practice/ladder/wifi.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char s[10010]; 5 | char s2[10010]; 6 | int n, cx; 7 | int cnt, total; 8 | 9 | void get(int x, int here) { 10 | if (here == n) { 11 | if (x == cx) 12 | cnt++; 13 | total++; 14 | } 15 | else { 16 | if (s2[here] == '?') { 17 | get(x + 1, here + 1); 18 | get(x - 1, here + 1); 19 | } 20 | else if (s2[here] == '+') 21 | get(x + 1, here + 1); 22 | else 23 | get(x - 1, here + 1); 24 | } 25 | } 26 | 27 | int main(void) { 28 | scanf("%s", s); 29 | scanf("%s", s2); 30 | n = strlen(s); 31 | for (int i = 0; i < n; i++) { 32 | if (s[i] == '+') 33 | cx++; 34 | else 35 | cx--; 36 | } 37 | get(0, 0); 38 | printf("%.15lf\n", cnt / (double) total); 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /src/practice/ladder/xorandor.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char s1[1001000], s2[1001000]; 5 | int main(void) { 6 | scanf("%s", s1); 7 | scanf("%s", s2); 8 | int l1 = strlen(s1), l2 = strlen(s2); 9 | if (l1 != l2) { 10 | printf("NO\n"); 11 | return 0; 12 | } 13 | int one1 = 0, one2 = 0; 14 | for (int i = 0; i < l1; i++) 15 | one1 += s1[i] == '1'; 16 | for (int i = 0; i < l2; i++) 17 | one2 += s2[i] == '1'; 18 | printf("%s\n", (one1 == 0 && one2 == 0) || (one2 > 0 && one1 > 0) ? "YES" : "NO"); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /src/practice/ladder/youngphysicist.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef pair pii; 4 | typedef long long ll; 5 | const int inf = 1e9 + 10; 6 | const ll infll = 1e18 + 500; 7 | 8 | int sum[5]; 9 | 10 | int main(void) { 11 | int n, x; 12 | scanf("%d", &n); 13 | while (n--) { 14 | for (int i = 1; i <= 3; i++) { 15 | scanf("%d", &x); 16 | sum[i] += x; 17 | } 18 | } 19 | printf("%s\n", sum[1] == 0 && sum[2] == 0 && sum[3] == 0 ? "YES" : "NO"); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /src/practice/luckfour.hs: -------------------------------------------------------------------------------- 1 | findNumFours :: String -> Int 2 | findNumFours str = helper 0 str 3 | where 4 | helper num [] = num 5 | helper num (x:xs) = if x == '4' 6 | then helper (num+1) xs 7 | else helper num xs 8 | 9 | doterms :: Integer -> IO () 10 | doterms 1 = do 11 | str <- getLine 12 | putStrLn . show $ findNumFours str 13 | return () 14 | doterms x = do 15 | str <- getLine 16 | putStrLn . show $ findNumFours str 17 | doterms (x-1) 18 | 19 | main = do 20 | terms <- getLine 21 | doterms (read terms::Integer) 22 | -------------------------------------------------------------------------------- /src/practice/luckyfour.py: -------------------------------------------------------------------------------- 1 | terms = int(raw_input()) 2 | for term in range(terms): 3 | number = raw_input() 4 | print number.count('4') 5 | -------------------------------------------------------------------------------- /src/practice/mathbond.java: -------------------------------------------------------------------------------- 1 | import java.io.*; 2 | class MathBond { 3 | public static void main(String[] args) throws Exception { 4 | InputStreamReader isr = new InputStreamReader(System.in); 5 | BufferedReader in = new BufferedReader(isr); 6 | int terms = Integer.parseInt(in.readLine()); 7 | for(int q=0; q 2 | int main( void ){ 3 | int terms; 4 | scanf("%d", &terms); 5 | while( terms-- ){ 6 | int n; 7 | scanf("%d", &n); 8 | int arr[n]; 9 | int freq[10001] = {0}; 10 | int i, num = 0, max_count = 0; 11 | for( i=0; i max_count ){ 15 | num = arr[i]; 16 | max_count = freq[arr[i]]; 17 | } 18 | else if(freq[arr[i]] == max_count) 19 | num = (num < arr[i]) ? num : arr[i]; 20 | } 21 | printf("%d %d\n",num, max_count); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/practice/misc/max.or.subarray.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int cnt[40]; 5 | int n, max_or; 6 | int a[101000]; 7 | 8 | void change(int x, int sign) { 9 | for (int i = 0; i < 30; i++) 10 | cnt[i] += sign * ((x >> i) & 1); 11 | } 12 | 13 | int get() { 14 | int val = 0; 15 | for (int i = 0; i < 30; i++) 16 | if (cnt[i] > 0) 17 | val |= (1 << i); 18 | return val; 19 | } 20 | 21 | 22 | int check(int l) { 23 | memset(cnt, 0, sizeof(cnt)); 24 | for (int i = 1; i <= l; i++) 25 | change(a[i], +1); 26 | if (get() == max_or) return 1; 27 | for (int remove = 1, add = l + 1; add <= n; add++, remove++) { 28 | change(a[remove], -1); 29 | change(a[add], +1); 30 | if (get() == max_or) return 1; 31 | } 32 | return 0; 33 | } 34 | 35 | 36 | int main(void) { 37 | scanf("%d", &n); 38 | for (int i = 1; i <= n; i++) { 39 | scanf("%d", &a[i]); 40 | max_or |= a[i]; 41 | } 42 | int lo = 1, hi = n; 43 | while (lo < hi) { 44 | int mid = (lo + hi) / 2; 45 | if (check(mid)) 46 | hi = mid; 47 | else 48 | lo = mid + 1; 49 | } 50 | printf("%d\n", lo); 51 | } 52 | -------------------------------------------------------------------------------- /src/practice/misc/okabe.and.boxes-821C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | char s[20]; 6 | 7 | int main(void) { 8 | int n; 9 | scanf("%d", &n); 10 | int cnt = 0; // count of number of remove commands issued 11 | int cur = 1; 12 | stack st; 13 | for (int i = 1; i <= 2*n; i++) { 14 | scanf("%s", s); 15 | if (s[0] == 'a') { 16 | int x; 17 | scanf("%d", &x); 18 | st.push(x); 19 | } 20 | else { 21 | cur++; 22 | if (st.empty()) continue; 23 | if (st.top() == cur - 1) { 24 | st.pop(); 25 | } 26 | else { 27 | cnt++; 28 | while (!st.empty()) st.pop(); 29 | } 30 | } 31 | } 32 | printf("%d\n", cnt); 33 | } 34 | -------------------------------------------------------------------------------- /src/practice/mixtures.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(void) { 6 | int n; 7 | while (scanf("%d", &n) != EOF) { 8 | int a[n]; 9 | int i, j, k; 10 | for (i = 0; i < n; i++) 11 | scanf("%d", a+i); 12 | int cost[n][n]; 13 | int result[n][n]; 14 | 15 | // initializing base cases of dp table 16 | for (i = 0; i < n; i++) { 17 | cost[i][i] = 0; 18 | result[i][i] = a[i]; 19 | } 20 | 21 | // filling up dp table bottom up 22 | for (i = 2; i <= n; i++) { 23 | for (j = 0; j < n - i + 1; j++) { 24 | int dest = j + i - 1; 25 | cost[j][dest] = INT_MAX; 26 | for (k = j; k < dest; k++) { 27 | int x = cost[j][k] + cost[k+1][dest] + (result[j][k] * result[k+1][dest]); 28 | int res = (result[j][k] + result[k+1][dest]) % 100; 29 | if (x < cost[j][dest]) { 30 | cost[j][dest] = x; 31 | result[j][dest] = res; 32 | } 33 | } 34 | } 35 | } 36 | 37 | printf("%d\n", cost[0][n-1]); 38 | } 39 | return 0; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /src/practice/mpilot.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define min(a, b) a 2 | int v[10]; 3 | 4 | int dp[100100][20]; 5 | int k; 6 | 7 | int can(int req, int i) { 8 | if (dp[req][i] != -1) 9 | return dp[req][i]; 10 | if (req == 0) 11 | return dp[req][i] = 1; 12 | if (i == 0) 13 | return dp[req][i] = (req % v[i] == 0); 14 | else { 15 | int use = 0; 16 | while (req >= use * v[i]) { 17 | if (can(req - use * v[i], i - 1)) 18 | return dp[req][i] = 1; 19 | use++; 20 | } 21 | return dp[req][i] = 0; 22 | } 23 | } 24 | 25 | int main(void) { 26 | for (int i = 0; i < 100100; i++) 27 | for (int j = 0; j < 20; j++) 28 | dp[i][j] = -1; 29 | int x; 30 | scanf("%d", &x); 31 | scanf("%d", &k); 32 | for (int i = 0; i < k; i++) 33 | scanf("%d", v+i); 34 | for (int i = 1; i < k; i++) 35 | v[i] = v[i] + v[i-1]; 36 | if (can(x, k-1)) 37 | printf("YES\n"); 38 | else 39 | printf("NO\n"); 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /src/practice/nondecreasingdigits.cpp: -------------------------------------------------------------------------------- 1 | // dp(l, start): number of numbers that can be made of length l starting with start 2 | // dp(1, x) = 1 3 | // dp(a, b) = dp(a-1, b) + dp(a-1, b+1) ... 4 | 5 | #include 6 | long long int dp[100][20]; 7 | 8 | long long int calc(int l, int start) { 9 | if (dp[l][start] != -1) 10 | return dp[l][start]; 11 | if (l == 1) 12 | return dp[l][start] = 1; 13 | long long int sol = 0; 14 | for (int i = start; i < 10; i++) 15 | sol += calc(l-1, i); 16 | return dp[l][start] = sol; 17 | } 18 | 19 | int main(void) { 20 | for (int i = 0; i < 100; i++) 21 | for (int j = 0; j < 20; j++) 22 | dp[i][j] = -1; 23 | int t; 24 | scanf("%d", &t); 25 | while (t--) { 26 | int no, l; 27 | scanf("%d %d", &no, &l); 28 | long long int ans = 0; 29 | for (int i = 0; i < 10; i++) 30 | ans += calc(l, i); 31 | printf("%d %lld\n", no, ans); 32 | } 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /src/practice/nsteps.c: -------------------------------------------------------------------------------- 1 | // Author: Param Singh 2 | // Number Steps: http://www.spoj.com/problems/NSTEPS/ 3 | 4 | #include 5 | 6 | int main(void) { 7 | int n; 8 | scanf("%d", &n); 9 | while (n--) { 10 | int x, y; 11 | scanf("%d%d", &x, &y); 12 | if (x == y) { 13 | if (x % 2 == 0) 14 | printf("%d\n", x+y); 15 | else 16 | printf("%d\n", x+y-1); 17 | } 18 | else if (x == y+2) { 19 | if (x % 2 == 0) 20 | printf("%d\n", x+y); 21 | else 22 | printf("%d\n", x+y-1); 23 | } 24 | else 25 | printf("No Number\n"); 26 | } 27 | return 0; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /src/practice/numbers/cprime.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | const int lim = 100000000 + 5; 4 | 5 | int sieve[lim >> 6]; 6 | int pi[lim]; 7 | 8 | int main(void) { 9 | for (int i = 3; i <= sqrt(lim); i+=2) { 10 | if (sieve[i >> 6] & (1 << ((i >> 1) & 31))) 11 | continue; 12 | else { 13 | int k = i << 1; 14 | for (int j = i * i; j <= lim; j += k) 15 | sieve[j >> 6] |= (1 << ((j >> 1) & 31)); 16 | } 17 | } 18 | pi[2] = 1; 19 | for (int i = 3; i <= lim; i++) { 20 | int c = 1; 21 | if (i % 2 == 0 || (sieve[i >> 6] & (1 << ((i >> 1) & 31)))) 22 | c = 0; 23 | pi[i] = pi[i - 1] + c; 24 | } 25 | 26 | int x; 27 | scanf("%d", &x); 28 | while (x != 0) { 29 | double l = x / log(x); 30 | printf("%.1lf\n", fabs(pi[x] - l) * 100.0 / pi[x]); 31 | scanf("%d", &x); 32 | } 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/1.py: -------------------------------------------------------------------------------- 1 | print sum([x for x in range(1, 1000) if x % 3 == 0 or x % 5 == 0]) 2 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/10.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(void) { 5 | int* seive = (int *) calloc(2000001, 4); 6 | int i; 7 | long long int sum = 0; 8 | for (i = 2; i < 2000001; i++) { 9 | if (seive[i] == 0) { 10 | sum += i; 11 | int j; 12 | for (j = i; j < 2000001; j+=i) 13 | seive[j] = 1; 14 | } 15 | } 16 | printf("%lld\n", sum); 17 | return 0; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/12.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define MAX 80000000 4 | 5 | int main(void) { 6 | int* seive = (int *) calloc(MAX, sizeof(int)); 7 | int i, j; 8 | for (i = 2; i < MAX; i++) { 9 | if (seive[i] == 0) { 10 | for (j = i; j < MAX; j+=i) 11 | seive[j] = i; 12 | } 13 | } 14 | long long int sum = 1; 15 | long long int factors = 1; 16 | for (i = 2; i < MAX; i++) { 17 | sum += i; 18 | long long int x = sum; 19 | int prev = seive[x], count = 1; 20 | int val = 1; 21 | while (x != 1) { 22 | x /= seive[x]; 23 | if (seive[x] == prev) 24 | count++; 25 | else { 26 | val *= count + 1; 27 | count = 1; 28 | } 29 | prev = seive[x]; 30 | } 31 | if (val > 500) { 32 | printf("%lld\n", sum); 33 | break; 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/13.py: -------------------------------------------------------------------------------- 1 | ans = 0 2 | for _ in range(100): 3 | x = int(raw_input()) 4 | ans += x 5 | print str(ans)[0:10] 6 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/15.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | long long int dp[30][30]; 5 | int i, j; 6 | for (i = 0; i <= 20; i++) { 7 | for (j = 0; j <= 20; j++) { 8 | if (i == 0 || j == 0) 9 | dp[i][j] = 1; 10 | else 11 | dp[i][j] = dp[i-1][j] + dp[i][j-1]; 12 | } 13 | } 14 | printf("%lld\n", dp[20][20]); 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/18.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define max(a, b) a>b?a:b 3 | 4 | int main(void) { 5 | int a[500][500]; 6 | int i, j; 7 | int n; 8 | scanf("%d", &n); 9 | for (i = 0; i < n; i++) { 10 | for (j = 0; j < i+1; j++) 11 | scanf("%d", &a[i][j]); 12 | } 13 | int dp[500][500]; 14 | for (i = n-1; i >= 0; i--) { 15 | for (j = 0; j < i+1; j++) { 16 | if (i == n-1) 17 | dp[i][j] = a[i][j]; 18 | else { 19 | int x = a[i][j]; 20 | int y = max(dp[i+1][j], dp[i+1][j+1]); 21 | dp[i][j] = x + y; 22 | } 23 | } 24 | } 25 | printf("%d\n", dp[0][0]); 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/2.py: -------------------------------------------------------------------------------- 1 | a = 1 2 | b = 2 3 | ans = 0 4 | while a < 4 * 10**6: 5 | if a % 2 == 0: 6 | ans += a 7 | a, b = b, a+b 8 | print ans 9 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/20.py: -------------------------------------------------------------------------------- 1 | import operator 2 | fact = reduce(operator.mul, [x for x in range(1, 101)]) 3 | print reduce(operator.add, map(lambda x: ord(x) - ord('0'), str(fact))) 4 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/22.py: -------------------------------------------------------------------------------- 1 | # take sorted names as input 2 | ans = 0 3 | for i in range(1, 5164): 4 | t = raw_input() 5 | v = 0 6 | for ch in t: 7 | v += ord(ch) - ord('A') + 1 8 | if t == "COLIN": 9 | print v*i 10 | ans += v * i 11 | print ans 12 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/25.py: -------------------------------------------------------------------------------- 1 | a = 1 2 | b = 1 3 | count = 2 4 | while a < 10**999: 5 | a, b = b, a + b 6 | count += 1 7 | print a 8 | print count-1 9 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/26.hs: -------------------------------------------------------------------------------- 1 | import Data.List 2 | order n = elemIndex True $ map (\x -> mod x n == 1) [10^x | x <- [1..1000]] 3 | main = print . snd . maximum $ map (\x -> (order x, x)) [1..1001] 4 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/3.py: -------------------------------------------------------------------------------- 1 | primes = set() 2 | seive = [0 for _ in range(5* 10**6)] 3 | val = 600851475143 4 | mx = 1 5 | for i in range(2, 5* 10**6): 6 | if seive[i] == 0: 7 | j = i 8 | primes.add(i) 9 | if val % i == 0 and val > mx: 10 | mx = i 11 | val /= i 12 | while j < 5* 10**6: 13 | seive[j] = 1; 14 | j += i 15 | 16 | print mx 17 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/4.py: -------------------------------------------------------------------------------- 1 | import sys 2 | mx = 0 3 | for i in range(999, 99, -1): 4 | for j in range(999, 99, -1): 5 | if str(i*j) == str(i*j)[::-1]: 6 | mx = max(mx, i*j) 7 | print mx 8 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/42.py: -------------------------------------------------------------------------------- 1 | triangle = set() 2 | s = 0 3 | for i in range(1, 1000): 4 | s += i 5 | triangle.add(s) 6 | ans = 0 7 | for _ in range(1786): 8 | word = raw_input() 9 | x = 0 10 | for ch in word: 11 | x += ord(ch) - ord('A') + 1 12 | if x in triangle: 13 | ans += 1 14 | print ans 15 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/47.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define MAX 10000000 4 | 5 | int* seive; 6 | 7 | int distinct(int n) { 8 | int x = seive[n], prev = 1; 9 | int count = 0; 10 | while (n != 1) { 11 | if (x != prev) { 12 | count++; 13 | } 14 | prev = x; 15 | n /= x; 16 | x = seive[n]; 17 | } 18 | return count; 19 | } 20 | int main(void) { 21 | seive = (int *) calloc(MAX, sizeof(int)); 22 | int i, j; 23 | for (i = 2; i < MAX; i++) { 24 | if (seive[i] == 0) { 25 | for (j = i; j < MAX; j+=i) 26 | seive[j] = i; 27 | } 28 | } 29 | int c = 0; 30 | int x = 1; 31 | int n = 4; 32 | while (c != n) { 33 | if (distinct(x) == n) 34 | c++; 35 | else 36 | c = 0; 37 | x++; 38 | } 39 | printf("%d\n", x-n); 40 | return 0; 41 | } 42 | 43 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/48.hs: -------------------------------------------------------------------------------- 1 | -- One way is using exponentiation by squaring 2 | big = 10^10 3 | power :: Integer -> Integer -> Integer 4 | power a b | b == 0 = 1 5 | | b == 1 = mod a big 6 | | mod b 2 == 0 = power (mod ((mod a big)*(mod a big)) big) (div b 2) 7 | | mod b 2 /= 0 = mod ((mod (power (mod ((mod a big) * (mod a big)) big) (div b 2)) big) * (mod a big)) big 8 | 9 | lst = [power x x | x <- [1..1000]] 10 | 11 | ans = foldr (\x y -> mod (x + y) big) 0 lst 12 | 13 | -- Another way 14 | ans2 = sum ([x^x | x <-[1..1000]]) `mod` big 15 | 16 | main = print ans 17 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/5.py: -------------------------------------------------------------------------------- 1 | def gcd(a, b): 2 | while b > 0: 3 | a, b = b, a % b 4 | return a 5 | 6 | def lcm(a, b): 7 | return a*b / gcd(a, b) 8 | 9 | ans = 1 10 | for i in range(1, 21): 11 | ans = lcm(ans, i) 12 | print ans 13 | 14 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/53.py: -------------------------------------------------------------------------------- 1 | c = [[0 for _ in range(101)] for _ in range(101)] 2 | 3 | for i in range(101): 4 | c[i][0] = 1 5 | c[i][1] = i 6 | 7 | mil = 10**6 8 | ans = 0 9 | for i in range(2, 101): 10 | for j in range(2, i+1): 11 | c[i][j] = c[i-1][j] + c[i-1][j-1] 12 | if c[i][j] > mil: 13 | ans += 1 14 | print ans 15 | 16 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/6.py: -------------------------------------------------------------------------------- 1 | print (100*101/2)**2 - (100*101*201/6) 2 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/69.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define SIZE 1000100 3 | 4 | int phi[SIZE]; 5 | 6 | int main(void) { 7 | int i; 8 | phi[1] = 1; 9 | for (i = 2; i < SIZE; i++) 10 | phi[i] = i; 11 | for (i = 2; i < SIZE; i++) { 12 | if (phi[i] == i) { 13 | for (int j = i; j < SIZE; j+=i) 14 | phi[j] -= phi[j] / i; 15 | } 16 | } 17 | float max = -1; 18 | int ans = 0; 19 | for (i = 2; i <= 1000000; i++) { 20 | if (max < i / (float) phi[i]) { 21 | max = i / (float) phi[i]; 22 | ans = i; 23 | } 24 | } 25 | printf("%d\n", ans); 26 | return 0; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/70.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define SIZE 10000020 3 | 4 | int phi[SIZE]; 5 | 6 | int check(int a, int b) { 7 | int af[10] = {0}; 8 | int bf[10] = {0}; 9 | while (a != 0) { 10 | af[a % 10]++; 11 | a /= 10; 12 | } 13 | while (b != 0) { 14 | bf[b % 10]++; 15 | b /= 10; 16 | } 17 | for (int i = 0; i < 10; i++) { 18 | if (af[i] != bf[i]) 19 | return 0; 20 | } 21 | return 1; 22 | } 23 | 24 | int main(void) { 25 | int i; 26 | phi[1] = 1; 27 | for (i = 2; i < SIZE; i++) 28 | phi[i] = i; 29 | for (i = 2; i < SIZE; i++) { 30 | if (phi[i] == i) { 31 | for (int j = i; j < SIZE; j += i) 32 | phi[j] -= phi[j] / i; 33 | } 34 | } 35 | int ans = 0; 36 | float min = 10000000; 37 | for (i = 2; i < 10000000; i++) { 38 | if (min > i / (float) phi[i] && check(i, phi[i])) { 39 | min = i / (float) phi[i]; 40 | ans = i; 41 | } 42 | } 43 | printf("%d\n", ans); 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/72.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define SIZE 1000100 3 | 4 | int phi[SIZE]; 5 | 6 | int main(void) { 7 | int i; 8 | phi[1] = 1; 9 | for (i = 2; i < SIZE; i++) 10 | phi[i] = i; 11 | for (i = 2; i < SIZE; i++) { 12 | if (phi[i] == i) { 13 | for (int j = i; j < SIZE; j+=i) 14 | phi[j] -= phi[j] / i; 15 | } 16 | } 17 | long long int sum = 0; 18 | for (i = 2; i <= 1000000; i++) 19 | sum += phi[i]; 20 | printf("%lld\n", sum); 21 | return 0; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/8.py: -------------------------------------------------------------------------------- 1 | num = raw_input() 2 | mx = 0 3 | for i in range(0, len(num)): 4 | pr = 1 5 | for j in range(i, i+13): 6 | if j >= len(num): 7 | continue 8 | pr *= ord(num[j]) - ord('0') 9 | mx = max(mx, pr) 10 | print mx 11 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/81.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define min(a, b) a= 0; i--) { 12 | if (i == 79) 13 | dp[79][i] = a[79][i]; 14 | else 15 | dp[79][i] = dp[79][i+1] + a[79][i]; 16 | } 17 | for (i = 78; i >= 0; i--) { 18 | for (j = 79; j >= 0; j--) { 19 | if (j == 79) 20 | dp[i][j] = a[i][j] + dp[i+1][j]; 21 | else 22 | dp[i][j] = a[i][j] + (min(dp[i+1][j], dp[i][j+1])); 23 | } 24 | } 25 | printf("%d\n", dp[0][0]); 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/9.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int a, b, c; 5 | for (a = 1; a < 1000; a++) { 6 | for (b = 1; b < 1000; b++) { 7 | c = 1000 - a - b; 8 | if (c < 0) 9 | break; 10 | else if (a*a + b*b == c*c) 11 | printf("%d %d %d %d\n", a, b, c, a*b*c); 12 | } 13 | } 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /src/practice/numbers/euler/fix.py: -------------------------------------------------------------------------------- 1 | for x in range(50): 2 | input() 3 | for _ in range(9): 4 | print(input()) 5 | 6 | -------------------------------------------------------------------------------- /src/practice/numbers/gcdex.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | typedef long long lli; 3 | 4 | int phi[1001000]; 5 | lli x[1001000]; 6 | lli ans[1001000]; 7 | 8 | int main(void) { 9 | for (int i = 0; i <= 1000000; i++) 10 | phi[i] = i; 11 | for (int i = 2; i <= 1000000; i++) { 12 | if (phi[i] == i) { 13 | for (int j = i; j <= 1000000; j += i) 14 | phi[j] -= phi[j] / i; 15 | } 16 | } 17 | 18 | for (int i = 1; i <= 1000000; i++) { 19 | for (int j = i; j <= 1000000; j += i) 20 | x[j] += ((long long)i) * phi[j / i]; 21 | } 22 | 23 | for (int i = 2; i <= 1000000; i++) 24 | ans[i] = ans[i - 1] + x[i] - i; 25 | 26 | int n; 27 | scanf("%d", &n); 28 | while (n != 0) { 29 | printf("%lld\n", ans[n]); 30 | scanf("%d", &n); 31 | } 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /src/practice/onp.py: -------------------------------------------------------------------------------- 1 | ops = ['+', '-', '*', '/', '^'] 2 | for _ in range(int(raw_input())): 3 | exp = raw_input() 4 | var = [] 5 | op = [] 6 | ans = [] 7 | for ch in exp: 8 | if ch == '(': 9 | continue 10 | elif ch == ')': 11 | x = var.pop() 12 | y = var.pop() 13 | o = op.pop() 14 | var.append(y+x+o) 15 | elif ch in ops: 16 | op.append(ch) 17 | else: 18 | var.append(ch) 19 | print var[0] 20 | -------------------------------------------------------------------------------- /src/practice/party.py: -------------------------------------------------------------------------------- 1 | def knapsack(cost, fun, w, n): 2 | dp = [[0 for _ in range(w+1)] for _ in range(n+1)] 3 | keep = [[False for _ in range(w+1)] for _ in range(n+1)] 4 | for i in range(1, n+1): 5 | for j in range(w+1): 6 | if cost[i-1] <= j and (fun[i-1] + dp[i-1][j-cost[i-1]]) > dp[i-1][j]: 7 | keep[i][j] = True 8 | dp[i][j] = fun[i-1] + dp[i-1][j-cost[i-1]] 9 | else: 10 | keep[i][j] = False 11 | dp[i][j] = dp[i-1][j] 12 | 13 | net = 0 14 | k = w 15 | for i in range(n, 0, -1): 16 | if keep[i][k]: 17 | net += cost[i-1] 18 | k -= cost[i-1] 19 | 20 | print net, dp[n][w] 21 | 22 | while True: 23 | raw_input() 24 | w, n = map(int, raw_input().split()) 25 | if w == 0 and n == 0: 26 | break 27 | fun = [0 for _ in range(n)] 28 | cost = [0 for _ in range(n)] 29 | for i in range(n): 30 | cost[i], fun[i] = map(int, raw_input().split()) 31 | knapsack(cost, fun, w, n) 32 | 33 | -------------------------------------------------------------------------------- /src/practice/pigbank.c: -------------------------------------------------------------------------------- 1 | // Author: Param Singh 2 | // http://www.spoj.com/problems/PIGBANK/ 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | int main(void) { 9 | int t; 10 | scanf("%d", &t); 11 | while (t--) { 12 | int e, f, w; 13 | scanf("%d %d", &e, &f); 14 | w = f - e; 15 | int n; 16 | scanf("%d", &n); 17 | int p[n], wt[n]; 18 | int i, j, k; 19 | for (i = 0; i < n; i++) 20 | scanf("%d %d", p+i, wt+i); 21 | int dp[w+1]; 22 | for (i = 0; i <= w; i++) 23 | dp[i] = -1; 24 | dp[0] = 0; 25 | for (i = 1; i <= w; i++) { 26 | for (j = 0; j < n; j++) { 27 | if (wt[j] > i || dp[i-wt[j]] == -1) 28 | continue; 29 | else { 30 | if (dp[i] == -1 || p[j] + dp[i-wt[j]] < dp[i]) 31 | dp[i] = p[j] + dp[i-wt[j]]; 32 | } 33 | } 34 | } 35 | 36 | if (dp[w] == -1) 37 | printf("This is impossible.\n"); 38 | else 39 | printf("The minimum amount of money in the piggy-bank is %d.\n", dp[w]); 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /src/practice/pleaselikeme.hs: -------------------------------------------------------------------------------- 1 | -- http://codechef.com/problems/PLZLYKME 2 | 3 | numLikes s c = s : (s*c + s) : map (\x -> x*c + x) (tail $ numLikes s c) 4 | 5 | -- f(1) = s 6 | -- f(x) = f(1) * (c+1)**(d-1) 7 | 8 | alive ::(Floating a, Ord a) => a -> a -> a -> a -> Bool 9 | alive l d s c = log s + (d-1) * log (c + 1) >= log l 10 | 11 | checkIfAlive = do 12 | str <- getLine 13 | let [l, d, s, c] = map (\x -> read x :: Float) $ words str 14 | if alive l d s c 15 | then putStrLn "ALIVE AND KICKING" 16 | else putStrLn "DEAD AND ROTTING" 17 | 18 | 19 | main = do 20 | terms <- readLn 21 | sequence $ replicate terms checkIfAlive 22 | return () 23 | -------------------------------------------------------------------------------- /src/practice/powersoftwo.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long lli; 4 | 5 | int a[100100]; 6 | int n; 7 | int main(void) { 8 | unordered_map mp; 9 | scanf("%d", &n); 10 | for (int i = 0; i < n; i++) 11 | scanf("%d", &a[i]); 12 | mp[a[0]] = 1; 13 | lli ans = 0; 14 | for (int i = 1; i < n; i++) { 15 | for (int p = 0; p < 40; p++) { 16 | lli num = (1LL) << p; 17 | lli x = num - a[i]; 18 | int c = mp[x]; 19 | ans += c; 20 | } 21 | if (mp.count(a[i])) 22 | mp[a[i]]++; 23 | else 24 | mp[a[i]] = 1; 25 | } 26 | cout << ans << endl; 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /src/practice/prime.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void){ 4 | int terms; 5 | scanf("%d", &terms); 6 | while(terms--){ 7 | int n; 8 | scanf("%d", &n); 9 | if(n==0 || n==1) 10 | printf("NO\n"); 11 | else 12 | printf("YES\n"); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/practice/primepalindrome.hs: -------------------------------------------------------------------------------- 1 | -- This is really embarrasing. 2 | pp = [2,3,5,7,11,101,131,151,181,191,313,353,373,383,727,757,787,797,919,929,10301,10501,10601,11311,11411,12421,12721,12821,13331,13831,13931,14341,14741,15451,15551,16061,16361,16561,16661,17471,17971,18181,18481,19391,19891,19991,30103,30203,30403,30703,30803,31013,31513,32323,32423,33533,34543,34843,35053,35153,35353,35753,36263,36563,37273,37573,38083,38183,38783,39293,70207,70507,70607,71317,71917,72227,72727,73037,73237,73637,74047,74747,75557,76367,76667,77377,77477,77977,78487,78787,78887,79397,79697,79997,90709,91019,93139,93239,93739,94049,94349,94649,94849,94949,95959,96269,96469,96769,97379,97579,97879,98389,98689,1003001] 3 | first_num n = head [x | x <- (dropWhile ( 4 | using namespace std; 5 | 6 | int adj[200][200] = {0}; 7 | 8 | int main(void) { 9 | int n; 10 | scanf("%d", &n); 11 | int i, j, k; 12 | int fin[n+1]; 13 | int fav[n+1]; 14 | for (i = 1; i <= n; i++) { 15 | int x; 16 | scanf("%d", &x); 17 | fin[x] = i; 18 | } 19 | for (i = 1; i <= n; i++) 20 | scanf("%d", fav+i); 21 | for (i = 1; i <= n; i++) { 22 | for (j = 1; j <= n; j++) { 23 | if (i == j || abs(i-j) == fav[i]) { 24 | adj[i][j] = adj[j][i] = 1; 25 | } 26 | } 27 | } 28 | for (k = 1; k <= n; k++) { 29 | for (i = 1; i <= n; i++) { 30 | for (j = 1; j <= n; j++) { 31 | adj[i][j] = adj[i][j] || (adj[i][k] && adj[k][j]); 32 | } 33 | } 34 | } 35 | for (i = 1; i <= n; i++) { 36 | if (adj[i][fin[i]] == 0) { 37 | printf("NO\n"); 38 | return 0; 39 | } 40 | } 41 | printf("YES\n"); 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /src/practice/psychon.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define SIZE 10000100 3 | 4 | int seive[SIZE] = {0}; 5 | 6 | int main(void) { 7 | int i, j; 8 | for (i = 2; i < SIZE; i++) { 9 | if (seive[i] == 0) { 10 | for (j = i; j < SIZE; j+=i) 11 | seive[j] = i; 12 | } 13 | } 14 | int t, n; 15 | scanf("%d", &t); 16 | while (t--) { 17 | scanf("%d", &n); 18 | int ce = 0, co = 0; 19 | int prev = seive[n]; 20 | int count = 1; 21 | while (n != 1) { 22 | n /= seive[n]; 23 | if (seive[n] == prev) 24 | count++; 25 | else { 26 | count % 2 == 0 ? ce++ : co++; 27 | count = 1; 28 | } 29 | prev = seive[n]; 30 | } 31 | if (ce > co) 32 | printf("Psycho Number\n"); 33 | else 34 | printf("Ordinary Number\n"); 35 | } 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /src/practice/ranklist.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | 3 | int main( void ){ 4 | long long terms; //variable to store the number of terms 5 | scanf("%lld", &terms); 6 | long long sums[100000]; 7 | sums[0] = 0; 8 | long long i; 9 | for(i=1;i<100000;i++) 10 | sums[i] = i + sums[i-1]; 11 | while( terms-- ){ 12 | long long num, sum; 13 | scanf("%lld %lld", &num, &sum); 14 | long long difference = sums[num] - sum; 15 | long long j; 16 | if( difference == 0 ){ 17 | printf("0\n"); 18 | continue; 19 | } 20 | for(j=num; j>=1; j--){ 21 | if( (difference - j + 1) <= 0 ){ 22 | break; 23 | } 24 | else { 25 | difference = difference - j + 1; 26 | } 27 | } 28 | printf("%lld\n", num - j + 1); 29 | } 30 | } -------------------------------------------------------------------------------- /src/practice/ribbons.c: -------------------------------------------------------------------------------- 1 | #include 2 | unsigned long long gcd(unsigned long long u, unsigned long long v) { 3 | return (v != 0)?gcd(v, u%v):u; 4 | } 5 | int main(void){ 6 | unsigned long long terms, n; 7 | scanf("%lld", &terms); 8 | while(terms--){ 9 | scanf("%lld", &n); 10 | unsigned long long a[n]; 11 | unsigned long long i; 12 | for(i=0;i 4 | using namespace std; 5 | 6 | vector tree[50010]; 7 | int ans[50010]; 8 | int visited[50010] = {0}; 9 | 10 | void dfs(int cur, int prev) { 11 | visited[cur] = 1; 12 | ans[cur] = prev; 13 | int i; 14 | for (i = 0; i < tree[cur].size(); i++) { 15 | int v = tree[cur][i]; 16 | if (v != prev) 17 | dfs(v, cur); 18 | } 19 | } 20 | 21 | int main(void) { 22 | int n, prev, now; 23 | scanf("%d %d %d", &n, &prev, &now); 24 | int i, pr; 25 | for (i = 1; i <= n; i++) { 26 | if (i != prev) { 27 | scanf("%d", &pr); 28 | tree[pr].push_back(i); 29 | tree[i].push_back(pr); 30 | } 31 | } 32 | dfs(now, -1); 33 | for (i = 1; i <= n; i++) { 34 | if (i != now) 35 | printf("%d ", ans[i]); 36 | } 37 | printf("\n"); 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /src/practice/rock.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define max(a, b) a>b?a:b 4 | 5 | char a[201]; 6 | int dp[201][201]; 7 | 8 | int func(int l, int r) { 9 | int i; 10 | if (dp[l][r] != -1){ 11 | return dp[l][r]; 12 | } 13 | int ans = -1; 14 | int c1 = 0, c0 = 0; 15 | for (i = l; i <= r; i++) { 16 | if (a[i] == '1') 17 | c1++; 18 | else 19 | c0++; 20 | } 21 | if (c1 > c0) 22 | ans = r - l + 1; 23 | else { 24 | for (i = l; i < r; i++) { 25 | ans = max(ans, func(l, i) + func(i+1, r)); 26 | } 27 | } 28 | if (ans == -1) 29 | dp[l][r] = 0; 30 | else 31 | dp[l][r] = ans; 32 | return dp[l][r]; 33 | } 34 | 35 | int main(void) { 36 | int t, i, j; 37 | scanf("%d", &t); 38 | while (t--) { 39 | int n; 40 | scanf("%d", &n); 41 | scanf("%s", a); 42 | for (i = 0; i < 201; i++) { 43 | for (j = 0; j < 201; j++) { 44 | dp[i][j] = -1; 45 | } 46 | } 47 | printf("%d\n", func(0, n-1)); 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /src/practice/shoelaces.cpp: -------------------------------------------------------------------------------- 1 | // http://codeforces.com/problemset/problem/129/B 2 | #include 3 | using namespace std; 4 | 5 | int n, m; 6 | vector graph[200]; 7 | int order[200] = {0}; 8 | int main(void) { 9 | scanf("%d %d", &n, &m); 10 | int u, v; 11 | while (m--) { 12 | scanf("%d %d", &u, &v); 13 | graph[u].push_back(v); 14 | order[u]++; 15 | graph[v].push_back(u); 16 | order[v]++; 17 | } 18 | int size = n; 19 | int groups = 0; 20 | while (size > 0) { 21 | int rem = 0; 22 | int* freq = (int*) calloc(200, sizeof(int)); 23 | for (int i = 1; i <= n; i++) { 24 | if (order[i] == 1) { 25 | rem++; 26 | order[i]--; 27 | for (int j = 0; j < graph[i].size(); j++) { 28 | freq[graph[i][j]]++; 29 | } 30 | } 31 | } 32 | if (rem == 0) 33 | break; 34 | size = size - rem; 35 | groups++; 36 | for (int i = 1; i <= n; i++) 37 | order[i] -= freq[i]; 38 | free(freq); 39 | } 40 | printf("%d\n", groups); 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /src/practice/snape.py: -------------------------------------------------------------------------------- 1 | # http://www.codechef.com/problems/SNAPE 2 | 3 | def maximum(ls, b): 4 | return ((ls**2) + (b**2))**0.5 5 | 6 | def minimum(ls, b): 7 | return ((ls**2) - (b**2))**0.5 8 | 9 | t = int(raw_input()) 10 | while t: 11 | line = raw_input().split() 12 | b = int(line[0]) 13 | ls = int(line[1]) 14 | print minimum(ls, b), maximum(ls, b) 15 | t -= 1 -------------------------------------------------------------------------------- /src/practice/st_queries.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void num_substring(int *a, int x, int y) 4 | { 5 | int found[] = {0,0,0}; 6 | int last_found[] = {0,0,0}; 7 | int sum_found = 0,i,j; 8 | for(i=x; i<=y; i++){ 9 | int res = a[i-1]%3; 10 | found[res % 3] = last_found[0] + 1; 11 | found[(res+1) % 3] = last_found[1]; 12 | found[(res+2) % 3] = last_found[2]; 13 | sum_found += found[0]; 14 | for(j=0;j<3;j++){ 15 | int tmp = found[j]; 16 | found[j] = last_found[j]; 17 | last_found[j] = tmp; 18 | } 19 | } 20 | printf("%d\n", sum_found); 21 | } 22 | 23 | int main(void) 24 | { 25 | int n,m; 26 | scanf("%d %d", &n, &m); 27 | char st[n]; 28 | scanf("%s", st); 29 | int i; 30 | int a[n]; 31 | for(i=0;i 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | 6 | char s[100100]; 7 | 8 | int a[100100][2]; 9 | int b[100100][2]; 10 | 11 | int main(void) { 12 | scanf("%s", s + 1); 13 | int l = strlen(s + 1); 14 | ll odd = 0, even = 0; 15 | for (int i = 1; i <= l; i++) { 16 | if (s[i] == 'a') 17 | a[i][i % 2] += 1; 18 | else 19 | b[i][i % 2] += 1; 20 | 21 | a[i][0] += a[i - 1][0]; 22 | a[i][1] += a[i - 1][1]; 23 | b[i][0] += b[i - 1][0]; 24 | b[i][1] += b[i - 1][1]; 25 | 26 | if (s[i] == 'a') { 27 | odd += a[i][i % 2]; 28 | even += a[i][!(i % 2)]; 29 | } 30 | else { 31 | odd += b[i][i % 2]; 32 | even += b[i][!(i % 2)]; 33 | } 34 | } 35 | printf("%lld %lld\n", even, odd); 36 | } 37 | -------------------------------------------------------------------------------- /src/practice/strings/goodsubstrings.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int trie[2500001][26]; 5 | bool mark[2500001]; 6 | int nxt = 1; 7 | int root = 0; 8 | 9 | char s[1510]; 10 | char good[30]; 11 | 12 | int main(void) { 13 | scanf("%s", s); 14 | int l = strlen(s); 15 | scanf("%s", good); 16 | int k; 17 | scanf("%d", &k); 18 | int ans = 0; 19 | for (int i = 0; i < l; i++) { 20 | int here = i; 21 | int node = root; 22 | int cnt = 0; 23 | while (cnt <= k && here < l) { 24 | cnt += good[s[here] - 'a'] == '0'; 25 | if (cnt > k) break; 26 | if (trie[node][s[here] - 'a'] == 0) 27 | trie[node][s[here] - 'a'] = nxt++; 28 | node = trie[node][s[here] - 'a']; 29 | if (mark[node] == 0) { 30 | ans++; 31 | mark[node] = 1; 32 | } 33 | here++; 34 | } 35 | } 36 | printf("%d\n", ans); 37 | } 38 | -------------------------------------------------------------------------------- /src/practice/subway.cpp: -------------------------------------------------------------------------------- 1 | // Subway: http://codeforces.com/contest/131/problem/D 2 | 3 | #include 4 | using namespace std; 5 | 6 | int n; 7 | int parent[4000] = {0}; 8 | int len[4000] = {0}; 9 | vector graph[4000]; 10 | 11 | int dfs(int node, int l) { 12 | len[node] = l; 13 | for (int i = 0; i < graph[node].size(); i++) { 14 | int v = graph[node][i]; 15 | if (v == parent[node]) 16 | continue; 17 | if (len[v] != 0) 18 | return len[v]; 19 | parent[v] = node; 20 | int tmp = dfs(v, l + 1); 21 | if (tmp > -1) 22 | return tmp; 23 | } 24 | return -1; 25 | } 26 | 27 | 28 | int main(void) { 29 | scanf("%d", &n); 30 | int m = n; 31 | while (m--) { 32 | int u, v; 33 | scanf("%d %d", &u, &v); 34 | graph[u].push_back(v); 35 | graph[v].push_back(u); 36 | } 37 | for (int i = 1; i <= n; i++) { 38 | printf("%d ", dfs(i, 1) - 1); 39 | for (int j = 1; j <= n; j++) { 40 | parent[j] = len[j] = 0; 41 | } 42 | } 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /src/practice/sysadmin.cpp: -------------------------------------------------------------------------------- 1 | // http://codeforces.com/problemset/problem/22/C 2 | 3 | #include 4 | #define mp make_pair 5 | using namespace std; 6 | typedef pair pii; 7 | 8 | 9 | int main(void) { 10 | int n, m, cut; 11 | scanf("%d %d %d", &n, &m, &cut); 12 | long long int mx = n - 1 + ((long long)(n-2) * (n-3)) / 2; 13 | if (m < n - 1 || m > mx) { 14 | printf("-1\n"); 15 | return 0; 16 | } 17 | vector edges; 18 | int count = 0; 19 | int mid = 2; 20 | int u, v; 21 | for (int i = 1; i <= n; i++) { 22 | if (i == mid) 23 | continue; 24 | u = cut; 25 | v = i == cut ? mid : i; 26 | printf("%d %d\n", u, v); 27 | count++; 28 | } 29 | if (count == m) 30 | return 0; 31 | for (int i = 3; i <= n; i++) { 32 | for (int j = i + 1; j <= n; j++) { 33 | u = i == 2 ? cut : i == cut ? 2 : i; 34 | v = j == 2 ? cut : j == cut ? 2 : j; 35 | printf("%d %d\n", u, v); 36 | count++; 37 | if (count == m) 38 | return 0; 39 | } 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /src/practice/tdkprime.c: -------------------------------------------------------------------------------- 1 | // http://www.spoj.com/problems/TDKPRIME 2 | 3 | #include 4 | #include 5 | #define MAX 86044176 6 | #define SQRT 9267 7 | #define isp(n) (seive[n>>6]&(1<<((n>>1)&31))) 8 | #define setp(n) (seive[n>>6]|=(1<<((n>>1)&31))) 9 | 10 | int seive[MAX >> 6] = {0}; 11 | int primes[5000100]; 12 | int main(void) { 13 | int i, j, k; 14 | for (i = 3; i < SQRT; i+=2) { 15 | if (!isp(i)) { 16 | for (j = i*i, k = i << 1; j < MAX; j+=k) { 17 | setp(j); 18 | } 19 | } 20 | } 21 | int c = 2; 22 | primes[1] = 2; 23 | for (i = 3; i < MAX && c <= 5000000; i+=2) { 24 | if (!isp(i)) 25 | primes[c++] = i; 26 | } 27 | int n, q; 28 | scanf("%d", &q); 29 | while (q--) { 30 | scanf("%d", &n); 31 | printf("%d\n", primes[n]); 32 | } 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /src/practice/test.hs: -------------------------------------------------------------------------------- 1 | main = do 2 | x <- getLine 3 | if x == "42" 4 | then return () 5 | else do 6 | putStrLn x 7 | main 8 | -------------------------------------------------------------------------------- /src/practice/tickets.py: -------------------------------------------------------------------------------- 1 | import re 2 | terms = int(raw_input()) 3 | for cases in range(terms): 4 | string = raw_input() 5 | x = string[0:2] 6 | if x[0] == x[1]: 7 | print "NO" 8 | continue 9 | regex = x.join(['(', ')*']) 10 | regex = re.compile(regex) 11 | l = len(string) 12 | begin, end = regex.match(string).span() 13 | if end == l - 1 and string[-1] == string[0]: 14 | print "YES" 15 | continue 16 | elif end == l: 17 | print "YES" 18 | continue 19 | else: 20 | print "NO" 21 | -------------------------------------------------------------------------------- /src/practice/topological.cpp: -------------------------------------------------------------------------------- 1 | /** http://acm.timus.ru/problem.aspx?space=1&num=1280 */ 2 | #include 3 | using namespace std; 4 | #define SIZE 1010 5 | 6 | int main(void) { 7 | int n, m; 8 | scanf("%d %d", &n, &m); 9 | vector graph[n+10]; 10 | int* order = (int*) calloc(n+10, sizeof(int)); 11 | int u, v; 12 | while (m--) { 13 | scanf("%d %d", &u, &v); 14 | graph[u].push_back(v); 15 | order[v]++; 16 | } 17 | int flag = 0; 18 | int cur; 19 | for (int i = 0; i < n; i++) { 20 | scanf("%d", &cur); 21 | if (order[cur] > 0) { 22 | flag = 1; 23 | break; 24 | } 25 | else { 26 | for (int j = 0; j < graph[cur].size(); j++) { 27 | order[graph[cur][j]]--; 28 | } 29 | } 30 | } 31 | if (flag == 1) 32 | printf("NO\n"); 33 | else 34 | printf("YES\n"); 35 | return 0; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /src/practice/triangles.cpp: -------------------------------------------------------------------------------- 1 | // http://codeforces.com/problemset/problem/229/C 2 | 3 | #include 4 | using namespace std; 5 | typedef long long int lli; 6 | 7 | int ord[1000100] = {0}; 8 | 9 | int main(void) { 10 | int n, m; 11 | int u, v; 12 | scanf("%d %d", &n, &m); 13 | while (m--) { 14 | scanf("%d %d", &u, &v); 15 | ord[u] += 1; 16 | ord[v] += 1; 17 | } 18 | lli t = (lli)(n) * (n-1) * (n-2) / 6; 19 | lli rem = 0; 20 | for (int i = 1; i <= n; i++) 21 | rem += ord[i] * ((lli)n - 1 - ord[i]); 22 | lli ans = t - rem / 2; 23 | cout << ans << endl; 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /src/practice/tsort.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main(void) { 4 | int t; 5 | scanf("%d", &t); 6 | int *a = (int *) calloc(1000001, 4); 7 | int i; 8 | for (i = 0; i < t; i++) { 9 | int x; 10 | scanf("%d", &x); 11 | a[x]++; 12 | } 13 | for (i = 0; i < 1000001; i++) { 14 | while (a[i] > 0) { 15 | printf("%d\n", i); 16 | a[i]--; 17 | } 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /src/practice/wachovia.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define max(a, b) a>b?a:b 4 | 5 | int main(void) { 6 | int t, i, j; 7 | scanf("%d", &t); 8 | while (t--) { 9 | int k, m; 10 | scanf("%d %d", &k, &m); 11 | int* val = (int *) calloc(m, 4); 12 | int* wts = (int *) calloc(m, 4); 13 | int **dp = (int **) calloc(m + 1, sizeof(int*)); 14 | for (i = 0; i < m; i++) 15 | scanf("%d %d", wts+i, val+i); 16 | for (i = 0; i <= m; i++) 17 | dp[i] = (int *) calloc(k+1, sizeof(int)); 18 | for (i = 1; i <= m; i++) { 19 | for (j = 0; j <= k; j++) { 20 | if (j >= wts[i-1]) { 21 | dp[i][j] = max(dp[i-1][j], dp[i-1][j-wts[i-1]] + val[i-1]); 22 | } 23 | else { 24 | dp[i][j] = dp[i-1][j]; 25 | } 26 | } 27 | } 28 | printf("Hey stupid robber, you can get %d.\n", dp[m][k]); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/practice/wout.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(void) { 6 | int t; 7 | scanf("%d", &t); 8 | while (t--) { 9 | int n, g; 10 | scanf("%d %d", &n, &g); 11 | int i; 12 | long long int* r = (long long int*) calloc(n+2, 8); 13 | for (i = 0; i < n; i++) { 14 | int h, l; 15 | scanf("%d %d", &l, &h); 16 | r[l+1]--; 17 | r[h+2]++; 18 | } 19 | r[0] = n; 20 | long long int cur = n; 21 | for (i = 0; i < n; i++) 22 | r[i+1] += r[i]; 23 | for (i = 0; i < n; i++) 24 | r[i+1] += r[i]; 25 | long long int min = r[g] - r[0]; 26 | for (i = g+1; i <= n; i++) { 27 | long long int y = r[i] - r[i-g]; 28 | if (y < min) 29 | min = y; 30 | } 31 | printf("%lld\n", min); 32 | } 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /src/practice/xor.py: -------------------------------------------------------------------------------- 1 | # http://www.codechef.com/DEC14/problems/XORSUB 2 | import operator 3 | def f(p): 4 | if p == []: 5 | return 0 6 | elif len(p) == 1: 7 | return p[0] 8 | else: 9 | return reduce(operator.xor, p) 10 | 11 | def list_powerset(lst): 12 | result = [[]] 13 | for x in lst: 14 | result.extend([subset + [x] for subset in result]) 15 | return result 16 | 17 | t = int(raw_input()) 18 | while t: 19 | k = int(raw_input().split()[1]) 20 | array = map(int, raw_input().split()) 21 | max = -1 22 | for i in list_powerset(array): 23 | if max < (k ^ f(i)): 24 | max = k ^ f(i) 25 | 26 | print max 27 | t -= 1 -------------------------------------------------------------------------------- /src/practice/yodaness.py: -------------------------------------------------------------------------------- 1 | bit = [0] 2 | maxval = 0 3 | 4 | def update(idx, val): 5 | while idx <= maxval: 6 | bit[idx] += val 7 | idx += (idx & (-idx)) 8 | 9 | def query(idx): 10 | ans = 0 11 | while idx > 0: 12 | ans += bit[idx] 13 | idx -= (idx & (-idx)) 14 | return ans 15 | 16 | t = int(raw_input()) 17 | for _ in range(t): 18 | n = int(raw_input()) 19 | bit = [0 for _ in range(n+3)] 20 | maxval = n 21 | yoda = raw_input().split() 22 | sentence = raw_input().split() 23 | words = {} 24 | for index, word in enumerate(sentence): 25 | words[word] = index + 1 26 | lst = [] 27 | for word in yoda: 28 | lst.append(words[word]) 29 | ans = 0 30 | for i in lst[::-1]: 31 | ans += query(i-1) 32 | update(i, 1) 33 | print ans 34 | 35 | 36 | -------------------------------------------------------------------------------- /src/recreation/a.blend.of.springtime.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char s[1001]; 5 | 6 | 7 | int main(void) { 8 | scanf("%s", s + 1); 9 | int l = strlen(s + 1); 10 | for (int i = 1; i <= l; i++) { 11 | int a[3]; 12 | a[0] = a[1] = a[2] = 0; 13 | for (int x = i - 1; x <= i + 1; x++) { 14 | if (s[x] == 'A' || s[x] == 'B' || s[x] == 'C') 15 | a[s[x] - 'A']++; 16 | } 17 | if (a[0] > 0 && a[1] > 0 && a[2] > 0) { 18 | printf("Yes\n"); 19 | return 0; 20 | } 21 | } 22 | printf("No\n"); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /src/recreation/a.tide.of.riverscape.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | char s[10100]; 5 | 6 | 7 | int main(void) { 8 | int n, p; 9 | scanf("%d %d", &n, &p); 10 | scanf("%s", s + 1); 11 | int cnt = 0; 12 | for (int i = 1; i <= n - p; i++) { 13 | if (s[i] == '.' && s[i + p] == '.') { 14 | s[i] = '1'; 15 | s[i + p] = '0'; 16 | cnt += 1; 17 | } 18 | else if (s[i] == '.') { 19 | s[i] = s[i + p] == '0' ? '1': '0'; 20 | cnt += 1; 21 | } 22 | else if (s[i + p] == '.') { 23 | s[i + p] = s[i] == '0' ? '1': '0'; 24 | cnt += 1; 25 | } 26 | else { 27 | if (s[i] != s[i + p]) { 28 | cnt += 1; 29 | } 30 | } 31 | } 32 | for (int i = n - p + 1; i <= n; i++) { 33 | if (s[i] == '.') 34 | s[i] = '0'; 35 | } 36 | if (cnt > 0) 37 | printf("%s\n", s + 1); 38 | else 39 | printf("NO\n"); 40 | } 41 | -------------------------------------------------------------------------------- /src/recreation/and.graph.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | int done[2][(1 << 22) + 10]; 6 | int here[(1 << 22) + 10]; 7 | int a[(1 << 22) + 10]; 8 | int n, m; 9 | 10 | void dfs(int val, int type) { 11 | if (done[type][val]) return; 12 | done[type][val] = 1; 13 | if (type == 0) { 14 | dfs(val, 1); 15 | } 16 | else { 17 | for (int i = 0; i < n; i++) { 18 | if ((val >> i) & 1) 19 | continue; 20 | else 21 | dfs(val | (1 << i), 1); 22 | } 23 | int inverse = (1 << n) - 1 - val; 24 | if (here[inverse]) 25 | dfs(inverse, 0); 26 | } 27 | } 28 | 29 | int main(void) { 30 | scanf("%d %d", &n, &m); 31 | for (int i = 1; i <= m; i++) { 32 | scanf("%d", &a[i]); 33 | here[a[i]] = 1; 34 | } 35 | int cnt = 0; 36 | for (int i = 1; i <= m; i++) { 37 | if (done[0][a[i]]) continue; 38 | cnt += 1; 39 | dfs(a[i], 0); 40 | } 41 | printf("%d\n", cnt); 42 | return 0; 43 | } 44 | 45 | -------------------------------------------------------------------------------- /src/recreation/bus.of.characters.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | int ans[400100]; 6 | char s[400100]; 7 | 8 | 9 | int main(void) { 10 | set > introverts; 11 | set noone; 12 | map rowids; 13 | 14 | int n; 15 | scanf("%d", &n); 16 | for (int i = 1; i <= n; i++) { 17 | int w; 18 | scanf("%d", &w); 19 | noone.insert(w); 20 | rowids[w] = i; 21 | } 22 | 23 | scanf("%s", s); 24 | for (int i = 0; i < 2*n; i++) { 25 | if (s[i] == '1') { 26 | int val = *introverts.begin(); 27 | printf("%d ", rowids[val]); 28 | introverts.erase(val); 29 | } 30 | else { 31 | int val = *noone.begin(); 32 | printf("%d ", rowids[val]); 33 | noone.erase(val); 34 | introverts.insert(val); 35 | } 36 | } 37 | return 0; 38 | } 39 | 40 | -------------------------------------------------------------------------------- /src/recreation/chess.placing.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int done[1010]; 5 | 6 | int main(void) { 7 | int n; 8 | scanf("%d", &n); 9 | vector p; 10 | for (int i = 1; i <= n / 2; i++) { 11 | int x; 12 | scanf("%d", &x); 13 | p.push_back(x); 14 | } 15 | sort(p.begin(), p.end()); 16 | int even_ans = 0; 17 | int odd_ans = 0; 18 | for (int i = 0; i < n / 2; i++) { 19 | int x = p[i]; 20 | even_ans += abs(p[i] - (2*i + 2)); 21 | odd_ans += abs(p[i] - (2*i + 1)); 22 | } 23 | printf("%d\n", min(odd_ans, even_ans)); 24 | return 0; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /src/recreation/equalize.cpp: -------------------------------------------------------------------------------- 1 | // 22:47 2 | // 3 | #include 4 | using namespace std; 5 | 6 | 7 | int n; 8 | char a[1001000], b[1001000]; 9 | 10 | 11 | int main(void) { 12 | scanf("%d", &n); 13 | scanf("%s", a + 1); 14 | scanf("%s", b + 1); 15 | int ans = 0; 16 | for (int i = 1; i <= n; i++) { 17 | if (a[i] != b[i]) { 18 | if (i < n && a[i + 1] != b[i + 1] && a[i] != a[i + 1]) { 19 | ans++; 20 | a[i] = b[i]; 21 | a[i + 1] = b[i + 1]; 22 | } 23 | else { 24 | ans++; 25 | a[i] = b[i]; 26 | } 27 | } 28 | } 29 | printf("%d\n", ans); 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /src/recreation/high.school.become.human.py: -------------------------------------------------------------------------------- 1 | from math import log 2 | 3 | x, y = map(int, input().split()) 4 | if x == y: 5 | print('=') 6 | elif x == 1 or y == 1: 7 | print('<' if x < y else '>') 8 | elif log(y, x) > y / float(x): 9 | print('<') 10 | elif log(y, x) < y / float(x): 11 | print('>') 12 | else: 13 | print('=') 14 | -------------------------------------------------------------------------------- /src/recreation/infinity.gauntlet.py: -------------------------------------------------------------------------------- 1 | color = { 2 | 'purple': 'Power', 3 | 'green': 'Time', 4 | 'blue': 'Space', 5 | 'orange': 'Soul', 6 | 'red': 'Reality', 7 | 'yellow': 'Mind', 8 | } 9 | 10 | if __name__ == '__main__': 11 | n = int(input()) 12 | gems = [] 13 | for _ in range(n): 14 | gems.append(input()) 15 | cnt = 0 16 | ans = [] 17 | for gem in color: 18 | if gem not in gems: 19 | cnt += 1 20 | ans.append(color[gem]) 21 | print(cnt) 22 | for line in ans: 23 | print(line) 24 | -------------------------------------------------------------------------------- /src/recreation/make_it_equal.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | typedef long long ll; 3 | using namespace std; 4 | 5 | int height[200001]; 6 | ll freq[201000]; 7 | 8 | int main(){ 9 | int n, k; 10 | scanf("%d %d", &n, &k); 11 | for(int i = 0; i < n; i++) { 12 | scanf("%d", &height[i]); 13 | freq[height[i]] += 1; 14 | } 15 | 16 | sort(height, height + n); 17 | ll sum = 0, cnt = 0; 18 | int ans = 0; 19 | for (int h = height[n - 1]; ;h--) { 20 | sum += freq[h] * h; 21 | cnt += freq[h]; 22 | ll cost = sum - (cnt * h); 23 | 24 | if (h == height[0]) { 25 | if (cost > 0 && cost <= k) { 26 | ans++; 27 | } 28 | if (cost <= k) 29 | break; 30 | } 31 | if (cost > k) { 32 | h++; 33 | cnt -= freq[h - 1]; 34 | sum = cnt * h; 35 | ans++; 36 | } 37 | } 38 | printf("%d\n", ans); 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /src/recreation/maximum.value.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | int have[2001000]; 6 | int largest[2001000]; 7 | 8 | int main(void) { 9 | int n; 10 | scanf("%d", &n); 11 | for (int i = 1; i <= n; i++) { 12 | int x; 13 | scanf("%d", &x); 14 | have[x] = 1; 15 | } 16 | for (int i = 1; i <= 2e6; i++) { 17 | if (have[i - 1]) 18 | largest[i] = i - 1; 19 | else 20 | largest[i] = largest[i - 1]; 21 | } 22 | int ans = 0; 23 | for (int aj = 1; aj <= 1e6; aj++) { 24 | if (!have[aj]) continue; 25 | 26 | for (int i = 2; i * aj <= 2e6; i++) 27 | ans = max(ans, largest[i * aj] % aj); 28 | } 29 | 30 | printf("%d\n", ans); 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /src/recreation/packets.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | int main(void) { 6 | int n; 7 | scanf("%d", &n); 8 | for (int i = 31; i >= 0; i--) { 9 | if ((n >> i) & 1) { 10 | printf("%d\n", i + 1); 11 | return 0; 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/recreation/petr.and.permutations.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int n; 5 | int a[1001000]; 6 | int pos[1001000]; 7 | int tree[5001000]; 8 | 9 | int update(int l, int i = 1, int cl=1, int cr=n) { 10 | if (cl == cr && cr == l) 11 | tree[i] = 1; 12 | else { 13 | int mid = (cl + cr) / 2; 14 | if (l <= mid) 15 | update(l, 2*i, cl, mid); 16 | else 17 | update(l, 2*i+1, mid+1, cr); 18 | tree[i] = tree[2*i] + tree[2*i+1]; 19 | } 20 | } 21 | 22 | int sum(int l, int r, int i = 1, int cl=1, int cr=n) { 23 | if (cl > r || cr < l || cl > cr) 24 | return 0; 25 | else if (l <= cl && cr <= r) 26 | return tree[i]; 27 | else { 28 | int mid = (cl + cr) / 2; 29 | return sum(l, r, 2*i, cl, mid) + sum(l, r, 2*i+1, mid+1, cr); 30 | } 31 | } 32 | 33 | int main(void) { 34 | scanf("%d", &n); 35 | for (int i = 1; i <= n; i++) 36 | scanf("%d", &a[i]); 37 | int inv = 0; 38 | for (int i = n; i >= 1; i--) { 39 | inv = (inv + sum(1, a[i])) % 2; 40 | update(a[i]); 41 | } 42 | if (inv == ((3 * n) % 2)) 43 | printf("Petr\n"); 44 | else 45 | printf("Um_nik\n"); 46 | return 0; 47 | } 48 | 49 | -------------------------------------------------------------------------------- /src/recreation/prepare.for.merge.sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int n; 5 | 6 | int a[200100]; 7 | 8 | vector subs[200100]; 9 | 10 | int find(int x) { 11 | // find the subsequence in which x should go 12 | int lo = 1, hi = n; 13 | while (lo < hi) { 14 | int mid = (lo + hi) / 2; 15 | int size = subs[mid].size(); 16 | // if this subarray is empty or if it's last element is 17 | // smaller than x, then answer is either mid or less than mid 18 | if (size == 0 || subs[mid][size - 1] < x) 19 | hi = mid; 20 | else 21 | lo = mid + 1; 22 | } 23 | return lo; 24 | } 25 | 26 | 27 | int main(void) { 28 | scanf("%d", &n); 29 | for (int i = 1; i <= n; i++) 30 | scanf("%d", &a[i]); 31 | for (int i = 1; i <= n; i++) { 32 | int x = find(a[i]); 33 | subs[x].push_back(a[i]); 34 | } 35 | for (int i = 1; i <= n; i++) { 36 | if (!subs[i].size()) break; 37 | for (int j = 0; j < subs[i].size(); j++) 38 | printf("%d ", subs[i][j]); 39 | printf("\n"); 40 | } 41 | return 0; 42 | } 43 | 44 | -------------------------------------------------------------------------------- /src/recreation/reach.median.cpp: -------------------------------------------------------------------------------- 1 | // 22:40 2 | 3 | #include 4 | using namespace std; 5 | typedef long long ll; 6 | 7 | 8 | int a[201000]; 9 | 10 | int main(void) { 11 | int n, s; 12 | scanf("%d %d", &n, &s); 13 | for (int i = 0; i < n; i++) 14 | scanf("%d", &a[i]); 15 | sort(a, a + n); 16 | ll ans = 0; 17 | for (int i = 0; i < n / 2; i++) { 18 | if (a[i] > s) 19 | ans += abs(a[i] - s); 20 | } 21 | if (a[n/2] != s) 22 | ans += abs(a[n/2] - s); 23 | for (int i = n / 2 + 1; i < n; i++) { 24 | if (a[i] < s) 25 | ans += abs(a[i] - s); 26 | } 27 | printf("%lld\n", ans); 28 | return 0; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /src/recreation/row.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | char a[10100]; 6 | 7 | int main(void) { 8 | int n; 9 | scanf("%d", &n); 10 | scanf("%s", a + 1); 11 | for (int i = 1; i <= n; i++) { 12 | if (a[i] == '0') { 13 | int l = (i == 1) || (a[i - 1] == '0'); 14 | int r = (i == n) || (a[i + 1] == '0'); 15 | if (l && r) { 16 | printf("No\n"); 17 | return 0; 18 | } 19 | } 20 | else { 21 | if (a[i - 1] == '1' || a[i + 1] == '1') { 22 | printf("No\n"); 23 | return 0; 24 | } 25 | } 26 | } 27 | printf("Yes\n"); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /src/recreation/sereja.and.suffixes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int a[100100]; 5 | int freq[100100]; 6 | int l[100100]; 7 | int ans[100100]; 8 | int main(void) { 9 | int n, m; 10 | scanf("%d %d", &n, &m); 11 | for (int i = 1; i <= n; i++) 12 | scanf("%d", &a[i]); 13 | for (int i = 1; i <= m; i++) 14 | scanf("%d", &l[i]); 15 | int cnt = 0; 16 | for (int i = n; i >= 1; i--) { 17 | if (freq[a[i]] == 0) { 18 | cnt += 1; 19 | freq[a[i]] = 1; 20 | } 21 | ans[i] = cnt; 22 | } 23 | for (int i = 1; i <= m; i++) { 24 | printf("%d\n", ans[l[i]]); 25 | } 26 | } 27 | 28 | 29 | -------------------------------------------------------------------------------- /src/recreation/three.displays.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long ll; 4 | const ll inf = 1e18; 5 | 6 | 7 | 8 | ll dp[5][3003]; 9 | int s[3030], c[3030]; 10 | 11 | int main(void) { 12 | int n; 13 | scanf("%d", &n); 14 | for (int i = 1; i <= n; i++) 15 | scanf("%d", &s[i]); 16 | for (int i = 1; i <= n; i++) 17 | scanf("%d", &c[i]); 18 | for (int i = 1; i <= n; i++) 19 | dp[1][i] = c[i]; 20 | for (int i = 2; i <= 3; i++) { 21 | for (int j = n; j >= 1; j--) { 22 | dp[i][j] = inf; 23 | for (int nxt = j + 1; nxt <= n; nxt++) 24 | if (s[nxt] > s[j]) 25 | dp[i][j] = min(dp[i][j], c[j] + dp[i - 1][nxt]); 26 | } 27 | } 28 | ll ans = inf; 29 | for (int i = 1; i <= n; i++) 30 | ans = min(ans, dp[3][i]); 31 | printf("%lld\n", ans == inf ? -1 : ans); 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /src/rs/equalornotequal.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | 3 | 4 | fn main() { 5 | let mut t = String::new(); 6 | io::stdin().read_line(&mut t).expect("input error"); 7 | let mut t: i32 = t.trim().parse().expect("input error"); 8 | while t > 0 { 9 | let mut input = String::new(); 10 | io::stdin().read_line(&mut input).expect("input error"); 11 | if input.matches('N').count() == 1 { 12 | println!("NO"); 13 | } else { 14 | println!("YES"); 15 | } 16 | t -= 1; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/rs/trianglesonarectangle.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | use std::cmp::max; 3 | 4 | fn get_line() -> Vec { 5 | let mut input = String::new(); 6 | io::stdin().read_line(&mut input).expect("could not read line"); 7 | return input.trim().split_whitespace().map(|x| x.parse().unwrap()).collect::>(); 8 | } 9 | 10 | fn main() { 11 | let mut t = get_line()[0]; 12 | while t > 0 { 13 | t -= 1; 14 | let mut line = get_line(); 15 | let (w, h) = (line[0], line[1]); 16 | line = get_line(); 17 | let (minx1, maxx1) = (line[1], line[line[0] as usize]); 18 | line = get_line(); 19 | let (minx2, maxx2) = (line[1], line[line[0] as usize]); 20 | let basex = max(maxx1 - minx1, maxx2 - minx2); 21 | 22 | line = get_line(); 23 | let (miny1, maxy1) = (line[1], line[line[0] as usize]); 24 | line = get_line(); 25 | let (miny2, maxy2) = (line[1], line[line[0] as usize]); 26 | let basey = max(maxy1 - miny1, maxy2 - miny2); 27 | 28 | 29 | let ans = max(basex * h, basey * w); 30 | println!("{}", ans); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/snackdown/givcandy.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef long long int lli; 4 | 5 | lli gcd(lli a, lli b) { 6 | while (b != 0) { 7 | lli t = b; 8 | b = a % b; 9 | a = t; 10 | } 11 | return a; 12 | } 13 | 14 | int main(void) { 15 | int t; 16 | scanf("%d", &t); 17 | while (t--) { 18 | lli a, b, c, d; 19 | scanf("%lld %lld %lld %lld", &a, &b, &c, &d); 20 | lli g = gcd(c, d); 21 | lli right = b - a; 22 | lli rem = right % g; 23 | if (rem < 0) 24 | rem += g; 25 | lli ans = min(rem, g - rem); 26 | printf("%lld\n", ans); 27 | } 28 | } 29 | 30 | 31 | -------------------------------------------------------------------------------- /src/snackdown/ndiffpal.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(void) { 5 | int t; 6 | scanf("%d", &t); 7 | while (t--) { 8 | int n; 9 | scanf("%d", &n); 10 | for (int i = 0; i < n; i++) 11 | printf("%c", (i % 3) + 'a'); 12 | printf("\n"); 13 | } 14 | return 0; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /src/snackdown/table.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int a[10010]; 4 | int b[10010]; 5 | int main(void) { 6 | int t; 7 | scanf("%d", &t); 8 | while (t--) { 9 | int n; 10 | scanf("%d", &n); 11 | int ans = 0; 12 | a[0] = 0; 13 | for (int i = 1; i <= n; i++) 14 | scanf("%d", a+i); 15 | for (int i = 1; i <= n; i++) { 16 | scanf("%d", b+i); 17 | if (a[i] - a[i-1] >= b[i]) 18 | ans++; 19 | } 20 | printf("%d\n", ans); 21 | } 22 | return 0; 23 | } 24 | --------------------------------------------------------------------------------