Submissions

Auto-generated with ❤ using Harwest

Introduction

A repository to keep track of problem solving practice, containing solutions from platforms:

Codeforces
AtCoder

#	Title	Solution	Tags	Submitted
1512	D - Caesar's Legions	C++20 (GCC 13-64)	`dp` `*1700`	Jul/25/2024 02:48
1511	A - Diverse Game	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `implementation`	Jul/24/2024 13:55
1510	B - Number Circle	C++20 (GCC 13-64)	`greedy` `math` `sortings` `*1100`	Jul/16/2024 23:21
1509	B - Make Majority	C++20 (GCC 13-64)	`greedy` `implementation` `*900`	Jul/15/2024 21:59
1508	B - The Best Gift	C++20 (GCC 13-64)	`constructive algorithms` `implementation` `*1100`	Jul/14/2024 00:17
1507	B - Dinner with Emma	C++20 (GCC 13-64)	`games` `greedy` `*1000`	Jul/13/2024 23:53
1506	E - XOR on Segment	C++20 (GCC 13-64)	`bitmasks` `data structures` `*2000`	Jul/13/2024 00:15
1505	D - Test of Love	C++20 (GCC 13-64)	`dp` `greedy` `implementation` `*1200`	Jul/12/2024 00:37
1504	C - Gorilla and Permutation	C++20 (GCC 13-64)	`constructive algorithms` `math` `*900`	Jul/11/2024 21:37
1503	A - Only Pluses	C++20 (GCC 13-64)	`brute force` `constructive algorithms` `greedy` `math` `sortings` `*800`	Jul/11/2024 20:59
1502	B - Angry Monk	C++20 (GCC 13-64)	`greedy` `math` `sortings` `*800`	Jul/11/2024 20:49
1501	B - Corner Twist	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `implementation` `math` `*1200`	Jul/08/2024 01:26
1500	A - Array Divisibility	C++20 (GCC 13-64)	`constructive algorithms` `math` `*800`	Jul/08/2024 00:33
1499	B - Interesting Subarray	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `math` `*1200`	Jul/07/2024 16:42
1498	B - Assigning to Classes	C++20 (GCC 13-64)	`greedy` `implementation` `sortings` `*1000`	Jul/07/2024 16:29
1497	B - Mahmoud and Ehab and the message	C++20 (GCC 13-64)	`dsu` `greedy` `implementation` `*1200`	Jul/05/2024 00:48
1496	A - BowWow and the Timetable	C++20 (GCC 13-64)	`math` `*1000`	Jul/03/2024 01:01
1495	A - XXXXX	C++20 (GCC 13-64)	`brute force` `data structures` `number theory` `two pointers` `*1200`	Jul/03/2024 00:12
1494	A - Ilya and a Colorful Walk	C++20 (GCC 13-64)	`greedy` `implementation` `*1100`	Jul/02/2024 23:44
1493	B - Make Product Equal One	C++20 (GCC 13-64)	`dp` `implementation` `*900`	Jul/02/2024 22:57
1492	A - Subtract or Divide	C++20 (GCC 13-64)	`greedy` `math` `*800`	Jul/02/2024 22:34
1491	A - Equality	C++20 (GCC 13-64)	`implementation` `strings` `*800`	Jul/02/2024 22:25
1490	A - Co-prime Array	C++20 (GCC 13-64)	`greedy` `implementation` `math` `number theory` `*1200`	Jul/01/2024 22:14
1489	A - Kuroni and the Gifts	C++20 (GCC 13-64)	`brute force` `constructive algorithms` `greedy` `sortings` `*800`	Jul/01/2024 02:20
1488	A - Keanu Reeves	C++20 (GCC 13-64)	`strings` `*800`	Jul/01/2024 02:12
1487	A - Mahmoud and Longest Uncommon Subsequence	C++20 (GCC 13-64)	`constructive algorithms` `strings` `*1000`	Jul/01/2024 02:03
1486	A - Mahmoud and Ehab and the MEX	C++20 (GCC 13-64)	`greedy` `implementation` `*1000`	Jul/01/2024 01:56
1485	A - Ehab Fails to Be Thanos	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `sortings` `*1000`	Jul/01/2024 01:37
1484	C - Basil's Garden	C++20 (GCC 13-64)	`dp` `greedy` `*1200`	Jul/01/2024 01:31
1483	B - K-Sort	C++20 (GCC 13-64)	`greedy` `*1000`	Jun/30/2024 21:31
1482	A - Upload More RAM	C++20 (GCC 13-64)	`greedy` `math` `*800`	Jun/30/2024 20:39
1481	A - EhAb AnD gCd	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `number theory` `*800`	Jun/30/2024 16:11
1480	C - Two Movies	C++20 (GCC 13-64)	`greedy` `*1400`	Jun/29/2024 01:52
1479	A - Catch the Coin	C++20 (GCC 13-64)	`implementation` `*800`	Jun/27/2024 22:30
1478	B - Substring and Subsequence	C++20 (GCC 13-64)	`brute force` `greedy` `strings` `*1200`	Jun/27/2024 21:37
1477	E - Beautiful Array	C++20 (GCC 13-64)	`greedy` `math` `number theory` `sortings` `*1700`	Jun/26/2024 23:33
1476	D - Mathematical Problem	C++20 (GCC 13-64)	`brute force` `dp` `greedy` `implementation` `math` `two pointers` `*1400`	Jun/26/2024 19:17
1475	B - Collatz Conjecture	C++20 (GCC 13-64)	`brute force` `implementation` `math` `number theory` `*1200`	Jun/25/2024 22:27
1474	C - Boring Day	C++20 (GCC 13-64)	`binary search` `data structures` `dp` `greedy` `two pointers` `*1200`	Jun/25/2024 21:58
1473	A - Soccer	C++20 (GCC 13-64)	`greedy` `implementation` `math` `sortings` `*800`	Jun/25/2024 20:56
1472	C - Update Queries	C++20 (GCC 13-64)	`data structures` `greedy` `sortings` `*1100`	Jun/23/2024 21:16
1471	B - Matrix Stabilization	C++20 (GCC 13-64)	`brute force` `data structures` `greedy` `sortings` `*1000`	Jun/23/2024 21:04
1470	A - X Axis	C++20 (GCC 13-64)	`brute force` `geometry` `math` `sortings` `*800`	Jun/23/2024 20:52
1469	B - Array Walk	C++20 (GCC 13-64)	`brute force` `dp` `greedy` `*1600`	Jun/22/2024 00:27
1468	B - Array Cancellation	C++20 (GCC 13-64)	`constructive algorithms` `implementation` `*1000`	Jun/20/2024 00:21
1467	A - Road To Zero	C++20 (GCC 13-64)	`greedy` `math` `*1000`	Jun/19/2024 23:57
1466	E - Advertising Agency	C++20 (GCC 13-64)	`combinatorics` `math` `sortings` `*1600`	Jun/18/2024 02:14
1465	C - Manhattan Permutations	C++20 (GCC 13-64)	`constructive algorithms` `data structures` `greedy` `implementation` `math` `*1300`	Jun/17/2024 03:42
1464	B - New Bakery	C++20 (GCC 13-64)	`binary search` `greedy` `math` `ternary search` `*800`	Jun/17/2024 02:32
1463	A - Alice and Books	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `sortings` `*800`	Jun/17/2024 02:12
1462	C - Chocolate Bunny	C++20 (GCC 13-64)	`constructive algorithms` `interactive` `math` `two pointers` `*1600`	Jun/14/2024 22:51
1461	H1 - Maximize the Largest Component (Easy Version)	C++20 (GCC 13-64)	`brute force` `data structures` `dfs and similar` `dsu` `graphs` `implementation` `*1700`	Jun/13/2024 03:34
1460	F - Final Boss	C++20 (GCC 13-64)	`binary search` `data structures` `*1500`	Jun/11/2024 22:04
1459	E - Secret Box	C++20 (GCC 13-64)	`brute force` `combinatorics` `math` `*1200`	Jun/11/2024 21:34
1458	D - Manhattan Circle	C++20 (GCC 13-64)	`implementation` `math` `*900`	Jun/11/2024 21:17
1457	C - Good Prefixes	C++20 (GCC 13-64)	`greedy` `*1000`	Jun/11/2024 21:10
1456	B - Maximum Multiple Sum	C++20 (GCC 13-64)	`brute force` `math` `number theory` `*800`	Jun/11/2024 20:42
1455	A - Creating Words	C++20 (GCC 13-64)	`implementation` `strings` `*800`	Jun/11/2024 20:36
1454	B - Large Addition	C++20 (GCC 13-64)	`implementation` `math` `*1100`	Jun/10/2024 02:56
1453	A - Strange Splitting	C++20 (GCC 13-64)	`constructive algorithms` `*800`	Jun/09/2024 20:39
1452	D - Flowers	C++20 (GCC 13-64)	`dp` `*1700`	Jun/08/2024 23:30
1451	B - XOR Sequences	C++20 (GCC 13-64)	`bitmasks` `greedy` `*1000`	Jun/08/2024 03:38
1450	F - Consecutive Subsequence	C++20 (GCC 13-64)	`dp` `*1700`	Jun/08/2024 01:54
1449	D - Fixing a Binary String	C++20 (GCC 13-64)	`bitmasks` `brute force` `constructive algorithms` `greedy` `hashing` `strings` `*1800`	Jun/07/2024 22:59
1448	C - Earning on Bets	C++20 (GCC 13-64)	`binary search` `combinatorics` `constructive algorithms` `number theory` `*1200`	Jun/06/2024 22:04
1447	A - Guess the Maximum	C++20 (GCC 13-64)	`brute force` `greedy` `implementation` `*800`	Jun/06/2024 20:41
1446	D - A-B-C Sort	C++20 (GCC 13-64)	`constructive algorithms` `implementation` `sortings` `*1200`	Jun/06/2024 02:45
1445	C - Powers Of Two	C++20 (GCC 13-64)	`bitmasks` `greedy` `*1400`	Jun/06/2024 00:53
1444	B - Array Stabilization	C++20 (GCC 13-64)	`implementation` `*900`	Jun/06/2024 00:02
1443	E - Permutation of Rows and Columns	C++20 (GCC 13-64)	`constructive algorithms` `data structures` `greedy` `hashing` `implementation` `math` `matrices` `sortings` `*1600`	Jun/05/2024 17:08
1442	D - GCD-sequence	C++20 (GCC 13-64)	`greedy` `implementation` `math` `number theory` `*1400`	Jun/05/2024 14:04
1441	C - Number of Ways	C++20 (GCC 13-64)	`binary search` `brute force` `data structures` `dp` `two pointers` `*1700`	Jun/04/2024 23:18
1440	C - Sofia and the Lost Operations	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `*1300`	Jun/03/2024 21:36
1439	B - Choosing Cubes	C++20 (GCC 13-64)	`sortings` `sortings` `*800`	Jun/03/2024 21:00
1438	A - Problem Generator	C++20 (GCC 13-64)	`math` `*800`	Jun/03/2024 20:38
1437	B - Not simply beatiful strings	C++20 (GCC 13-64)	`implementation` `*1400`	Jun/02/2024 21:14
1436	C - Shifts	C++20 (GCC 13-64)	`binary search` `data structures` `dp` `implementation` `*1500`	Jun/01/2024 20:32
1435	B - Increase/Decrease/Copy	C++20 (GCC 13-64)	`greedy` `implementation` `*1100`	Jun/01/2024 17:16
1434	B - Turtle and an Infinite Sequence	C++20 (GCC 13-64)	`bitmasks` `math` `*1300`	May/31/2024 18:57
1433	A - Turtle and Piggy Are Playing a Game	C++20 (GCC 13-64)	`brute force` `greedy` `math` `*800`	May/31/2024 16:13
1432	A - Verify Password	C++20 (GCC 13-64)	`implementation` `sortings` `strings` `*800`	May/30/2024 20:58
1431	B - The least round way	C++20 (GCC 13-64)	`dp` `math` `*2000`	May/29/2024 03:13
1430	D - Required Length	C++20 (GCC 13-64)	`brute force` `dfs and similar` `dp` `hashing` `shortest paths` `*1700`	May/28/2024 03:05
1429	C - Double Sort	C++20 (GCC 13-64)	`implementation` `sortings` `*1200`	May/28/2024 01:52
1428	A - Little Nikita	C++20 (GCC 13-64)	`math` `*800`	May/26/2024 20:38
1427	A - Qingshan Loves Strings 2	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `implementation` `*1300`	May/26/2024 02:56
1426	C - Chamo and Mocha's Array	C++20 (GCC 13-64)	`binary search` `brute force` `greedy` `*1200`	May/26/2024 02:32
1425	B - 378QAQ and Mocha's Array	C++20 (GCC 13-64)	`brute force` `greedy` `math` `sortings` `*1000`	May/25/2024 23:11
1424	A - Bazoka and Mocha's Array	C++20 (GCC 13-64)	`brute force` `greedy` `implementation` `sortings` `*800`	May/25/2024 20:39
1423	B - PIN Codes	C++20 (GCC 13-64)	`greedy` `implementation` `*1400`	May/24/2024 22:35
1422	D - Secret Passwords	C++20 (GCC 13-64)	`dfs and similar` `dsu` `graphs` `*1500`	May/24/2024 22:09
1421	A - Row GCD	C++20 (GCC 13-64)	`math` `number theory` `*1600`	May/24/2024 04:43
1420	B - JoJo's Incredible Adventures	C++20 (GCC 13-64)	`math` `strings` `two pointers` `*1100`	May/24/2024 03:12
1419	B - Lost Numbers	C++20 (GCC 13-64)	`brute force` `divide and conquer` `interactive` `math` `*1400`	May/23/2024 03:34
1418	B - Cat, Fox and the Lonely Array	C++20 (GCC 13-64)	`binary search` `bitmasks` `data structures` `greedy` `math` `two pointers` `*1300`	May/22/2024 00:45
1417	C - Beautiful Triple Pairs	C++20 (GCC 13-64)	`combinatorics` `data structures` `*1400`	May/21/2024 22:14
1416	B - Symmetric Encoding	C++20 (GCC 13-64)	`implementation` `sortings` `strings` `*800`	May/20/2024 21:00
1415	A - Phone Desktop	C++20 (GCC 13-64)	`greedy` `math` `*800`	May/20/2024 20:49
1414	B - AND Sorting	C++20 (GCC 13-64)	`bitmasks` `constructive algorithms` `sortings` `*1100`	May/19/2024 22:31
1413	B - Difference of GCDs	C++20 (GCC 13-64)	`constructive algorithms` `math` `*1100`	May/19/2024 22:13
1412	C - Sereja and Brackets	C++20 (GCC 13-64)	`data structures` `schedules` `*2000`	May/18/2024 23:34
1411	A - Chess For Three	C++20 (GCC 13-64)	`brute force` `dp` `implementation` `math` `*900`	May/17/2024 21:13
1410	B - Triangles on a Rectangle	C++20 (GCC 13-64)	`geometry` `greedy` `math` `*1000`	May/16/2024 21:57
1409	B - Luke is a Foodie	C++20 (GCC 13-64)	`brute force` `greedy` `implementation` `*1000`	May/16/2024 20:31
1408	C - Palindrome Basis	C++20 (GCC 13-64)	`brute force` `dp` `math` `number theory` `*1500`	May/16/2024 18:51
1407	H - Maximal AND	C++20 (GCC 13-64)	`bitmasks` `greedy` `math` `*1300`	May/14/2024 23:25
1406	B - WOW Factor	C++20 (GCC 13-64)	`dp` `strings` `*1300`	May/13/2024 01:13
1405	C1 - Game on Tree (Easy)	C++20 (GCC 13-64)	`games` `*1400`	May/11/2024 02:25
1404	C2 - Game on Tree (Medium)	C++20 (GCC 13-64)	`dfs and similar` `dp` `games` `trees` `*1700`	May/11/2024 02:25
1403	G - XOUR	C++20 (GCC 13-64)	`data structures` `dsu` `sortings` `*1400`	May/11/2024 01:45
1402	D - Binary Cut	C++20 (GCC 13-64)	`dp` `greedy` `implementation` `sortings` `strings` `*1100`	May/10/2024 23:09
1401	C - Clock and Strings	C++20 (GCC 13-64)	`implementation` `*900`	May/10/2024 22:34
1400	B - Different String	C++20 (GCC 13-64)	`implementation` `strings` `*800`	May/10/2024 21:00
1399	A - My First Sorting Problem	C++20 (GCC 13-64)	`implementation` `sortings` `*800`	May/10/2024 20:36
1398	C - Jatayu's Balanced Bracket Sequence	C++20 (GCC 13-64)	`data structures` `dsu` `graphs` `greedy` `*1300`	May/10/2024 17:16
1397	C - Minimize the Thickness	C++20 (GCC 13-64)	`brute force` `greedy` `math` `two pointers` `*1100`	May/08/2024 21:07
1396	C - Scoring Subsequences	C++20 (GCC 13-64)	`binary search` `greedy` `math` `two pointers` `*1300`	May/08/2024 20:41
1395	A - Start Up	C++20 (GCC 13-64)	`implementation` `*1000`	May/07/2024 23:05
1394	C - Simple Strings	C++20 (GCC 13-64)	`dp` `greedy` `strings` `*1300`	May/06/2024 21:23
1393	A1 - Balanced Shuffle (Easy)	C++20 (GCC 13-64)	`implementation` `sortings` `*1000`	May/05/2024 20:31
1392	C - Add One	C++20 (GCC 13-64)	`dp` `matrices` `*1600`	May/04/2024 01:17
1391	D - Permutation Game	C++20 (GCC 13-64)	`brute force` `dfs and similar` `games` `graphs` `greedy` `math` `*1300`	May/02/2024 23:13
1390	A - Maximize?	C++20 (GCC 13-64)	`brute force` `math` `number theory` `*800`	May/02/2024 23:02
1389	B - Prefiquence	C++20 (GCC 13-64)	`greedy` `two pointers` `*800`	May/02/2024 23:02
1388	C - Assembly via Remainders	C++20 (GCC 13-64)	`constructive algorithms` `number theory` `*1000`	May/02/2024 23:02
1387	B - Coin Games	C++20 (GCC 13-64)	`games` `*900`	May/02/2024 17:57
1386	A - Contest Proposal	C++20 (GCC 13-64)	`brute force` `greedy` `two pointers` `*800`	May/01/2024 13:41
1385	D - Fixed Point Guessing	C++20 (GCC 13-64)	`binary search` `constructive algorithms` `interactive` `*1600`	Apr/30/2024 02:30
1384	B - Shifts and Sorting	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `*1000`	Apr/29/2024 20:48
1383	A - Two Friends	C++20 (GCC 13-64)	`constructive algorithms` `implementation` `math` `*800`	Apr/29/2024 20:41
1382	E - Split Into Two Sets	C++20 (GCC 13-64)	`dfs and similar` `dsu` `graphs` `*1600`	Apr/27/2024 22:55
1381	B - Rectangle Filling	C++20 (GCC 13-64)	`constructive algorithms` `implementation` `*1100`	Apr/27/2024 21:18
1380	A - Card Exchange	C++20 (GCC 13-64)	`constructive algorithms` `games` `greedy` `*800`	Apr/27/2024 20:42
1379	D - Say No to Palindromes	C++20 (GCC 13-64)	`brute force` `constructive algorithms` `dp` `strings` `*1600`	Apr/24/2024 18:54
1378	B - Meeting on the Line	C++20 (GCC 13-64)	`binary search` `geometry` `greedy` `implementation` `math` `ternary search` `*1600`	Apr/23/2024 22:03
1377	B - A BIT of a Construction	C++20 (GCC 13-64)	`bitmasks` `constructive algorithms` `greedy` `implementation` `*1100`	Apr/23/2024 20:22
1376	A - Stickogon	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `*800`	Apr/23/2024 01:56
1375	A - Buying Torches	C++20 (GCC 13-64)	`math` `*1000`	Apr/17/2024 14:30
1374	B - Beautiful Array	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `math` `*1000`	Apr/17/2024 13:55
1373	A - Helmets in Night Light	C++20 (GCC 13-64)	`greedy` `sortings` `*1000`	Apr/17/2024 13:24
1372	C - Nene's Magical Matrix	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `math` `*1600`	Apr/15/2024 01:58
1371	B - Nene and the Card Game	C++20 (GCC 13-64)	`games` `greedy` `*800`	Apr/13/2024 20:50
1370	A - Nene's Game	C++20 (GCC 13-64)	`binary search` `brute force` `data structures` `games` `greedy` `*800`	Apr/13/2024 20:42
1369	B - Make It Ugly	C++20 (GCC 13-64)	`implementation` `math` `*1200`	Apr/13/2024 13:26
1368	C - Long Multiplication	C++20 (GCC 13-64)	`greedy` `math` `number theory` `*1200`	Apr/13/2024 13:12
1367	A - Painting the Ribbon	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `math` `*900`	Apr/13/2024 12:37
1366	B - Basketball Together	C++20 (GCC 13-64)	`binary search` `greedy` `sortings` `*1000`	Apr/10/2024 05:42
1365	A - Walking Master	C++20 (GCC 13-64)	`geometry` `greedy` `math` `*800`	Apr/10/2024 05:08
1364	B - Luntik and Subsequences	C++20 (GCC 13-64)	`combinatorics` `math` `*900`	Apr/10/2024 03:56
1363	A - Strange Partition	C++20 (GCC 13-64)	`greedy` `math` `number theory` `*900`	Apr/10/2024 03:40
1362	B - Progressive Square	C++20 (GCC 13-64)	`constructive algorithms` `data structures` `implementation` `sortings` `*1000`	Apr/10/2024 00:42
1361	A - Yogurt Sale	C++20 (GCC 13-64)	`math` `*800`	Apr/10/2024 00:26
1360	C - Homework	C++20 (GCC 13-64)	`greedy` `*1200`	Apr/09/2024 22:32
1359	A - Halloumi Boxes	C++20 (GCC 13-64)	`brute force` `greedy` `sortings` `*800`	Apr/09/2024 19:53
1358	A - Desorting	C++20 (GCC 13-64)	`brute force` `greedy` `math` `*800`	Apr/09/2024 19:39
1357	A - Serval and Mocha's Array	C++20 (GCC 13-64)	`brute force` `math` `number theory` `*800`	Apr/09/2024 19:28
1356	C - Ticket Hoarding	C++20 (GCC 13-64)	`greedy` `math` `sortings` `*1400`	Apr/07/2024 05:07
1355	B - Battle Cows	C++20 (GCC 13-64)	`binary search` `data structures` `greedy` `*1200`	Apr/07/2024 04:47
1354	A - Dual Trigger	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `math` `*900`	Apr/07/2024 00:18
1353	D - Strong Vertices	C++20 (GCC 13-64)	`math` `sortings` `trees` `*1300`	Apr/05/2024 16:25
1352	E - Mirror Grid	C++20 (GCC 13-64)	`implementation` `*1200`	Apr/02/2024 05:25
1351	F - You Are So Beautiful	C++20 (GCC 13-64)	`data structures` `*1400`	Apr/02/2024 03:40
1350	D - Are You a Procrastinator?	C++20 (GCC 13-64)	`implementation`	Apr/02/2024 01:06
1349	B - Is it stated?	C++20 (GCC 13-64)	`strings`	Apr/01/2024 21:28
1348	G2 - Dances (Hard Version)	C++20 (GCC 13-64)	`binary search` `greedy` `sortings` `two pointers` `*1900`	Apr/01/2024 05:22
1347	G1 - Dances (Easy version)	C++20 (GCC 13-64)	`binary search` `greedy` `two pointers` `*1400`	Apr/01/2024 03:41
1346	E - Sending a Sequence Over the Network	C++20 (GCC 13-64)	`dp` `*1600`	Mar/31/2024 05:07
1345	A - Farmer John's Challenge	C++20 (GCC 13-64)	`constructive algorithms` `math` `*800`	Mar/31/2024 01:58
1344	C - Interesting Sequence	C++20 (GCC 13-64)	`bitmasks` `math` `*1600`	Mar/30/2024 05:32
1343	E - Nearly Shortest Repeating Substring	C++20 (GCC 13-64)	`brute force` `implementation` `number theory` `strings` `*1500`	Mar/29/2024 04:38
1342	D - Product of Binary Decimals	C++20 (GCC 13-64)	`brute force` `dp` `implementation` `number theory` `*1100`	Mar/29/2024 03:54
1341	C - Clock Conversion	C++20 (GCC 13-64)	`implementation` `math` `*800`	Mar/29/2024 03:24
1340	B - Upscaling	C++20 (GCC 13-64)	`implementation` `*800`	Mar/29/2024 03:11
1339	A - Stair, Peak, or Neither?	C++20 (GCC 13-64)	`implementation` `*800`	Mar/29/2024 03:05
1338	B - Shoe Shuffling	C++20 (GCC 13-64)	`constructive algorithms` `greedy` `implementation` `two pointers` `*1000`	Mar/29/2024 03:00
1337	C - Equal Frequencies	C++20 (GCC 13-64)	`brute force` `constructive algorithms` `greedy` `implementation` `sortings` `strings` `*1600`	Mar/29/2024 02:15
1336	D - Triangle Coloring	C++20 (GCC 13-64)	`combinatorics` `math` `*1600`	Mar/27/2024 20:34
1335	G - Hits Different	C++20 (GCC 13-64)	`data structures` `dp` `implementation` `math` `*1600`	Mar/26/2024 02:19
1334	B - Shuffle	C++20 (GCC 13-64)	`math` `two pointers` `*1300`	Mar/26/2024 00:19
1333	C - Turtle Fingers: Count the Values of k	C++20 (GCC 13-64)	`brute force` `implementation` `math` `number theory` `*1100`	Mar/24/2024 05:23
1332	D - Binary String To Subsequences	C++20 (GCC 13-64)	`constructive algorithms` `data structures` `greedy` `implementation` `*1500`	Mar/24/2024 00:05
1331	C - Replacement	C++20 (GCC 13-64)	`constructive algorithms` `data structures` `implementation` `*1600`	Mar/23/2024 23:31
1330	B - Maximum Sum	C++20 (GCC 13-64)	`dp` `greedy` `math` `*1100`	Mar/23/2024 01:27
1329	A - Median of an Array	C++20 (GCC 13-64)	`greedy` `implementation` `*800`	Mar/23/2024 00:44
1328	E - Final Countdown	C++20 (GCC 13-64)	`implementation` `math` `number theory` `*1600`	Mar/23/2024 00:19
1327	C - Flexible String	C++20 (GCC 13-64)	`bitmasks` `brute force` `strings` `*1600`	Mar/22/2024 18:39
1326	B - Fireworks	C++17 (GCC 7-32)	`math` `number theory` `*900`	Mar/22/2024 17:07
1325	D - Seraphim the Owl	C++17 (GCC 7-32)	`dp` `greedy` `*1300`	Mar/22/2024 16:42
1324	E - Binary Search	C++17 (GCC 7-32)	`binary search` `constructive algorithms` `greedy` `sortings` `*1700`	Mar/22/2024 02:25
1323	A - Setting up Camp	C++17 (GCC 7-32)	`greedy` `math` `*800`	Mar/21/2024 23:19
1322	E - Round Dance	C++17 (GCC 7-32)	`dfs and similar` `dsu` `graphs` `shortest paths` `*1600`	Mar/21/2024 21:04
1321	D - The Clock	C++14 (GCC 6-32)	`brute force` `implementation` `*1100`	Mar/18/2024 04:58
1320	H2 - Maximum Crossings (Hard Version)	C++14 (GCC 6-32)	`data structures` `divide and conquer` `sortings` `*1500`	Mar/18/2024 01:25
1319	H1 - Maximum Crossings (Easy Version)	C++14 (GCC 6-32)	`brute force` `*1400`	Mar/18/2024 01:03
1318	C - MEX Game 1	C++14 (GCC 6-32)	`constructive algorithms` `games` `greedy` `*1300`	Mar/18/2024 00:07
1317	B - Equal XOR	C++14 (GCC 6-32)	`bitmasks` `constructive algorithms` `*1100`	Mar/17/2024 20:22
1316	A - Destroying Bridges	C++14 (GCC 6-32)	`graphs` `greedy` `math` `*800`	Mar/17/2024 19:01
1315	C - Arrow Path	C++14 (GCC 6-32)	`brute force` `constructive algorithms` `dfs and similar` `dp` `graphs` `shortest paths` `*1300`	Mar/17/2024 01:49
1314	B - Array Fix	C++14 (GCC 6-32)	`brute force` `dp` `greedy` `implementation` `*1100`	Mar/16/2024 19:18
1313	A - Special Characters	C++14 (GCC 6-32)	`brute force` `constructive algorithms` `*800`	Mar/16/2024 19:02
1312	C - Circular RMQ	C++14 (GCC 6-32)	`data structures` `*2200`	Mar/15/2024 03:31
1311	B - Rudolf and 121	C++14 (GCC 6-32)	`brute force` `dp` `greedy` `math` `*1000`	Mar/14/2024 03:43
1310	G - Fall Down	C++14 (GCC 6-32)	`dfs and similar` `implementation` `*1200`	Mar/14/2024 02:56
1309	E - Binary Deque	C++14 (GCC 6-32)	`binary search` `implementation` `two pointers` `*1200`	Mar/14/2024 02:27
1308	F - 3SUM	C++17 (GCC 7-32)	`brute force` `math` `*1300`	Mar/14/2024 00:22
1307	F - Yet Another Problem About Pairs Satisfying an Inequality	C++17 (GCC 7-32)	`binary search` `data structures` `dp` `greedy` `sortings` `*1300`	Mar/13/2024 20:36
1306	D - Rudolf and the Ball Game	C++17 (GCC 7-32)	`dp` `implementation` `*1200`	Mar/13/2024 00:36
1305	C - Rudolf and the Ugly String	C++17 (GCC 7-32)	`dp` `strings` `*900`	Mar/13/2024 00:07
1304	E - Rudolf and k Bridges	C++17 (GCC 7-32)	`binary search` `data structures` `dp` `two pointers` `*1600`	Mar/12/2024 23:45
1303	A - Rudolf and the Ticket	C++17 (GCC 7-32)	`brute force` `math` `*800`	Mar/12/2024 18:41
1302	A - Linova and Kingdom	C++17 (GCC 7-32)	`dfs and similar` `dp` `greedy` `sortings` `trees` `*1600`	Mar/12/2024 03:00
1301	C - Kuroni and Impossible Calculation	C++17 (GCC 7-32)	`brute force` `combinatorics` `math` `number theory` `*1600`	Mar/11/2024 22:59
1300	E - Tracking Segments	C++20 (GCC 11-64)	`binary search` `brute force` `data structures` `two pointers` `*1600`	Mar/11/2024 02:32
1299	E - Good Triples	C++20 (GCC 11-64)	`brute force` `combinatorics` `number theory` `*1600`	Mar/10/2024 01:15
1298	C - Leha and Function	C++20 (GCC 11-64)	`greedy` `*1300`	Mar/09/2024 16:10
1297	B - Godsend	C++20 (GCC 11-64)	`games` `math` `*1100`	Mar/09/2024 14:35
1296	C - Messenger in MAC	C++20 (GCC 11-64)	`binary search` `brute force` `constructive algorithms` `data structures` `dp` `greedy` `sortings` `*1800`	Mar/08/2024 20:36
1295	B - Informatics in MAC	C++20 (GCC 11-64)	`constructive algorithms` `*1200`	Mar/08/2024 17:01
1294	A - Entertainment in MAC	C++20 (GCC 11-64)	`constructive algorithms` `strings` `*800`	Mar/08/2024 16:28
1293	A - Case of Matryoshkas	C++20 (GCC 11-64)	`implementation` `*1500`	Mar/08/2024 15:48
1292	C - Permutation Operations	C++20 (GCC 11-64)	`constructive algorithms` `greedy` `implementation` `math` `*1300`	Mar/03/2024 17:10
1291	B - Yet Another Coin Problem	C++20 (GCC 11-64)	`brute force` `dp` `greedy` `math` `*1200`	Mar/03/2024 04:12
1290	A - Too Min Too Max	C++20 (GCC 11-64)	`greedy` `math` `*800`	Mar/03/2024 03:36
1289	C - Bitwise Operation Wizard	C++20 (GCC 11-64)	`bitmasks` `constructive algorithms` `interactive` `*1700`	Mar/02/2024 23:55
1288	C - Find B	C++20 (GCC 11-64)	`constructive algorithms` `greedy` `*1400`	Mar/02/2024 01:26
1287	C - Lexicographically Largest	C++20 (GCC 11-64)	`binary search` `constructive algorithms` `data structures` `greedy` `sortings` `*1700`	Mar/01/2024 19:44
1286	B - Binary Path	C++20 (GCC 11-64)	`dp` `greedy` `implementation` `*1300`	Feb/29/2024 21:12
1285	A - Shuffle Party	C++20 (GCC 11-64)	`implementation` `math` `*800`	Feb/29/2024 20:42
1284	B - Integers Shop	C++20 (GCC 11-64)	`data structures` `greedy` `implementation` `*1500`	Feb/29/2024 15:53
1283	E - Air Conditioners	C++20 (GCC 11-64)	`data structures` `dp` `implementation` `shortest paths` `sortings` `two pointers` `*1500`	Feb/29/2024 14:47
1282	D - Deleting Divisors	C++20 (GCC 11-64)	`games` `math` `number theory` `*1700`	Feb/29/2024 02:46
1281	E1 - Erase and Extend (Easy Version)	C++20 (GCC 11-64)	`binary search` `brute force` `dp` `greedy` `hashing` `implementation` `string suffix structures` `strings` `two pointers` `*1600`	Feb/28/2024 23:56
1280	C - Strange Function	C++20 (GCC 11-64)	`math` `number theory` `*1600`	Feb/28/2024 17:53
1279	E - Turtle vs. Rabbit Race: Optimal Trainings	C++20 (GCC 11-64)	`binary search` `implementation` `math` `ternary search` `*1500`	Feb/28/2024 15:05
1278	D - Turtle Tenacity: Continual Mods	C++20 (GCC 11-64)	`constructive algorithms` `greedy` `math` `number theory` `sortings` `*1200`	Feb/27/2024 21:07
1277	B - Turtle Math: Fast Three Task	C++20 (GCC 11-64)	`implementation` `math` `number theory` `*800`	Feb/27/2024 20:42
1276	A - Turtle Puzzle: Rearrange and Negate	C++20 (GCC 11-64)	`greedy` `math` `sortings` `*800`	Feb/27/2024 20:36
1275	A - Moving Chips	C++20 (GCC 11-64)	`greedy` `implementation` `*800`	Feb/23/2024 20:47
1274	A - Vlad and the Best of Five	C++20 (GCC 11-64)	`implementation` `*800`	Feb/23/2024 03:42
1273	D - Distinct Characters Queries	C++20 (GCC 11-64)	`data structures` `*1600`	Feb/23/2024 03:38
1272	A - Alena's Schedule	C++20 (GCC 11-64)	`implementation` `*900`	Feb/22/2024 22:19
1271	D - Mathematical Problem	C++20 (GCC 11-64)	`brute force` `constructive algorithms` `geometry` `math` `*1700`	Feb/22/2024 18:29
1270	E - Vlad and an Odd Ordering	C++20 (GCC 11-64)	`binary search` `bitmasks` `data structures` `dp` `implementation` `math` `number theory` `*1500`	Feb/22/2024 03:49
1269	C - Boats Competition	C++20 (GCC 11-64)	`brute force` `greedy` `two pointers` `*1200`	Feb/21/2024 23:53
1268	C - Good Subarrays	C++20 (GCC 11-64)	`data structures` `dp` `math` `*1600`	Feb/21/2024 02:43
1267	A - Number of Apartments	C++20 (GCC 11-64)	`brute force` `constructive algorithms` `math` `*900`	Feb/21/2024 00:18
1266	D - Vlad and Division	C++20 (GCC 11-64)	`bitmasks` `greedy` `*1300`	Feb/19/2024 22:48
1265	C - Vlad and a Sum of Sum of Digits	C++20 (GCC 11-64)	`dp` `implementation` `*1200`	Feb/19/2024 21:32
1264	B - Vlad and Shapes	C++20 (GCC 11-64)	`geometry` `implementation` `*800`	Feb/19/2024 21:13
1263	D - Card Game	C++20 (GCC 11-64)	`greedy` `implementation` `*1400`	Feb/18/2024 20:41
1262	C - LR-remainders	C++20 (GCC 11-64)	`brute force` `data structures` `implementation` `math` `two pointers` `*1400`	Feb/18/2024 19:35
1261	B - Chaya Calendar	C++20 (GCC 11-64)	`number theory` `*1100`	Feb/18/2024 18:38
1260	A - Thorns and Coins	C++20 (GCC 11-64)	`dp` `greedy` `implementation` `*800`	Feb/18/2024 18:11
1259	C - Largest Subsequence	C++20 (GCC 11-64)	`greedy` `strings` `*1400`	Feb/18/2024 17:34
1258	C - King's Path	C++20 (GCC 11-64)	`dfs and similar` `graphs` `hashing` `shortest paths` `*1800`	Feb/18/2024 03:27
1257	B - Permutation Printing	C++20 (GCC 11-64)	`brute force` `constructive algorithms` `math` `*1000`	Feb/17/2024 21:12
1256	A - Maximise The Score	C++20 (GCC 11-64)	`greedy` `sortings` `*800`	Feb/17/2024 20:37
1255	C - Sasha and the Casino	GNU C++20 (64)	`brute force` `constructive algorithms` `games` `greedy` `math` `*1400`	Feb/16/2024 23:59
1254	C - Dijkstra?	GNU C++20 (64)	`graphs` `shortest paths` `*1900`	Feb/16/2024 15:21
1253	B - Sasha and the Drawing	GNU C++20 (64)	`constructive algorithms` `greedy` `math` `*800`	Feb/15/2024 21:12
1252	A - Sasha and the Beautiful Array	GNU C++20 (64)	`constructive algorithms` `greedy` `sortings` `*800`	Feb/15/2024 20:36
1251	D - Divisible Pairs	GNU C++20 (64)	`combinatorics` `math` `number theory` `*1300`	Feb/15/2024 18:17
1250	E - Klever Permutation	GNU C++20 (64)	`constructive algorithms` `math` `two pointers` `*1400`	Feb/15/2024 17:14
1249	A - Noldbach problem	GNU C++20 (64)	`brute force` `math` `number theory` `*1000`	Feb/15/2024 02:56
1248	F - Chat Screenshots	GNU C++20 (64)	`combinatorics` `dfs and similar` `graphs` `implementation` `*1700`	Feb/15/2024 01:20
1247	E - Anna and the Valentine's Day Gift	GNU C++20 (64)	`games` `greedy` `math` `sortings` `*1400`	Feb/14/2024 01:03
1246	C - Make Equal Again	GNU C++20 (64)	`brute force` `greedy` `math` `*1000`	Feb/13/2024 21:07
1245	B - Make Equal	GNU C++20 (64)	`greedy` `*800`	Feb/13/2024 20:46
1244	A - Recovering a Small String	GNU C++20 (64)	`brute force` `strings` `*800`	Feb/13/2024 20:41
1243	C - Game on Permutation	GNU C++20 (64)	`data structures` `dp` `games` `greedy` `*1400`	Feb/12/2024 18:48
1242	A - Rectangle Cutting	GNU C++20 (64)	`geometry` `math` `*800`	Feb/11/2024 21:50
1241	B - Equalize	GNU C++20 (64)	`binary search` `greedy` `sortings` `two pointers` `*1200`	Feb/11/2024 21:41
1240	A - Prime Permutation	GNU C++20 (64)	`implementation` `number theory` `strings` `*1300`	Feb/11/2024 18:17
1239	B - Subtract Operation	GNU C++20 (64)	`data structures` `greedy` `math` `two pointers` `*1100`	Feb/10/2024 23:54
1238	C - Most Similar Words	GNU C++20 (64)	`brute force` `greedy` `implementation` `implementation` `math` `strings` `*800`	Feb/09/2024 16:27
1237	F - Longest Strike	GNU C++20 (64)	`data structures` `greedy` `implementation` `sortings` `two pointers` `*1300`	Feb/09/2024 16:23
1236	B - Equal Candies	GNU C++20 (64)	`greedy` `math` `sortings` `*800`	Feb/08/2024 23:57
1235	D - Find the Different Ones!	GNU C++20 (64)	`binary search` `brute force` `data structures` `dp` `dsu` `greedy` `two pointers`	Feb/07/2024 12:01
1234	C - Choose the Different Ones!	GNU C++20 (64)	`brute force` `greedy` `math`	Feb/06/2024 21:25
1233	B - Following the String	GNU C++20 (64)	`constructive algorithms` `greedy` `strings`	Feb/06/2024 21:09
1232	A - Make it White	GNU C++20 (64)	`greedy` `strings`	Feb/06/2024 20:51
1231	C - Theofanis' Nightmare	GNU C++20 (64)	`constructive algorithms` `greedy` `*1400`	Feb/05/2024 23:37
1230	C - Helping the Nature	GNU C++20 (64)	`constructive algorithms` `data structures` `greedy` `*1700`	Feb/04/2024 20:14
1229	C - Lucky Conversion	GNU C++20 (64)	`greedy` `*1200`	Feb/04/2024 02:01
1228	C - Place for a Selfie	GNU C++20 (64)	`binary search` `data structures` `geometry` `math` `*1400`	Feb/03/2024 23:03
1227	C - Constructive Problem	GNU C++20 (64)	`constructive algorithms` `greedy` `*1300`	Feb/02/2024 15:16
1226	C - XOR-distance	GNU C++20 (64)	`bitmasks` `greedy` `implementation` `math` `*1400`	Feb/01/2024 01:51
1225	A - From Hero to Zero	GNU C++20 (64)	`implementation` `math` `*900`	Jan/31/2024 23:55
1224	B - Minimize Inversions	GNU C++20 (64)	`constructive algorithms` `data structures` `greedy` `implementation` `sortings` `*900`	Jan/30/2024 21:01
1223	A - Brick Wall	GNU C++20 (64)	`constructive algorithms` `greedy` `implementation` `math` `*800`	Jan/30/2024 20:42
1222	B - Hamon Odyssey	GNU C++20 (64)	`bitmasks` `greedy` `two pointers` `*1000`	Jan/30/2024 20:26
1221	C - Smilo and Monsters	GNU C++20 (64)	`binary search` `constructive algorithms` `greedy` `sortings` `two pointers` `*1500`	Jan/30/2024 01:15
1220	B - Monsters	GNU C++20 (64)	`greedy` `math` `sortings` `*1000`	Jan/28/2024 15:44
1219	C - Did We Get Everything Covered?	GNU C++20 (64)	`constructive algorithms` `dp` `greedy` `implementation` `strings` `*1500`	Jan/28/2024 14:57
1218	B - A Balanced Problemset?	GNU C++20 (64)	`brute force` `greedy` `math` `number theory` `*1200`	Jan/28/2024 13:36
1217	A - We Got Everything Covered!	GNU C++20 (64)	`constructive algorithms` `greedy` `strings` `*800`	Jan/27/2024 21:02
1216	A - Letters Cyclic Shift	GNU C++20 (64)	`constructive algorithms` `greedy` `implementation` `strings` `*1200`	Jan/22/2024 23:31
1215	C - Closest Cities	GNU C++20 (64)	`greedy` `*1300`	Jan/21/2024 02:17
1214	B - Forming Triangles	GNU C++20 (64)	`combinatorics` `constructive algorithms` `math` `*1200`	Jan/20/2024 01:55
1213	A - Tricky Template	GNU C++20 (64)	`constructive algorithms` `implementation` `strings` `*800`	Jan/19/2024 02:50
1212	C - Partitioning the Array	GNU C++20 (64)	`brute force` `math` `number theory` `*1500`	Jan/17/2024 00:25
1211	D - Very Different Array	GNU C++20 (64)	`data structures` `greedy` `sortings` `two pointers` `*1100`	Jan/16/2024 19:56
1210	C - Sending Messages	GNU C++20 (64)	`greedy` `math` `*900`	Jan/15/2024 21:51
1209	B - Arranging Cats	GNU C++20 (64)	`greedy` `implementation` `*800`	Jan/15/2024 21:28
1208	A - Square	GNU C++20 (64)	`greedy` `math` `*800`	Jan/15/2024 20:39
1207	B - Bus of Characters	GNU C++20 (64)	`data structures` `greedy` `implementation` `*1300`	Jan/15/2024 00:21
1206	B - PolandBall and Game	GNU C++20 (64)	`binary search` `data structures` `games` `greedy` `sortings` `strings` `*1100`	Jan/15/2024 00:16
1205	B - ICPC Balloons	GNU C++20 (64)	`data structures` `implementation` `*800`	Jan/14/2024 23:42
1204	A1 - Prefix Flip (Easy Version)	GNU C++20 (64)	`constructive algorithms` `data structures` `strings` `*1300`	Jan/13/2024 23:32
1203	B - Summation Game	GNU C++20 (64)	`games` `greedy` `math` `sortings` `*1100`	Jan/13/2024 22:06
1202	A - Satisfying Constraints	GNU C++20 (64)	`brute force` `greedy` `math` `*800`	Jan/13/2024 20:50
1201	B - Average Sleep Time	GNU C++20 (64)	`data structures` `implementation` `math` `*1300`	Jan/12/2024 17:59
1200	B - Multithreading	GNU C++20 (64)	`data structures` `greedy` `implementation` `*1400`	Jan/12/2024 17:38
1199	C1 - Good Subarrays (Easy Version)	GNU C++20 (64)	`binary search` `data structures` `schedules` `two pointers` `*1300`	Jan/12/2024 16:26
1198	C - Inversion Graph	GNU C++20 (64)	`data structures` `dsu` `graphs` `math` `*1300`	Jan/12/2024 02:28
1197	A - String Building	GNU C++20 (64)		Jan/10/2024 22:28
1196	C - Odd/Even Increments	GNU C++20 (64)	`greedy` `greedy` `implementation` `math` `*800`	Jan/10/2024 22:16
1195	D - Colorful Stamp	GNU C++20 (64)	`implementation` `*1100`	Jan/10/2024 22:12
1194	B - Two Divisors	GNU C++20 (64)	`constructive algorithms` `math` `number theory` `*900`	Jan/09/2024 23:56
1193	B - Build a Contest	GNU C++20 (64)	`data structures` `implementation` `*1300`	Jan/09/2024 00:45
1192	C - Array Game	GNU C++20 (64)	`binary search` `brute force` `data structures` `sortings` `two pointers` `*1400`	Jan/08/2024 23:32
1191	A - Sonya and Queries	GNU C++20 (64)	`data structures` `implementation` `*1400`	Jan/08/2024 21:35
1190	C - Digital Logarithm	GNU C++20 (64)	`data structures` `greedy` `sortings` `*1400`	Jan/07/2024 19:49
1189	C - Grouping Increases	GNU C++20 (64)	`data structures` `dp` `greedy` `*1400`	Jan/06/2024 22:21
1188	B - Plus-Minus Split	GNU C++20 (64)	`greedy` `*800`	Jan/06/2024 20:47
1187	A - Wallet Exchange	GNU C++20 (64)	`games` `math` `*800`	Jan/06/2024 20:38
1186	A - Array with Odd Sum	GNU C++20 (64)	`math` `*800`	Jan/06/2024 17:58
1185	B - Non-Coprime Partition	GNU C++20 (64)	`constructive algorithms` `math` `*1100`	Jan/06/2024 16:24
1184	B - Cosmic Tables	GNU C++20 (64)	`data structures` `implementation` `*1300`	Jan/05/2024 20:04
1183	G - 2^Sort	GNU C++20 (64)	`data structures` `dp` `sortings` `two pointers` `*1400`	Jan/04/2024 19:13
1182	B - After Training	GNU C++20 (64)	`data structures` `implementation` `math` `*1300`	Jan/03/2024 20:43
1181	B - Lecture Sleep	GNU C++20 (64)	`data structures` `dp` `implementation` `two pointers` `*1200`	Jan/02/2024 18:41
1180	A - Reorder the Array	GNU C++20 (64)	`combinatorics` `data structures` `math` `sortings` `two pointers` `*1300`	Jan/02/2024 18:10
1179	G - Years	GNU C++20 (64)	`data structures` `sortings` `*1300`	Jan/01/2024 19:56
1178	A - 2023	GNU C++20 (64)	`constructive algorithms` `implementation` `math` `number theory` `*800`	Dec/31/2023 18:50
1177	E - Romantic Glasses	GNU C++20 (64)	`data structures` `greedy` `math` `*1300`	Dec/30/2023 01:42
1176	F - Greetings	GNU C++20 (64)	`data structures` `divide and conquer` `sortings` `*1500`	Dec/29/2023 22:17
1175	B - Erase First or Second Letter	GNU C++20 (64)	`brute force` `combinatorics` `data structures` `dp` `strings` `*1100`	Dec/29/2023 15:31
1174	B - Not Quite Latin Square	GNU C++20 (64)	`bitmasks` `brute force` `implementation` `*800`	Dec/29/2023 01:09
1173	A - Odd One Out	GNU C++20 (64)	`bitmasks` `implementation` `*800`	Dec/29/2023 01:04
1172	D - Unnatural Language Processing	GNU C++20 (64)	`greedy` `implementation` `strings` `*900`	Dec/28/2023 20:58
1171	C - Can I Square?	GNU C++20 (64)	`binary search` `implementation` `*800`	Dec/28/2023 20:49
1170	C - Numbers on Whiteboard	GNU C++20 (64)	`constructive algorithms` `data structures` `greedy` `implementation` `math` `*1000`	Dec/28/2023 19:01
1169	A - Meximization	GNU C++20 (64)	`brute force` `data structures` `greedy` `sortings` `*800`	Dec/28/2023 17:57
1168	B - Order Book	GNU C++20 (64)	`data structures` `greedy` `implementation` `sortings` `*1300`	Dec/28/2023 00:12
1167	C - Stripe	GNU C++20 (64)	`data structures` `implementation` `*1200`	Dec/26/2023 19:18
1166	C - Bad Sequence	GNU C++20 (64)	`data structures` `greedy` `*1200`	Dec/26/2023 18:58
1165	B - Game with string	GNU C++20 (64)	`data structures` `implementation` `math` `*1200`	Dec/26/2023 18:35
1164	B - Chat Order	GNU C++20 (64)	`special problem` `binary search` `constructive algorithms` `data structures` `sortings` `1200`	Dec/26/2023 18:25
1163	A - Least Product	GNU C++20 (64)	`constructive algorithms` `math` `*800`	Dec/25/2023 02:38
1162	B - Shooting	GNU C++20 (64)	`greedy` `implementation` `sortings` `*900`	Dec/25/2023 02:30
1161	A - Three Indices	GNU C++20 (64)	`brute force` `data structures` `*900`	Dec/25/2023 02:20
1160	A - Subset Mex	GNU C++20 (64)	`greedy` `implementation` `math` `*900`	Dec/25/2023 02:16
1159	A - Exciting Bets	GNU C++20 (64)	`greedy` `math` `number theory` `*900`	Dec/25/2023 02:01
1158	A - Chips Moving	GNU C++20 (64)	`math` `*900`	Dec/25/2023 01:47
1157	A - Hexadecimal's theorem	GNU C++20 (64)	`brute force` `constructive algorithms` `implementation` `number theory` `*900`	Dec/25/2023 01:42
1156	A - Filling Diamonds	GNU C++20 (64)	`brute force` `dp` `implementation` `math` `*900`	Dec/25/2023 01:29
1155	A - Nastya and Rice	GNU C++20 (64)	`math` `*900`	Dec/25/2023 01:17
1154	C - Heavy Intervals	GNU C++20 (64)	`constructive algorithms` `data structures` `dsu` `greedy` `math` `sortings` `*1400`	Dec/25/2023 01:00
1153	C - Make Equal With Mod	GNU C++20 (64)	`constructive algorithms` `math` `number theory` `sortings` `*1200`	Dec/24/2023 23:44
1152	B - Make Almost Equal With Mod	GNU C++20 (64)	`bitmasks` `constructive algorithms` `math` `number theory` `*1200`	Dec/24/2023 20:04
1151	A - Distinct Buttons	GNU C++20 (64)	`implementation` `math` `*800`	Dec/23/2023 20:46
1150	A - Visiting a Friend	GNU C++20 (64)	`greedy` `implementation` `*1100`	Dec/22/2023 21:21
1149	B - Coloring a Tree	GNU C++20 (64)	`dfs and similar` `dsu` `greedy` `*1200`	Dec/21/2023 18:02
1148	A - Problemsolving Log	GNU C++20 (64)	`implementation` `strings` `*800`	Dec/21/2023 14:28
1147	B - Preparing for the Contest	GNU C++20 (64)	`constructive algorithms` `math` `*800`	Dec/21/2023 13:58
1146	C - Quests	GNU C++20 (64)	`greedy` `math` `*1100`	Dec/21/2023 13:41
1145	D - Three Activities	GNU C++20 (64)	`brute force` `dp` `greedy` `implementation` `sortings` `*1200`	Dec/20/2023 23:11
1144	B - Distances to Zero	GNU C++20 (64)	`constructive algorithms` `*1200`	Dec/20/2023 20:36
1143	C - Game with Multiset	GNU C++20 (64)	`binary search` `bitmasks` `brute force` `greedy` `*1300`	Dec/19/2023 21:20
1142	B - Swap and Delete	GNU C++20 (64)	`strings` `*1000`	Dec/18/2023 20:59
1141	A - Rating Increase	GNU C++20 (64)	`implementation` `*800`	Dec/18/2023 20:45
1140	C - Maximum Set	GNU C++20 (64)	`binary search` `math` `*1600`	Dec/18/2023 15:46
1139	B - Begginer's Zelda	GNU C++20 (64)	`greedy` `trees` `*1100`	Dec/17/2023 13:30
1138	A - Maze	GNU C++20 (64)	`dfs and similar` `*1600`	Dec/17/2023 00:04
1137	A - Constructive Problems	GNU C++20 (64)	`constructive algorithms` `math` `*800`	Dec/16/2023 20:43
1136	B - Party	GNU C++20 (64)	`constructive algorithms` `graphs` `math` `*1600`	Dec/15/2023 21:13
1135	A - Ice Skating	GNU C++20 (64)	`brute force` `dfs and similar` `dsu` `graphs` `*1200`	Dec/15/2023 20:22
1134	A - Forked!	GNU C++20 (64)	`brute force` `implementation` `*900`	Dec/15/2023 15:14
1133	A - Fox and Box Accumulation	GNU C++20 (64)	`greedy` `sortings` `*1400`	Dec/14/2023 23:22
1132	B - Collecting Game	GNU C++20 (64)	`binary search` `dp` `greedy` `sortings` `two pointers` `*1100`	Dec/13/2023 21:28
1131	A - Binary Imbalance	GNU C++20 (64)	`constructive algorithms` `*800`	Dec/12/2023 22:58
1130	D - Jumping Through Segments	GNU C++20 (64)	`binary search` `constructive algorithms` `*1400`	Dec/11/2023 20:47
1129	C - Removal of Unattractive Pairs	GNU C++20 (64)	`constructive algorithms` `greedy` `math` `strings` `*1100`	Dec/10/2023 23:54
1128	B - YetnotherrokenKeoard	GNU C++20 (64)	`data structures` `implementation` `strings` `*1000`	Dec/09/2023 22:50
1127	A - Rook	GNU C++20 (64)	`implementation` `*800`	Dec/09/2023 22:24
1126	A - Easy As ABC	GNU C++20 (64)	`brute force` `*1000`	Dec/09/2023 21:27
1125	A - New Year Transportation	GNU C++20 (64)	`dfs and similar` `graphs` `implementation` `*1000`	Nov/28/2023 20:03
1124	B - DZY Loves Chemistry	GNU C++20 (64)	`dfs and similar` `dsu` `greedy` `*1400`	Nov/27/2023 19:06
1123	B - Laura and Operations	GNU C++20 (64)	`dp` `math` `*900`	Nov/26/2023 23:19
1122	A - Cover in Water	GNU C++20 (64)	`constructive algorithms` `greedy` `implementation` `strings` `*800`	Nov/26/2023 20:43
1121	C - Add, Divide and Floor	GNU C++20 (64)	`constructive algorithms` `greedy` `math` `*1400`	Nov/26/2023 19:19
1120	B - AB Flipping	GNU C++20 (64)	`greedy` `strings` `two pointers` `*900`	Nov/25/2023 21:28
1119	A - Jagged Swaps	GNU C++20 (64)	`sortings` `*800`	Nov/25/2023 20:54
1118	B - Chip and Ribbon	GNU C++20 (64)	`greedy` `math` `*1100`	Nov/24/2023 21:19
1117	A - Line Trip	GNU C++20 (64)	`greedy` `math` `*800`	Nov/24/2023 20:44
1116	C - Diluc and Kaeya	GNU C++20 (64)	`data structures` `dp` `hashing` `number theory` `*1500`	Nov/23/2023 18:47
1115	B - Symmetric Matrix	GNU C++20 (64)	`implementation` `*900`	Nov/22/2023 17:52
1114	B - Milena and Admirer	GNU C++20 (64)	`greedy` `math` `*1500`	Nov/21/2023 19:59
1113	C - Swap Adjacent Elements	GNU C++20 (64)	`dfs and similar` `greedy` `math` `sortings` `two pointers` `*1400`	Nov/21/2023 18:40
1112	A - Bits	GNU C++20 (64)	`bitmasks` `constructive algorithms` `*1700`	Nov/20/2023 23:55
1111	F - Alex's whims	GNU C++20 (64)	`constructive algorithms` `graphs` `greedy` `shortest paths` `trees` `*1600`	Nov/20/2023 22:29
1110	A - Milica and String	GNU C++20 (64)	`brute force` `implementation` `strings` `*800`	Nov/19/2023 21:02
1109	E - Queue Sort	GNU C++20 (64)	`greedy` `implementation` `sortings` `*1300`	Nov/19/2023 20:28
1108	D - Yarik and Musical Notes	GNU C++20 (64)	`hashing` `math` `number theory` `*1300`	Nov/18/2023 23:46
1107	C - Yarik and Array	GNU C++20 (64)	`dp` `greedy` `two pointers` `*1100`	Nov/18/2023 18:56
1106	B - 250 Thousand Tons of TNT	GNU C++20 (64)	`brute force` `implementation` `number theory` `*1100`	Nov/18/2023 18:12
1105	A - Game with Integers	GNU C++20 (64)	`games` `math` `number theory` `*800`	Nov/17/2023 20:39
1104	A - Case of the Zeros and Ones	GNU C++20 (64)	`greedy` `*900`	Nov/16/2023 23:31
1103	B - The Time	GNU C++20 (64)	`implementation` `*900`	Nov/15/2023 23:59
1102	A - Triangle	GNU C++20 (64)	`brute force` `geometry` `*1500`	Nov/15/2023 00:10
1101	E2 - Close Tuples (hard version)	GNU C++20 (64)	`binary search` `combinatorics` `implementation` `math` `sortings` `two pointers` `*1700`	Nov/14/2023 21:07
1100	E1 - Close Tuples (easy version)	GNU C++20 (64)	`binary search` `combinatorics` `math` `sortings` `two pointers` `*1500`	Nov/14/2023 18:30
1099	B - Coloring	GNU C++20 (64)	`constructive algorithms` `greedy` `math` `*1500`	Nov/13/2023 23:46
1098	C - Sum on Subarrays	GNU C++20 (64)	`constructive algorithms` `greedy` `math` `*1500`	Nov/13/2023 00:34
1097	E - Price Maximization	GNU C++20 (64)	`binary search` `greedy` `math` `two pointers` `*1500`	Nov/12/2023 19:11
1096	E - Data Structures Fan	GNU C++20 (64)	`binary search` `bitmasks` `data structures` `dp` `*1500`	Nov/11/2023 21:10
1095	E - Two Round Dances	GNU C++20 (64)	`combinatorics` `math` `*1300`	Nov/10/2023 17:59
1094	C - Min Max Sort	GNU C++20 (64)	`binary search` `brute force` `greedy` `math` `two pointers` `*1500`	Nov/09/2023 16:35
1093	C - Anonymous Informant	GNU C++20 (64)	`constructive algorithms` `graphs` `implementation` `*1400`	Nov/08/2023 21:07
1092	B - Two Out of Three	GNU C++20 (64)	`constructive algorithms` `*1000`	Nov/08/2023 14:05
1091	A - Secret Sport	GNU C++20 (64)	`implementation` `strings` `*800`	Nov/08/2023 13:30
1090	C - The Child and Toy	GNU C++20 (64)	`graphs` `greedy` `sortings` `*1400`	Nov/08/2023 01:52
1089	B - Mashmokh and ACM	GNU C++20 (64)	`combinatorics` `dp` `number theory` `*1400`	Nov/07/2023 19:37
1088	B - Raspberries	GNU C++20 (64)	`math` `number theory` `*1000`	Nov/07/2023 15:55
1087	A - Chemistry	GNU C++20 (64)	`strings` `*900`	Nov/07/2023 15:54
1086	B - Points and Minimum Distance	GNU C++20 (64)	`greedy` `math` `sortings` `*800`	Nov/06/2023 17:39
1085	A - Treasure Chest	GNU C++20 (64)	`math` `*800`	Nov/06/2023 17:15
1084	A - Shifting Stacks	GNU C++20 (64)	`greedy` `implementation` `*900`	Nov/05/2023 23:11
1083	B - Elimination	GNU C++20 (64)	`greedy` `math` `*900`	Nov/04/2023 17:58
1082	C - Yet Another Broken Keyboard	GNU C++20 (64)	`combinatorics` `dp` `implementation` `*1200`	Nov/03/2023 00:58
1081	D - Xenia and Bit Operations	GNU C++20 (64)	`data structures` `trees` `*1700`	Nov/02/2023 19:11
1080	A - Even But Not Even	GNU C++20 (64)	`greedy` `math` `strings` `*900`	Nov/01/2023 23:24
1079	A - Cookies	GNU C++20 (64)	`implementation` `*900`	Nov/01/2023 23:12
1078	A - Oath of the Night's Watch	GNU C++20 (64)	`constructive algorithms` `sortings` `*900`	Nov/01/2023 23:00
1077	B - Array Eversion	GNU C++20 (64)	`greedy` `*900`	Oct/31/2023 21:52
1076	B - Deja Vu	GNU C++20 (64)	`math` `sortings`	Oct/31/2023 13:36
1075	A - Dreamoon and Ranking Collection	GNU C++20 (64)	`implementation` `*900`	Oct/30/2023 23:56
1074	A - Sorting with Twos	GNU C++20 (64)	`constructive algorithms` `constructive algorithms` `constructive algorithms` `constructive algorithms` `constructive algorithms` `constructive algorithms` `sortings`	Oct/30/2023 20:59
1073	B - Qingshan Loves Strings	GNU C++20 (64)	`implementation`	Oct/29/2023 00:09
1072	A - Doremy's Paint 3	GNU C++20 (64)	`constructive algorithms`	Oct/28/2023 23:59
1071	B - Codeforces Subsequences	GNU C++20 (64)	`brute force` `constructive algorithms` `greedy` `math` `strings` `*1500`	Oct/28/2023 23:13
1070	C - Poisoned Dagger	GNU C++20 (64)	`binary search` `*1200`	Oct/27/2023 21:41
1069	F - Quests	GNU C++20 (64)	`binary search` `greedy` `sortings` `*1500`	Oct/26/2023 23:05
1068	B - Facetook Priority Wall	GNU C++20 (64)	`expression parsing` `implementation` `strings` `*1500`	Oct/26/2023 22:31
1067	C - World Tour Finals	C++ 20 (gcc 12.2)	`AtCoder` `*250`	Oct/26/2023 00:10
1066	E - Look Back	GNU C++20 (64)	`bitmasks` `greedy`	Oct/25/2023 00:41
1065	A - Simply Strange Sort	GNU C++20 (64)	`brute force` `implementation` `sortings` `*800`	Oct/24/2023 23:07
1064	B - Sum of Digits	GNU C++20 (64)	`implementation` `*1000`	Oct/23/2023 22:19
1063	D - In Love	GNU C++20 (64)	`data structures` `greedy`	Oct/22/2023 23:59
1062	B - Haunted House	GNU C++20 (64)	`binary search` `greedy` `math` `two pointers`	Oct/22/2023 23:15
1061	C - Raspberries	GNU C++20 (64)	`dp` `math`	Oct/22/2023 18:37
1060	B - Chemistry	GNU C++20 (64)	`strings`	Oct/22/2023 17:23
1059	A - Morning	GNU C++20 (64)	`math`	Oct/22/2023 17:16
1058	A - Simple Design	GNU C++20 (64)	`brute force` `greedy` `math`	Oct/22/2023 13:09
1057	B - Olya and Game with Arrays	GNU C++20 (64)	`constructive algorithms` `greedy` `math` `sortings` `*1000`	Oct/21/2023 22:37
1056	C - Yet Another Permutation Problem	GNU C++20 (64)	`constructive algorithms` `greedy` `math` `number theory` `*1000`	Oct/21/2023 22:17
1055	A - Lights Out	GNU C++20 (64)	`implementation` `*900`	Oct/20/2023 19:24
1054	A - PizzaForces	GNU C++20 (64)	`brute force` `math` `*900`	Oct/20/2023 19:04
1053	A - Mocha and Math	GNU C++20 (64)	`bitmasks` `constructive algorithms` `math` `*900`	Oct/20/2023 18:03
1052	A - Slightly Decreasing Permutations	GNU C++20 (64)	`greedy` `implementation` `*1100`	Oct/19/2023 13:27
1051	B - Valued Keys	GNU C++20 (64)	`constructive algorithms` `greedy` `strings` `*900`	Oct/18/2023 22:19
1050	C - Really Big Numbers	GNU C++20 (64)	`binary search` `brute force` `dp` `math` `*1600`	Oct/17/2023 20:35
1049	B - Makes And The Product	GNU C++20 (64)	`combinatorics` `implementation` `math` `sortings` `*1500`	Oct/17/2023 19:38
1048	C - Ntarsis' Set	GNU C++20 (64)	`binary search` `constructive algorithms` `implementation` `math` `*1800`	Oct/16/2023 23:43
1047	B - Mislove Has Lost an Array	GNU C++20 (64)	`greedy` `math` `*900`	Oct/15/2023 21:24
1046	E - Boxers	GNU C++20 (64)	`greedy` `sortings` `*1500`	Oct/14/2023 19:56
1045	E - Block Sequence	GNU C++20 (64)	`dp`	Oct/13/2023 21:48
1044	C - Perfect Square	GNU C++20 (64)	`brute force` `implementation`	Oct/13/2023 04:23
1043	A - Don't Try to Count	GNU C++20 (64)	`brute force` `strings`	Oct/12/2023 23:56
1042	D - Divide and Equalize	GNU C++20 (64)	`math` `number theory`	Oct/12/2023 21:55
1041	B - Three Threadlets	GNU C++20 (64)	`math`	Oct/12/2023 21:17
1040	C - Common Divisors	GNU C++20 (64)	`implementation` `math` `*1300`	Oct/12/2023 03:00
1039	D2 - Remove the Substring (hard version)	GNU C++20 (64)	`binary search` `greedy` `implementation` `two pointers` `*1700`	Oct/11/2023 22:44
1038	D1 - Remove the Substring (easy version)	GNU C++20 (64)	`greedy` `implementation` `*1600`	Oct/11/2023 18:36
1037	C - Decreasing String	GNU C++20 (64)	`implementation` `strings`	Oct/10/2023 17:27
1036	A - Sum of Three	GNU C++20 (64)	`brute force` `constructive algorithms` `math`	Oct/09/2023 20:43
1035	A - Goals of Victory	GNU C++20 (64)	`math`	Oct/09/2023 20:25
1034	D - Min Cost String	GNU C++20 (64)	`brute force` `constructive algorithms` `graphs` `greedy` `strings` `*1600`	Oct/08/2023 17:44
1033	B - Burning Midnight Oil	GNU C++20 (64)	`binary search` `implementation` `*1500`	Oct/07/2023 01:44
1032	C - Playlist	GNU C++20 (64)	`brute force` `data structures` `sortings` `*1600`	Oct/06/2023 19:48
1031	B - Archer	GNU C++20 (64)	`math` `probabilities` `*1300`	Oct/05/2023 01:27
1030	B - Good String	GNU C++20 (64)	`implementation` `strings` `*1200`	Oct/05/2023 00:21
1029	A - Detective Book	GNU C++20 (64)	`implementation` `*1000`	Oct/04/2023 23:44
1028	A - Short Sort	GNU C++20 (64)	`brute force` `implementation` `*800`	Oct/04/2023 19:42
1027	B - Good Kid	GNU C++20 (64)	`brute force` `greedy` `math` `*800`	Oct/04/2023 19:42
1026	C - Target Practice	GNU C++20 (64)	`implementation` `math` `*800`	Oct/04/2023 19:42
1025	D - 1D Eraser	GNU C++20 (64)	`greedy` `implementation` `two pointers` `*800`	Oct/04/2023 19:42
1024	E - Building an Aquarium	GNU C++20 (64)	`binary search` `sortings` `*1100`	Oct/04/2023 19:42
1023	F - Money Trees	GNU C++20 (64)	`binary search` `greedy` `math` `two pointers` `*1300`	Oct/04/2023 19:42
1022	A - 2-3 Moves	GNU C++20 (64)	`greedy` `math` `*800`	Oct/03/2023 13:49
1021	F1 - Guess the K-th Zero (Easy version)	GNU C++20 (64)	`binary search` `interactive` `*1600`	Oct/02/2023 16:57
1020	C - Good String	GNU C++20 (64)	`greedy` `*1300`	Oct/02/2023 16:39
1019	D - Almost All Divisors	GNU C++20 (64)	`math` `number theory` `*1600`	Oct/02/2023 15:39
1018	C - 321-like Searcher	C++ 20 (gcc 12.2)	`AtCoder` `*300`	Oct/02/2023 15:16
1017	C - Pursuit	GNU C++20 (64)	`binary search` `brute force` `greedy` `sortings` `*1200`	Oct/02/2023 00:04
1016	B - Nirvana	GNU C++20 (64)	`brute force` `math` `number theory` `*1200`	Oct/01/2023 17:05
1015	A - k-Factorization	GNU C++20 (64)	`implementation` `math` `number theory` `*1100`	Oct/01/2023 14:24
1014	A - Jellyfish and Undertale	GNU C++20 (64)	`brute force` `greedy`	Oct/01/2023 03:43
1013	C - Strong Password	GNU C++20 (64)	`binary search` `dp` `greedy` `strings` `*1400`	Oct/01/2023 03:37
1012	B - Special Permutation	GNU C++20 (64)	`constructive algorithms` `greedy` `*900`	Oct/01/2023 00:45
1011	C - Festival	C++ 20 (gcc 12.2)	`AtCoder` `*250`	Sep/30/2023 18:26
1010	B - Prefix and Suffix	C++ 20 (gcc 12.2)	`AtCoder` `*200`	Sep/30/2023 18:10
1009	A - First ABC 2	C++ 20 (gcc 12.2)	`AtCoder` `*100`	Sep/30/2023 18:03
1008	D - Permutations	GNU C++20 (64)	`greedy` `*1500`	Sep/30/2023 17:39
1007	A - Rigged!	GNU C++20 (64)	`greedy` `*800`	Sep/28/2023 19:52
1006	B - Chips on the Board	GNU C++20 (64)	`constructive algorithms` `greedy` `*900`	Sep/28/2023 19:51
1005	A - Increasing Sequence	GNU C++20 (64)	`greedy`	Sep/28/2023 19:48
1004	C - Vasilije in Cacak	GNU C++20 (64)	`math`	Sep/27/2023 23:13
1003	B - Aleksa and Stack	GNU C++20 (64)	`constructive algorithms` `math`	Sep/27/2023 15:27
1002	A - How Much Does Daytona Cost?	GNU C++20 (64)	`greedy`	Sep/27/2023 15:26
1001	A - Split it!	GNU C++20 (64)	`brute force` `constructive algorithms` `greedy` `strings` `*900`	Sep/26/2023 15:37
1000	B - Minimize Permutation Subarrays	GNU C++20 (64)	`constructive algorithms` `math` `*1100`	Sep/26/2023 14:34
999	C - Card Game	GNU C++20 (64)	`brute force` `greedy`	Sep/26/2023 01:13
998	B - Sets and Union	GNU C++20 (64)	`bitmasks` `brute force` `constructive algorithms` `greedy`	Sep/25/2023 23:53
997	C - Make it Alternating	GNU C++20 (64)	`combinatorics` `dp` `greedy` `*1300`	Sep/25/2023 00:05
996	B - Serial Time!	GNU C++20 (64)	`dfs and similar` `dsu` `*1400`	Sep/24/2023 20:16
995	A - Shortest path of the king	GNU C++20 (64)	`greedy` `shortest paths` `*1000`	Sep/24/2023 14:28
994	B - Biridian Forest	GNU C++20 (64)	`dfs and similar` `shortest paths` `*1500`	Sep/23/2023 21:03
993	G - ABBC or BACB	GNU C++20 (64)	`constructive algorithms` `greedy` `*1500`	Sep/22/2023 16:52
992	B - Friendly Arrays	GNU C++20 (64)	`bitmasks` `greedy` `math` `*1200`	Sep/21/2023 20:33
991	A - Whose sentence is it?	GNU C++20 (64)	`implementation` `strings` `*1100`	Sep/20/2023 23:18
990	A - MEXanized Array	GNU C++20 (64)	`constructive algorithms` `greedy` `math` `*800`	Sep/19/2023 21:28
989	A - United We Stand	GNU C++20 (64)	`constructive algorithms` `math` `number theory` `*800`	Sep/18/2023 20:41
988	C - Sweets Eating	GNU C++20 (64)	`dp` `greedy` `math` `sortings` `*1500`	Sep/17/2023 17:25
987	B - Kana and Dragon Quest game	GNU C++20 (64)	`greedy` `implementation` `math` `*900`	Sep/16/2023 23:51
986	A - And Then There Were K	GNU C++20 (64)	`bitmasks` `*800`	Sep/15/2023 22:34
985	A - Fill in the Matrix	GNU C++20 (64)	`constructive algorithms` `implementation` `*1300`	Sep/14/2023 20:25
984	C - Non-coprime Split	GNU C++20 (64)	`math` `number theory` `*1100`	Sep/13/2023 19:08
983	B - Odd sum	GNU C++20 (64)	`dp` `greedy` `implementation` `*1400`	Sep/13/2023 01:47
982	E2 - Salyg1n and Array (hard version)	GNU C++20 (64)	`constructive algorithms` `interactive` `*2200`	Sep/12/2023 22:53
981	E1 - Salyg1n and Array (simple version)	GNU C++20 (64)	`constructive algorithms` `interactive` `math` `*2000`	Sep/12/2023 22:52
980	B - XOR Palindromes	GNU C++20 (64)	`bitmasks` `constructive algorithms` `strings` `*1100`	Sep/12/2023 19:54
979	A - green_gold_dog, array and permutation	GNU C++20 (64)	`constructive algorithms` `sortings` `*800`	Sep/12/2023 19:54
978	C - Salyg1n and the MEX Game	GNU C++20 (64)	`constructive algorithms` `data structures` `games` `greedy` `interactive` `*1300`	Sep/12/2023 00:24
977	A - Cloning Toys	GNU C++20 (64)	`implementation` `*1300`	Sep/11/2023 00:24
976	A - Two Vessels	GNU C++20 (64)	`brute force` `greedy` `math` `*800`	Sep/10/2023 23:57
975	A - Make It Zero	GNU C++20 (64)	`constructive algorithms` `*900`	Sep/10/2023 23:15
974	B - Magic Forest	GNU C++20 (64)	`brute force` `*1300`	Sep/09/2023 00:40
973	C - K-Dominant Character	GNU C++20 (64)	`binary search` `implementation` `two pointers` `*1400`	Sep/08/2023 23:06
972	C - String Transformation	GNU C++20 (64)	`greedy` `strings` `*1300`	Sep/08/2023 20:21
971	A - Partition	GNU C++20 (64)	`greedy` `*800`	Sep/07/2023 20:05
970	B - Weird Subtraction Process	GNU C++20 (64)	`math` `number theory` `*1100`	Sep/07/2023 19:55
969	C - Representative Edges	GNU C++20 (64)	`brute force` `geometry` `implementation` `math` `*1500`	Sep/06/2023 14:33
968	A - Integer Diversity	GNU C++20 (64)	`implementation` `*800`	Sep/05/2023 23:41
967	C - Swap Letters	GNU C++20 (64)	`constructive algorithms` `greedy` `*1500`	Sep/04/2023 21:06
966	B - Ternary String	GNU C++20 (64)	`binary search` `dp` `implementation` `two pointers` `*1200`	Sep/03/2023 21:11
965	A - Ambitious Kid	GNU C++20 (64)	`math` `*800`	Sep/03/2023 18:07
964	C - MEX Repetition	GNU C++20 (64)	`implementation` `math` `*1100`	Sep/02/2023 21:34
963	B - Two Binary Strings	GNU C++20 (64)	`constructive algorithms` `dp` `greedy` `*1000`	Sep/01/2023 14:25
962	A - Prime Deletion	GNU C++20 (64)	`constructive algorithms` `math` `*800`	Sep/01/2023 14:22
961	C - Different Differences	GNU C++20 (64)	`constructive algorithms` `greedy` `math` `*1000`	Sep/01/2023 14:16
960	B - Split Sort	GNU C++20 (64)	`greedy` `math` `sortings` `*1100`	Aug/31/2023 12:10
959	A - Channel	GNU C++20 (64)	`greedy` `implementation` `*800`	Aug/31/2023 12:07
958	C - Dreaming of Freedom	GNU C++20 (64)	`greedy` `math` `number theory` `*1300`	Aug/30/2023 19:40
957	A - Alarm Clock	GNU C++20 (64)	`math` `*900`	Aug/29/2023 23:49
956	C - Tea Tasting	GNU C++20 (64)	`binary search` `data structures` `implementation` `*1500`	Aug/29/2023 00:02
955	G - Orray	GNU C++20 (64)	`bitmasks` `brute force` `greedy` `math` `sortings` `*1500`	Aug/27/2023 03:10
954	A - Increasing and Decreasing	GNU C++20 (64)	`constructive algorithms` `greedy` `implementation` `math` `*800`	Aug/27/2023 01:46
953	B - Swap and Reverse	GNU C++20 (64)	`constructive algorithms` `greedy` `sortings` `strings` `*1100`	Aug/27/2023 01:46
952	C - Divisor Chain	GNU C++20 (64)	`bitmasks` `constructive algorithms` `math` `number theory` `*1300`	Aug/27/2023 01:46
951	A - Tales of a Sort	GNU C++20 (64)	`implementation` `*800`	Aug/26/2023 23:47
950	D - Ice Cream Balls	GNU C++20 (64)	`binary search` `combinatorics` `constructive algorithms` `math` `*1300`	Aug/25/2023 21:45
949	B - Good Arrays	GNU C++20 (64)	`implementation` `math` `*900`	Aug/25/2023 17:48
948	A - Gift Carpet	GNU C++20 (64)	`dp` `greedy` `implementation` `strings` `*800`	Aug/24/2023 22:52
947	B - Sequence Game	GNU C++20 (64)	`constructive algorithms` `*800`	Aug/24/2023 22:52
946	C - Flower City Fence	GNU C++20 (64)	`binary search` `data structures` `implementation` `sortings` `*1100`	Aug/24/2023 22:52
945	C - Good String	GNU C++20 (64)	`brute force` `dp` `greedy` `two pointers` `*1500`	Aug/23/2023 21:52
944	B - Easter Eggs	GNU C++20 (64)	`constructive algorithms` `implementation` `*1200`	Aug/22/2023 18:47
943	A - Haiku	GNU C++20 (64)	`implementation` `strings` `*800`	Aug/22/2023 17:28
942	C - Interesting Story	GNU C++20 (64)	`greedy` `sortings` `strings` `*1500`	Aug/21/2023 17:24
941	D - Backspace	GNU C++20 (64)	`dp` `greedy` `strings` `two pointers` `*1500`	Aug/19/2023 18:50
940	A - Yaroslav and Permutations	GNU C++20 (64)	`greedy` `math` `*1100`	Aug/19/2023 15:28
939	B - AGAGA XOOORRR	GNU C++20 (64)	`bitmasks` `brute force` `dp` `greedy` `*1500`	Aug/18/2023 21:26
938	A - Not a Substring	GNU C++20 (64)	`constructive algorithms` `strings` `*900`	Aug/17/2023 22:57
937	B - Fancy Coins	GNU C++20 (64)	`binary search` `brute force` `greedy` `math` `*1200`	Aug/17/2023 22:36
936	A - Buttons	GNU C++20 (64)	`games` `greedy` `math` `*800`	Aug/17/2023 20:17
935	C - Minimum Notation	GNU C++20 (64)	`data structures` `greedy` `math` `sortings` `*1200`	Aug/16/2023 01:13
934	G2 - Subsequence Addition (Hard Version)	GNU C++20 (64)	`bitmasks` `dp` `greedy` `implementation` `sortings` `*1100`	Aug/15/2023 22:31
933	D - Stas and the Queue at the Buffet	GNU C++20 (64)	`greedy` `math` `sortings` `*1600`	Aug/15/2023 01:33
932	B - Running for Gold	GNU C++20 (64)	`combinatorics` `graphs` `greedy` `sortings` `*1500`	Aug/14/2023 19:41
931	C - Another Permutation Problem	GNU C++20 (64)	`brute force` `dp` `greedy` `math` `*1200`	Aug/13/2023 01:24
930	B - Find The Array	GNU C++20 (64)	`bitmasks` `constructive algorithms` `greedy` `*1400`	Aug/11/2023 18:48
929	B - Polycarp Writes a String from Memory	GNU C++20 (64)	`greedy` `*800`	Aug/10/2023 01:13
928	C - Almost All Multiples	GNU C++20 (64)	`greedy` `number theory` `*1400`	Aug/09/2023 23:54
927	B - Maximum Rounding	GNU C++20 (64)	`greedy` `implementation` `math` `*1100`	Aug/08/2023 21:06
926	C - Assembly via Minimums	GNU C++20 (64)	`greedy` `sortings` `*1200`	Aug/08/2023 01:37
925	A - Array Coloring	GNU C++20 (64)	`greedy` `math` `*800`	Aug/08/2023 00:39
924	A - Winner	GNU C++20 (64)	`hashing` `implementation` `*1500`	Aug/07/2023 22:19
923	C - To Become Max	GNU C++20 (64)	`binary search` `brute force` `data structures` `dp` `*1600`	Aug/06/2023 23:02
922	C - Divisibility by Eight	GNU C++20 (64)	`brute force` `dp` `math` `*1500`	Aug/05/2023 23:59
921	C - Two TVs	GNU C++20 (64)	`data structures` `greedy` `sortings` `*1500`	Aug/04/2023 19:14
920	F - Interesting Function	GNU C++20 (64)	`binary search` `dp` `math` `number theory` `*1500`	Aug/04/2023 14:41
919	C2 - Potions (Hard Version)	GNU C++20 (64)	`data structures` `greedy` `*1600`	Aug/03/2023 16:07
918	C1 - Potions (Easy Version)	GNU C++20 (64)	`brute force` `data structures` `dp` `greedy` `*1500`	Aug/03/2023 16:06
917	C - Balanced Team	GNU C++20 (64)	`sortings` `two pointers` `*1200`	Aug/03/2023 00:25
916	B - Lucky Numbers (easy)	GNU C++20 (64)	`binary search` `bitmasks` `brute force` `*1300`	Aug/02/2023 21:00
915	B - Plus and Multiply	GNU C++20 (64)	`constructive algorithms` `math` `number theory` `*1500`	Aug/01/2023 21:19
914	B - Bad Boy	GNU C++20 (64)	`constructive algorithms` `greedy` `math` `*900`	Aug/01/2023 01:13
913	B - Regular Bracket Sequence	GNU C++20 (64)	`greedy` `*1400`	Jul/31/2023 19:14
912	E - Arranging The Sheep	GNU C++20 (64)	`greedy` `math` `*1400`	Jul/31/2023 19:02
911	C - Delete Two Elements	GNU C++20 (64)	`data structures` `dp` `implementation` `math` `two pointers` `*1200`	Jul/30/2023 23:38
910	B - Longest Divisors Interval	GNU C++20 (64)	`brute force` `combinatorics` `greedy` `math` `number theory` `*900`	Jul/30/2023 21:07
909	B - Fibonaccharsis	GNU C++20 (64)	`binary search` `brute force` `math` `*1200`	Jul/30/2023 13:40
908	B - T-shirt buying	GNU C++20 (64)	`data structures` `implementation` `*1400`	Jul/29/2023 14:32
907	A - Andryusha and Socks	GNU C++20 (64)	`implementation` `*800`	Jul/28/2023 23:30
906	D - X-Sum	GNU C++20 (64)	`brute force` `greedy` `implementation` `*1000`	Jul/27/2023 23:32
905	A - Escalator Conversations	GNU C++20 (64)	`brute force` `constructive algorithms` `math` `*800`	Jul/26/2023 21:53
904	D - Prefix Permutation Sums	GNU C++20 (64)	`implementation` `math` `*1300`	Jul/26/2023 20:22
903	C - Tiles Comeback	GNU C++20 (64)	`greedy` `*1000`	Jul/26/2023 00:55
902	B - Parity Sort	GNU C++20 (64)	`greedy` `sortings` `two pointers` `*800`	Jul/26/2023 00:08
901	B - Restricted RPS	GNU C++20 (64)	`constructive algorithms` `dp` `greedy` `*1200`	Jul/24/2023 01:11
900	A - Comparing Two Long Integers	GNU C++20 (64)	`implementation` `strings` `*900`	Jul/23/2023 22:21
899	C - Great Sequence	GNU C++20 (64)	`greedy` `sortings` `*1200`	Jul/22/2023 20:50
898	E - Cardboard for Pictures	GNU C++20 (64)	`binary search` `geometry` `implementation` `math` `*1100`	Jul/21/2023 22:34
897	F - We Were Both Children	GNU C++20 (64)	`brute force` `implementation` `math` `number theory` `*1300`	Jul/21/2023 22:16
896	D - Balanced Round	GNU C++20 (64)	`brute force` `greedy` `implementation` `sortings` `*900`	Jul/21/2023 20:56
895	C - Word on the Paper	GNU C++20 (64)	`implementation` `strings` `*800`	Jul/21/2023 20:49
894	B - Ten Words of Wisdom	GNU C++20 (64)	`implementation` `sortings` `*800`	Jul/21/2023 20:46
893	A - To My Critics	GNU C++20 (64)	`implementation` `sortings` `*800`	Jul/21/2023 20:37
892	A - Direction Change	GNU C++20 (64)	`implementation` `math` `*800`	Jul/20/2023 23:26
891	B - Square?	GNU C++20 (64)	`brute force` `implementation` `math` `*900`	Jul/19/2023 23:21
890	C - Contrast Value	GNU C++20 (64)	`greedy` `implementation` `*1200`	Jul/18/2023 00:00
889	A - Boboniu Likes to Color Balls	GNU C++20 (64)	`brute force` `math` `*1000`	Jul/17/2023 23:33
888	C - Two Arrays	GNU C++20 (64)	`greedy` `math` `sortings` `*900`	Jul/16/2023 20:23
887	A - Anti Light's Cell Guessing	GNU C++20 (64)	`math` `*900`	Jul/16/2023 19:48
886	B - Sum of Medians	GNU C++20 (64)	`greedy` `math` `*900`	Jul/15/2023 23:08
885	B - Power Walking	GNU C++20 (64)	`greedy` `*900`	Jul/14/2023 21:07
884	B - Array Cloning Technique	GNU C++20 (64)	`constructive algorithms` `greedy` `sortings` `*900`	Jul/14/2023 20:19
883	A - Forbidden Integer	GNU C++20 (64)	`constructive algorithms` `implementation` `math` `number theory` `*800`	Jul/13/2023 19:57
882	B - Customising the Track	GNU C++20 (64)	`combinatorics` `greedy` `math` `*900`	Jul/13/2023 18:50
881	A - Subtraction Game	GNU C++20 (64)	`constructive algorithms` `games` `*800`	Jul/12/2023 14:43
880	B - Mystic Permutation	GNU C++20 (64)	`data structures` `greedy` `*900`	Jul/11/2023 18:12
879	A - Filling Shapes	GNU C++20 (64)	`dp` `math` `*1000`	Jul/10/2023 23:11
878	A - Pashmak and Garden	GNU C++20 (64)	`implementation` `*1200`	Jul/10/2023 13:27
877	C - Monitor	GNU C++20 (64)	`binary search` `number theory` `*1800`	Jul/10/2023 00:26
876	B - M-arrays	GNU C++20 (64)	`constructive algorithms` `greedy` `math` `*1200`	Jul/09/2023 21:14
875	C - Yet Another Array Restoration	GNU C++20 (64)	`brute force` `math` `number theory` `*1200`	Jul/08/2023 21:39
874	D - Rudolph and Christmas Tree	GNU C++20 (64)	`constructive algorithms` `geometry` `math` `*1200`	Jul/08/2023 12:46
873	B - Rudolph and Tic-Tac-Toe	GNU C++20 (64)	`brute force` `implementation` `strings` `*800`	Jul/07/2023 23:05
872	C - Rudolf and the Another Competition	GNU C++20 (64)	`constructive algorithms` `data structures` `dp` `greedy` `sortings` `*1200`	Jul/07/2023 21:50
871	A - Rudolph and Cut the Rope	GNU C++20 (64)	`implementation` `math` `*800`	Jul/07/2023 20:47
870	D - Matryoshkas	GNU C++20 (64)	`data structures` `greedy` `sortings` `*1200`	Jul/07/2023 16:45
869	B - Flip the Bits	GNU C++20 (64)	`constructive algorithms` `greedy` `implementation` `math` `*1200`	Jul/07/2023 16:16
868	C - Three Parts of the Array	GNU C++20 (64)	`binary search` `data structures` `two pointers` `*1200`	Jul/06/2023 22:56
867	B - Make Them Odd	GNU C++20 (64)	`greedy` `number theory` `*1200`	Jul/06/2023 22:18
866	B - Creating the Contest	GNU C++20 (64)	`dp` `greedy` `math` `*1200`	Jul/05/2023 20:22
865	C - Dominated Subarray	GNU C++20 (64)	`greedy` `implementation` `sortings` `strings` `two pointers` `*1200`	Jul/05/2023 19:18
864	A - Casimir's String Solitaire	GNU C++20 (64)	`math` `strings` `*800`	Jul/05/2023 10:59
863	B - Divan and a New Project	GNU C++20 (64)	`constructive algorithms` `sortings` `*1000`	Jul/04/2023 19:55
862	B - Red and Blue	GNU C++20 (64)	`dp` `greedy` `*1000`	Jul/04/2023 18:00
861	B - Binary Removals	GNU C++20 (64)	`brute force` `dp` `greedy` `implementation` `*1000`	Jul/04/2023 17:35
860	B - Reverse Binary Strings	GNU C++20 (64)	`constructive algorithms` `greedy` `*1200`	Jul/03/2023 21:31
859	B - Build the Permutation	GNU C++20 (64)	`constructive algorithms` `greedy` `*1200`	Jul/03/2023 03:58
858	C - Make Them Equal	GNU C++20 (64)	`brute force` `greedy` `math` `strings` `*1200`	Jul/03/2023 00:49
857	D - Even-Odd Game	GNU C++20 (64)	`dp` `games` `greedy` `sortings` `*1200`	Jul/02/2023 20:24
856	B - Also Try Minecraft	GNU C++20 (64)	`data structures` `dp` `implementation` `*900`	Jul/01/2023 21:41
855	B - Mark the Dust Sweeper	GNU C++20 (64)	`constructive algorithms` `greedy` `implementation` `*900`	Jul/01/2023 20:52
854	B - Rule of League	GNU C++20 (64)	`constructive algorithms` `math` `*900`	Jul/01/2023 20:32
853	A - Everyone Loves to Sleep	GNU C++20 (64)	`implementation` `math` `*900`	Jul/01/2023 19:24
852	A - Common Prefixes	GNU C++20 (64)	`constructive algorithms` `greedy` `strings` `*1200`	Jun/30/2023 00:06
851	C - Make It Good	GNU C++20 (64)	`greedy` `*1200`	Jun/29/2023 02:03
850	B - Maximum Product	GNU C++20 (64)	`brute force` `dp` `greedy` `implementation` `sortings` `*1200`	Jun/29/2023 01:08
849	C - Wrong Addition	GNU C++20 (64)	`implementation` `*1200`	Jun/28/2023 00:49
848	C2 - k-LCM (hard version)	GNU C++20 (64)	`constructive algorithms` `math` `*1600`	Jun/27/2023 17:13
847	C1 - k-LCM (easy version)	GNU C++20 (64)	`constructive algorithms` `math` `*1200`	Jun/27/2023 17:09
846	B - Prinzessin der Verurteilung	GNU C++20 (64)	`brute force` `constructive algorithms` `strings` `*1200`	Jun/27/2023 16:26
845	C - Sequence Transformation	GNU C++20 (64)	`greedy` `implementation` `*1200`	Jun/26/2023 19:37
844	C - Penalty	GNU C++20 (64)	`bitmasks` `brute force` `dp` `greedy` `*1200`	Jun/26/2023 01:21
843	A - Tenzing and Tsondu	GNU C++20 (64)	`games` `math` `*800`	Jun/25/2023 00:00
842	B - Tenzing and Books	GNU C++20 (64)	`bitmasks` `greedy` `math` `*1100`	Jun/24/2023 23:59
841	B - Stairs	GNU C++20 (64)	`brute force` `constructive algorithms` `greedy` `implementation` `math` `*1200`	Jun/24/2023 20:48
840	B - AND 0, Sum Big	GNU C++20 (64)	`bitmasks` `combinatorics` `math` `*1200`	Jun/23/2023 02:07
839	B - Equal Rectangles	GNU C++20 (64)	`greedy` `math` `*1200`	Jun/22/2023 19:54
838	A - Exercising Walk	GNU C++20 (64)	`greedy` `implementation` `math` `*1100`	Jun/21/2023 22:19
837	B - Boboniu Plays Chess	GNU C++20 (64)	`constructive algorithms` `*1100`	Jun/21/2023 12:33
836	D - Apple Tree	GNU C++20 (64)	`combinatorics` `dfs and similar` `dp` `math` `trees` `*1200`	Jun/20/2023 23:12
835	C - Sum in Binary Tree	GNU C++20 (64)	`bitmasks` `combinatorics` `math` `trees` `*800`	Jun/20/2023 20:58
834	B - Long Long	GNU C++20 (64)	`greedy` `math` `two pointers` `*800`	Jun/20/2023 20:48
833	A - Sasha and Array Coloring	GNU C++20 (64)	`greedy` `sortings` `two pointers` `*800`	Jun/20/2023 20:39
832	B - Putting Bricks in the Wall	GNU C++20 (64)	`constructive algorithms` `implementation` `*1100`	Jun/20/2023 20:20
831	B - Lord of the Values	GNU C++20 (64)	`constructive algorithms` `*1100`	Jun/20/2023 19:16
830	A - Cards for Friends	GNU C++20 (64)	`greedy` `math` `*800`	Jun/20/2023 12:57
829	A - GCD Sum	GNU C++20 (64)	`brute force` `math` `*800`	Jun/19/2023 23:36
828	A - Two Bags of Potatoes	GNU C++20 (64)	`greedy` `implementation` `math` `*1200`	Jun/19/2023 19:26
827	B - Misha and Changing Handles	GNU C++20 (64)	`data structures` `dsu` `strings` `*1100`	Jun/19/2023 01:23
826	A - Destroyer	GNU C++20 (64)	`implementation` `sortings` `*800`	Jun/18/2023 23:37
825	A - Unit Array	GNU C++20 (64)	`greedy` `math` `*800`	Jun/18/2023 17:40
824	B - Sherlock and his girlfriend	GNU C++20 (64)	`constructive algorithms` `number theory` `*1200`	Jun/17/2023 22:21
823	B - Card Deck	GNU C++20 (64)	`data structures` `greedy` `math` `*1100`	Jun/17/2023 19:41
822	A - Brain's Photos	GNU C++20 (64)	`implementation` `*800`	Jun/17/2023 14:44
821	C - Ternary XOR	GNU C++20 (64)	`greedy` `implementation` `*1200`	Jun/17/2023 01:55
820	B - Books	GNU C++20 (64)	`binary search` `brute force` `implementation` `two pointers` `*1400`	Jun/17/2023 01:21
819	B - Histogram Ugliness	GNU C++20 (64)	`greedy` `implementation` `math` `*1100`	Jun/16/2023 21:54
818	B - Mex Master	GNU C++20 (64)	`constructive algorithms` `greedy` `*900`	Jun/15/2023 14:53
817	B - Game on Ranges	GNU C++20 (64)	`brute force` `dfs and similar` `implementation` `sortings` `*1100`	Jun/14/2023 21:16
816	A - Game with Board	GNU C++20 (64)	`constructive algorithms` `games` `*800`	Jun/13/2023 01:17
815	B - Keep it Beautiful	GNU C++20 (64)	`implementation` `*1000`	Jun/13/2023 01:04
814	A - Multiplication Table	GNU C++20 (64)	`implementation` `number theory` `*1000`	Jun/12/2023 09:35
813	C - Challenging Cliffs	GNU C++20 (64)	`constructive algorithms` `greedy` `implementation` `math` `*1200`	Jun/11/2023 13:57
812	B - Palindromic Numbers	GNU C++20 (64)	`constructive algorithms` `implementation` `math` `*1100`	Jun/10/2023 01:06
811	B - JOE is on TV!	GNU C++20 (64)	`combinatorics` `greedy` `math` `*1000`	Jun/09/2023 23:56
810	A - Digits Sequence (Easy Edition)	GNU C++20 (64)	`implementation` `*1000`	Jun/08/2023 02:18
809	E - Character Blocking	GNU C++20 (64)	`data structures` `hashing` `implementation` `*1600`	Jun/07/2023 21:06
808	D - Wooden Toy Festival	GNU C++20 (64)	`binary search` `greedy` `sortings` `*1400`	Jun/07/2023 18:39
807	C - Ski Resort	GNU C++20 (64)	`combinatorics` `math` `two pointers` `*1000`	Jun/06/2023 21:48
806	B - Binary Cafe	GNU C++20 (64)	`bitmasks` `combinatorics` `math` `*1100`	Jun/06/2023 21:28
805	A - Cipher Shifer	GNU C++20 (64)	`implementation` `strings` `two pointers` `*800`	Jun/06/2023 20:44
804	B - Jeff and Periods	GNU C++20 (64)	`implementation` `sortings` `*1300`	Jun/06/2023 02:13
803	A - DZY Loves Chessboard	GNU C++20 (64)	`dfs and similar` `implementation` `*1200`	Jun/06/2023 01:46
802	A - Black Square	GNU C++20 (64)	`implementation` `*800`	Jun/05/2023 01:49
801	A - City Day	GNU C++20 (64)	`implementation` `*1000`	Jun/05/2023 01:24
800	A - The Good Array	GNU C++20 (64)	`greedy` `implementation` `math` `*800`	Jun/05/2023 00:51
799	A - Bad Ugly Numbers	GNU C++20 (64)	`constructive algorithms` `number theory` `*1000`	Jun/04/2023 21:26
798	A - Bestie	GNU C++20 (64)	`brute force` `combinatorics` `constructive algorithms` `implementation` `math` `number theory` `*1000`	Jun/03/2023 02:25
797	A - The Contest	GNU C++20 (64)	`implementation` `*1100`	Jun/02/2023 20:47
796	A - An abandoned sentiment from past	GNU C++20 (64)	`constructive algorithms` `greedy` `implementation` `sortings` `*900`	Jun/01/2023 13:18
795	A - Matrix Game	GNU C++20 (64)	`games` `greedy` `implementation` `*1100`	May/31/2023 21:48
794	B - Hate "A"	GNU C++20 (64)	`implementation` `strings` `*1100`	May/31/2023 19:44
793	A - Regular Bracket Sequence	GNU C++20 (64)	`greedy` `implementation` `*1100`	May/31/2023 18:37
792	C - Frog Jumps	GNU C++20 (64)	`binary search` `data structures` `dfs and similar` `greedy` `implementation` `*1100`	May/30/2023 23:04
791	B - Two Arrays	GNU C++20 (64)	`greedy` `math` `sortings` `*1100`	May/30/2023 22:35
790	B - Partial Replacement	GNU C++20 (64)	`greedy` `implementation` `*1100`	May/30/2023 20:45
789	B - Combinatorics Homework	GNU C++20 (64)	`combinatorics` `greedy` `math` `*1100`	May/30/2023 01:01
788	B - Elementary Particles	GNU C++20 (64)	`brute force` `greedy` `sortings` `*1100`	May/29/2023 23:35
787	D1 - Seating Arrangements (easy version)	GNU C++20 (64)	`data structures` `greedy` `sortings` `*1100`	May/29/2023 02:17
786	C - Ping-pong	GNU C++20 (64)	`constructive algorithms` `games` `math` `*1100`	May/29/2023 01:44
785	B - Array merging	GNU C++20 (64)	`constructive algorithms` `greedy` `*1000`	May/28/2023 22:00
784	A - Twin Permutations	GNU C++20 (64)	`constructive algorithms` `*800`	May/28/2023 20:50
783	B - William the Vigilant	GNU C++20 (64)	`implementation` `strings` `*1100`	May/28/2023 19:56
782	B - Odd Swap Sort	GNU C++20 (64)	`data structures` `math` `sortings` `*1100`	May/27/2023 00:43
781	C - Two Teams Composing	GNU C++20 (64)	`binary search` `greedy` `implementation` `sortings` `*1100`	May/26/2023 20:51
780	B - Divine Array	GNU C++20 (64)	`constructive algorithms` `implementation` `*1100`	May/26/2023 19:33
779	B - Nezzar and Lucky Number	GNU C++20 (64)	`brute force` `dp` `greedy` `math` `*1100`	May/26/2023 17:41
778	D - Bracket Coloring	GNU C++20 (64)	`constructive algorithms` `greedy` `*1400`	May/26/2023 00:50
777	C - Best Binary String	GNU C++20 (64)	`constructive algorithms` `greedy` `*1000`	May/25/2023 21:45
776	B - Comparison String	GNU C++20 (64)	`greedy` `*900`	May/25/2023 21:17
775	A - Grasshopper on a Line	GNU C++20 (64)	`constructive algorithms` `math` `*800`	May/25/2023 20:40
774	B - Middle Class	GNU C++20 (64)	`greedy` `sortings` `*1100`	May/25/2023 16:48
773	B - Ternary Sequence	GNU C++20 (64)	`constructive algorithms` `greedy` `math` `*1100`	May/25/2023 16:31
772	D - Line	GNU C++20 (64)	`greedy` `sortings` `*1100`	May/25/2023 02:26
771	B - Kalindrome Array	GNU C++20 (64)	`greedy` `two pointers` `*1100`	May/24/2023 22:09
770	A - Shovels and Swords	GNU C++20 (64)	`binary search` `greedy` `math` `*1100`	May/24/2023 19:49
769	B - Shifting Sort	GNU C++20 (64)	`implementation` `sortings` `*1100`	May/24/2023 16:05
768	D1 - All are Same	GNU C++20 (64)	`math` `number theory` `*1100`	May/23/2023 18:51
767	A - Supercentral Point	GNU C++20 (64)	`implementation` `*1000`	May/23/2023 03:45
766	C - Letters	GNU C++20 (64)	`binary search` `implementation` `two pointers` `*1000`	May/23/2023 00:15
765	C - Kill the Monster	GNU C++20 (64)	`brute force` `math` `*1100`	May/22/2023 03:29
764	C - Pair Programming	GNU C++20 (64)	`greedy` `two pointers` `*1100`	May/21/2023 16:56
763	B - Cover Points	GNU C++20 (64)	`geometry` `math` `*900`	May/21/2023 00:55
762	C - Save More Mice	GNU C++20 (64)	`binary search` `greedy` `greedy` `*1000`	May/20/2023 23:38
761	A - Tavas and Nafas	GNU C++20 (64)	`brute force` `implementation` `*1000`	May/20/2023 21:34
760	D - Deletive Editing	GNU C++20 (64)	`greedy` `*900`	May/20/2023 01:44
759	C - Vlad Building Beautiful Array	GNU C++20 (64)	`greedy` `math` `*800`	May/19/2023 21:18
758	B - Restore the Weather	GNU C++20 (64)	`greedy` `sortings` `*900`	May/19/2023 20:57
757	A - Musical Puzzle	GNU C++20 (64)	`implementation` `strings` `*800`	May/19/2023 20:43
756	B - GCD Compression	GNU C++20 (64)	`constructive algorithms` `math` `number theory` `*1100`	May/19/2023 19:20
755	B - Kind Anton	GNU C++20 (64)	`greedy` `implementation` `*1100`	May/19/2023 18:25
754	A - Sign Flipping	GNU C++20 (64)	`constructive algorithms` `math` `*1100`	May/19/2023 17:18
753	B - Repainting Street	GNU C++20 (64)	`brute force` `greedy` `*1100`	May/18/2023 23:31
752	B - Effective Approach	GNU C++20 (64)	`implementation` `*1100`	May/18/2023 21:36
751	B - A New Technique	GNU C++20 (64)	`constructive algorithms` `implementation` `*1100`	May/18/2023 21:10
750	B - Tavas and SaDDas	GNU C++20 (64)	`bitmasks` `brute force` `combinatorics` `implementation` `*1100`	May/17/2023 22:31
749	A - Array	GNU C++20 (64)	`brute force` `constructive algorithms` `implementation` `*1100`	May/17/2023 19:14
748	B - Petya and Countryside	GNU C++17	`brute force` `implementation` `*1100`	May/17/2023 18:36
747	C - Alphabetic Removals	GNU C++17	`implementation` `*1200`	May/17/2023 00:14
746	B - The Fibonacci Segment	GNU C++17	`implementation` `*1100`	May/16/2023 20:11
745	B - XOR Specia-LIS-t	GNU C++17	`*1100`	May/16/2023 19:29
744	C - Yet Another Card Deck	GNU C++17	`brute force` `data structures` `implementation` `trees` `*1100`	May/16/2023 18:49
743	B - Fun with Even Subarrays	GNU C++17	`dp` `greedy` `*1100`	May/16/2023 18:29
742	C - Counting Orders	GNU C++17	`binary search` `combinatorics` `sortings` `*1100`	May/15/2023 20:35
741	A - Divisible Array	GNU C++17	`constructive algorithms` `math` `*800`	May/15/2023 00:47
740	B - Permutation Swap	GNU C++17	`math` `number theory` `*900`	May/15/2023 00:46
739	A - Ahahahahahahahaha	GNU C++17	`constructive algorithms` `math` `*1100`	May/15/2023 00:12
738	B - Max and Mex	GNU C++17	`math` `*1100`	May/14/2023 17:00
737	B - Roadside Trees (Simplified Edition)	GNU C++17	`greedy` `implementation` `*1000`	May/14/2023 16:31
736	B - Update Files	GNU C++17	`greedy` `implementation` `math` `*1100`	May/14/2023 01:13
735	A - Kitahara Haruki's Gift	GNU C++17	`brute force` `implementation` `*1100`	May/13/2023 20:22
734	B - Special Numbers	GNU C++17	`bitmasks` `math` `*1100`	May/13/2023 02:29
733	A - New Palindrome	GNU C++17	`strings` `*800`	May/12/2023 20:40
732	B - Cobb	GNU C++17	`bitmasks` `brute force` `greedy` `math` `*1700`	May/11/2023 19:23
731	C - Long Jumps	GNU C++17	`dp` `graphs` `*1100`	May/11/2023 02:21
730	B - Strange List	GNU C++17	`brute force` `greedy` `implementation` `math` `*1100`	May/10/2023 23:04
729	B - Yet Another Meme Problem	GNU C++20 (64)	`math` `*1100`	May/10/2023 22:00
728	B - Merge it!	GNU C++20 (64)	`math` `*1100`	May/10/2023 21:00
727	A - Deadline	GNU C++20 (64)	`binary search` `brute force` `math` `ternary search` `*1100`	May/10/2023 20:49
726	B - Sifid and Strange Subsequences	GNU C++20 (64)	`greedy` `math` `sortings` `*1100`	May/10/2023 19:45
725	C - Increase and Copy	GNU C++20 (64)	`binary search` `constructive algorithms` `math` `*1100`	May/09/2023 22:54
724	A - LuoTianyi and the Palindrome String	GNU C++20 (64)	`greedy` `strings` `*800`	May/09/2023 21:41
723	C - ABBB	GNU C++20 (64)	`brute force` `data structures` `greedy` `strings` `*1100`	May/08/2023 23:49
722	B - LuoTianyi and the Table	GNU C++20 (64)	`greedy` `math` `*1000`	May/08/2023 19:42
721	B - Petya and Staircases	GNU C++20 (64)	`implementation` `sortings` `*1100`	May/07/2023 20:34
720	F - Forever Winter	GNU C++20 (64)	`dfs and similar` `graphs` `math` `*1300`	May/07/2023 18:53
719	E - The Lakes	GNU C++20 (64)	`dfs and similar` `dsu` `graphs` `implementation` `*1100`	May/06/2023 22:30
718	D - Gold Rush	GNU C++20 (64)	`brute force` `dfs and similar` `dp` `implementation` `*1000`	May/06/2023 21:58
717	C - Mr. Perfectly Fine	GNU C++20 (64)	`bitmasks` `greedy` `implementation` `*800`	May/06/2023 21:04
716	B - Blank Space	GNU C++20 (64)	`implementation` `*800`	May/06/2023 20:39
715	A - Love Story	GNU C++20 (64)	`implementation` `strings` `*800`	May/06/2023 20:37
714	B - Lunatic Never Content	GNU C++20 (64)	`math` `number theory` `*1100`	May/06/2023 01:00
713	A - Another Sorting Problem	GNU C++20 (64)	`data structures` `sortings` `strings` `*1100`	May/05/2023 17:08
712	A - Level Statistics	GNU C++20 (64)	`implementation` `math` `*1200`	May/04/2023 15:18
711	C - Omkar and Waterslide	GNU C++20 (64)	`greedy` `implementation` `*1200`	May/04/2023 14:35
710	A - Find Array	GNU C++20 (64)	`constructive algorithms` `math` `*800`	May/03/2023 20:49
709	C - Little Elephant and Bits	GNU C++20 (64)	`greedy` `strings` `*1100`	May/02/2023 21:30
708	A - Little Elephant and Chess	GNU C++20 (64)	`brute force` `strings` `*1000`	May/02/2023 21:14
707	B - Little Elephant and Magic Square	GNU C++20 (64)	`brute force` `implementation` `*1100`	May/02/2023 20:08
706	B - Little Pigs and Wolves	GNU C++20 (64)	`greedy` `implementation` `*1100`	May/02/2023 18:52
705	B - Different Divisors	GNU C++20 (64)	`binary search` `constructive algorithms` `greedy` `math` `number theory` `*1000`	May/02/2023 16:17
704	A - Regular Bracket Sequence	GNU C++20 (64)	`constructive algorithms` `greedy` `*1000`	May/02/2023 02:31
703	C - MAX-MEX Cut	GNU C++20 (64)	`bitmasks` `constructive algorithms` `dp` `greedy` `*1000`	May/02/2023 02:05
702	B - Balanced Remainders	GNU C++20 (64)	`brute force` `constructive algorithms` `math` `*1000`	May/01/2023 20:11
701	B - MEXor Mixup	GNU C++20 (64)	`bitmasks` `greedy` `*1000`	May/01/2023 01:19
700	B - Reverse Sort	GNU C++20 (64)	`greedy` `sortings` `*1000`	Apr/30/2023 23:37
699	A - Little Artem	GNU C++20 (64)	`constructive algorithms` `*1000`	Apr/30/2023 03:07
698	A - Johnny and Ancient Computer	GNU C++20 (64)	`implementation` `*1000`	Apr/30/2023 02:34
697	C - Almost Increasing Subsequence	GNU C++20 (64)	`binary search` `dp` `greedy` `*1500`	Apr/30/2023 01:40
696	A - Politics	GNU C++20 (64)	`greedy` `implementation` `*800`	Apr/29/2023 21:35
695	B - Indivisible	GNU C++20 (64)	`constructive algorithms` `*900`	Apr/29/2023 21:33
694	B - Sort with Step	GNU C++20 (64)	`brute force` `math` `sortings` `*900`	Apr/29/2023 20:14
693	A - A-characteristic	GNU C++20 (64)	`combinatorics` `constructive algorithms` `math` `*800`	Apr/29/2023 18:54
692	A - Add and Divide	GNU C++20 (64)	`brute force` `greedy` `math` `number theory` `*1000`	Apr/28/2023 23:43
691	A - Rank List	GNU C++20 (64)	`binary search` `implementation` `sortings` `*1100`	Apr/28/2023 17:59
690	B - Ciel and Flowers	GNU C++20 (64)	`combinatorics` `math` `*1600`	Apr/28/2023 02:14
689	C - Paint the Array	GNU C++20 (64)	`math` `*1100`	Apr/28/2023 00:51
688	B - Big Segment	GNU C++20 (64)	`implementation` `sortings` `*1100`	Apr/27/2023 19:53
687	C - Polycarp Recovers the Permutation	GNU C++20 (64)	`constructive algorithms` `*1000`	Apr/26/2023 13:39
686	A - Remainder	GNU C++20 (64)	`implementation` `math` `*1100`	Apr/26/2023 13:19
685	B - Polycarp Training	GNU C++20 (64)	`data structures` `greedy` `sortings` `*1000`	Apr/26/2023 12:35
684	B - Cormen --- The Best Friend Of a Man	GNU C++20 (64)	`dp` `greedy` `*1000`	Apr/26/2023 12:24
683	B1 - Social Network (easy version)	GNU C++20 (64)	`implementation` `*1000`	Apr/25/2023 13:47
682	A - Dima and Friends	GNU C++20 (64)	`implementation` `math` `*1000`	Apr/25/2023 13:22
681	B - Sport Mafia	GNU C++20 (64)	`binary search` `brute force` `math` `*1000`	Apr/25/2023 00:54
680	D - Super-Permutation	GNU C++20 (64)	`constructive algorithms` `math` `*1200`	Apr/24/2023 22:24
679	C - Bun Lover	GNU C++20 (64)	`math` `*800`	Apr/24/2023 21:44
678	B - Karina and Array	GNU C++20 (64)	`greedy` `math` `sortings` `*800`	Apr/24/2023 20:50
677	A - TubeTube Feed	GNU C++20 (64)	`brute force` `implementation` `*800`	Apr/24/2023 20:45
676	B - Fair Numbers	GNU C++20 (64)	`brute force` `number theory` `*1000`	Apr/24/2023 20:30
675	B - Roof Construction	GNU C++20 (64)	`bitmasks` `constructive algorithms` `*1000`	Apr/24/2023 16:51
674	C - Minimum Extraction	GNU C++20 (64)	`brute force` `sortings` `*1000`	Apr/24/2023 14:13
673	A - Valera and X	GNU C++20 (64)	`implementation` `*1000`	Apr/23/2023 22:01
672	B - Berland Music	GNU C++20 (64)	`data structures` `greedy` `math` `sortings` `*1000`	Apr/23/2023 19:03
671	B - Maximum Cost Deletion	GNU C++20 (64)	`greedy` `math` `*1000`	Apr/23/2023 17:41
670	A - Nastia and Nearly Good Numbers	GNU C++20 (64)	`constructive algorithms` `math` `number theory` `*1000`	Apr/23/2023 14:20
669	A - Min Max Swap	GNU C++20 (64)	`greedy` `*800`	Apr/22/2023 01:05
668	A - ABC	GNU C++20 (64)	`implementation` `*800`	Apr/22/2023 01:01
667	A - Binary Decimal	GNU C++20 (64)	`greedy` `math` `*800`	Apr/22/2023 00:42
666	B - Sort the Subarray	GNU C++20 (64)	`brute force` `greedy` `*1100`	Apr/21/2023 03:29
665	A - Matching	GNU C++20 (64)	`combinatorics` `math` `*800`	Apr/21/2023 01:18
664	B - Odd Sum Segments	GNU C++20 (64)	`constructive algorithms` `math` `*1200`	Apr/20/2023 22:51
663	B - Moamen and k-subarrays	GNU C++20 (64)	`greedy` `sortings` `*1100`	Apr/20/2023 15:08
662	B - TMT Document	GNU C++20 (64)	`greedy` `*1100`	Apr/20/2023 13:07
661	A - Box is Pull	GNU C++20 (64)	`math` `*800`	Apr/19/2023 15:46
660	B - Pleasant Pairs	GNU C++20 (64)	`brute force` `implementation` `math` `number theory` `*1200`	Apr/18/2023 19:43
659	C - Stable Groups	GNU C++20 (64)	`greedy` `sortings` `*1200`	Apr/18/2023 19:07
658	A - Odd Set	GNU C++20 (64)	`math` `*800`	Apr/17/2023 22:01
657	A - Domino	GNU C++20 (64)	`implementation` `math` `*1200`	Apr/16/2023 00:38
656	B - Array Reodering	GNU C++20 (64)	`brute force` `greedy` `math` `number theory` `sortings` `*900`	Apr/15/2023 17:52
655	A - Little Xor	GNU C++20 (64)	`brute force` `implementation` `*1100`	Apr/14/2023 19:49
654	A - Shortest Path with Obstacle	GNU C++20 (64)	`implementation` `math` `*800`	Apr/14/2023 15:09
653	B - Alphabetical Strings	GNU C++20 (64)	`greedy` `implementation` `strings` `*800`	Apr/14/2023 01:55
652	C - Search in Parallel	GNU C++20 (64)	`constructive algorithms` `greedy` `sortings` `*1500`	Apr/14/2023 00:01
651	B - Beautiful Numbers	GNU C++20 (64)	`data structures` `implementation` `math` `two pointers` `*1300`	Apr/13/2023 20:32
650	C - Alice, Bob and Chocolate	GNU C++20 (64)	`greedy` `two pointers` `*1200`	Apr/13/2023 19:01
649	A - Next Test	GNU C++20 (64)	`implementation` `sortings` `*1200`	Apr/13/2023 16:55
648	D - Epic Transformation	GNU C++20 (64)	`constructive algorithms` `data structures` `greedy` `*1400`	Apr/13/2023 16:49
647	C - Dominant Character	GNU C++20 (64)	`brute force` `greedy` `implementation` `strings` `*1400`	Apr/13/2023 06:06
646	C - Get an Even String	GNU C++20 (64)	`dp` `greedy` `strings` `*1300`	Apr/12/2023 07:06
645	A - Ichihime and Triangle	GNU C++20 (64)	`constructive algorithms` `math` `*800`	Apr/11/2023 23:55
644	B - CopyCopyCopyCopyCopy	GNU C++20 (64)	`greedy` `implementation` `*800`	Apr/11/2023 23:33
643	E - Vlad and a Pair of Numbers	GNU C++20 (64)	`bitmasks` `constructive algorithms` `*1400`	Apr/10/2023 03:47
642	C - Ian and Array Sorting	GNU C++20 (64)	`math` `sortings` `*1300`	Apr/09/2023 22:56
641	B - Grid Reconstruction	GNU C++20 (64)	`constructive algorithms` `greedy` `*1000`	Apr/09/2023 21:31
640	A - Ian Visits Mary	GNU C++20 (64)	`constructive algorithms` `geometry` `number theory` `*800`	Apr/09/2023 21:04
639	C - Li Hua and Chess	GNU C++20 (64)	`constructive algorithms` `greedy` `interactive` `*1600`	Apr/09/2023 02:36
638	B - Li Hua and Pattern	GNU C++20 (64)	`constructive algorithms` `greedy` `*1100`	Apr/08/2023 23:00
637	A - Li Hua and Maze	GNU C++20 (64)	`constructive algorithms` `flows` `graphs` `greedy` `implementation` `*800`	Apr/08/2023 20:46
636	C - Not Adjacent Matrix	GNU C++20 (64)	`constructive algorithms` `*1000`	Apr/08/2023 05:31
635	B - Emordnilap	GNU C++20 (64)	`combinatorics` `greedy` `math` `*900`	Apr/08/2023 02:25
634	A - Everybody Likes Good Arrays!	GNU C++20 (64)	`greedy` `math` `*800`	Apr/08/2023 01:28
633	A - BerOS file system	GNU C++20 (64)	`implementation` `*1700`	Apr/07/2023 20:49
632	A - We Need the Zero	GNU C++20 (64)	`bitmasks` `brute force` `*800`	Apr/07/2023 20:28
631	B - The String Has a Target	GNU C++20 (64)	`greedy` `strings` `*800`	Apr/07/2023 20:06
630	A - Coins	GNU C++20 (64)	`implementation` `math` `*800`	Apr/07/2023 00:15
629	B - Petr and a Combination Lock	GNU C++20 (64)	`bitmasks` `brute force` `dp` `*1200`	Apr/06/2023 00:43
628	E - Living Sequence	GNU C++20 (64)	`binary search` `dp` `math` `number theory` `*1500`	Apr/05/2023 23:01
627	B - Conveyor Belts	GNU C++20 (64)	`implementation` `math` `*1000`	Apr/04/2023 22:30
626	C - Restore the Array	GNU C++20 (64)	`constructive algorithms` `greedy` `*1100`	Apr/04/2023 21:37
625	A - Insert Digit	GNU C++20 (64)	`greedy` `math` `strings` `*800`	Apr/04/2023 20:46
624	A - Consecutive Sum	GNU C++20 (64)	`greedy` `sortings` `*800`	Apr/04/2023 05:31
623	B - Getting Zero	GNU C++20 (64)	`bitmasks` `brute force` `dfs and similar` `dp` `graphs` `greedy` `shortest paths` `*1300`	Apr/03/2023 22:06
622	C - Make It Permutation	GNU C++20 (64)	`brute force` `greedy` `sortings` `*1300`	Apr/03/2023 04:25
621	A - ABC String	GNU C++20 (64)	`bitmasks` `brute force` `implementation` `*900`	Apr/03/2023 02:24
620	A - YES or YES?	GNU C++20 (64)	`brute force` `implementation` `strings` `*800`	Apr/02/2023 23:19
619	C - Infinite Replacement	GNU C++20 (64)	`combinatorics` `implementation` `strings` `*1000`	Apr/01/2023 01:03
618	B - Candies	GNU C++20 (64)	`constructive algorithms` `math` `number theory` `*800`	Mar/31/2023 21:52
617	A - Beautiful Sequence	GNU C++20 (64)	`brute force` `greedy` `*800`	Mar/31/2023 20:44
616	C - 3SUM Closure	GNU C++20 (64)	`brute force` `data structures` `*1300`	Mar/31/2023 05:01
615	B - Playing in a Casino	GNU C++20 (64)	`math` `sortings` `*1200`	Mar/30/2023 23:18
614	A - Lucky Numbers	GNU C++20 (64)	`brute force` `implementation` `*900`	Mar/29/2023 15:23
613	F - Binary String Reconstruction	GNU C++20 (64)	`constructive algorithms` `dfs and similar` `math` `*1500`	Mar/29/2023 02:40
612	B - Minimum Product	GNU C++20 (64)	`brute force` `greedy` `math` `*1100`	Mar/29/2023 01:19
611	A - Uniform String	GNU C++20 (64)	`implementation` `*800`	Mar/28/2023 22:58
610	D - Shocking Arrangement	GNU C++20 (64)	`constructive algorithms` `greedy` `math` `*1600`	Mar/27/2023 02:27
609	B - Three Sevens	GNU C++20 (64)	`brute force` `data structures` `greedy` `implementation` `*1000`	Mar/26/2023 22:09
608	A - Showstopper	GNU C++20 (64)	`greedy` `implementation` `sortings` `*800`	Mar/26/2023 20:45
607	B - Queries about less or equal elements	GNU C++20 (64)	`binary search` `data structures` `sortings` `two pointers` `*1300`	Mar/26/2023 19:07
606	G - Special Permutation	GNU C++20 (64)	`constructive algorithms` `*1600`	Mar/25/2023 01:44
605	F - Smaller	GNU C++20 (64)	`constructive algorithms` `greedy` `strings` `*1500`	Mar/24/2023 22:52
604	B - Points on Plane	GNU C++20 (64)	`binary search` `greedy` `math` `*1000`	Mar/24/2023 00:15
603	A - Garland	GNU C++20 (64)	`implementation` `*800`	Mar/23/2023 23:41
602	C - Madoka and Childish Pranks	GNU C++20 (64)	`constructive algorithms` `greedy` `*1300`	Mar/23/2023 19:21
601	E - Special Elements	GNU C++20 (64)	`brute force` `implementation` `two pointers` `*1500`	Mar/23/2023 01:27
600	C - Jumping on Tiles	GNU C++20 (64)	`constructive algorithms` `strings` `*1100`	Mar/22/2023 23:33
599	C - Board Moves	GNU C++20 (64)	`math` `*1000`	Mar/22/2023 22:59
598	C - From S To T	GNU C++20 (64)	`implementation` `strings` `*1300`	Mar/21/2023 17:41
597	C - Find and Replace	GNU C++20 (64)	`greedy` `implementation` `strings` `*800`	Mar/20/2023 21:50
596	E - Interview	GNU C++20 (64)	`binary search` `implementation` `interactive` `*1300`	Mar/20/2023 19:01
595	G1 - Subsequence Addition (Easy Version)	GNU C++20 (64)	`brute force` `data structures` `dp` `greedy` `implementation` `sortings` `*1100`	Mar/19/2023 22:42
594	D - Odd Queries	GNU C++20 (64)	`data structures` `implementation` `*900`	Mar/19/2023 22:20
593	B - Grab the Candies	GNU C++20 (64)	`greedy` `*800`	Mar/19/2023 21:02
592	A - Plus or Minus	GNU C++20 (64)	`implementation` `*800`	Mar/19/2023 20:57
591	C1 - Increasing Subsequence (easy version)	GNU C++20 (64)	`greedy` `*1300`	Mar/18/2023 01:29
590	C - Prefixes and Suffixes	GNU C++20 (64)	`strings` `*1700`	Mar/17/2023 01:32
589	B - Teams Forming	GNU C++20 (64)	`sortings` `*800`	Mar/16/2023 21:50
588	B - Bogosort	GNU C++20 (64)	`constructive algorithms` `sortings` `*1000`	Mar/16/2023 21:42
587	D - Alice, Bob and Candies	GNU C++20 (64)	`implementation` `*1300`	Mar/16/2023 21:00
586	A - Lame King	GNU C++17	`greedy` `math` `*800`	Mar/16/2023 16:37
585	B - Array Sharpening	GNU C++20 (64)	`greedy` `implementation` `*1300`	Mar/15/2023 23:04
584	B - Scenes From a Memory	Java 17	`brute force` `constructive algorithms` `implementation` `math` `number theory` `*1000`	Mar/15/2023 20:38
583	B - Sysadmin Bob	GNU C++20 (64)	`greedy` `implementation` `strings` `*1500`	Mar/13/2023 22:30
582	B - A Perfectly Balanced String?	GNU C++20 (64)	`brute force` `greedy` `strings` `*1100`	Mar/12/2023 22:13
581	A - Reachable Numbers	GNU C++20 (64)	`implementation` `*1100`	Mar/12/2023 00:03
580	B - Long Number	GNU C++20 (64)	`greedy` `*1300`	Mar/11/2023 22:26
579	A - 2Char	GNU C++20 (64)	`brute force` `implementation` `*1200`	Mar/11/2023 02:09
578	C - awoo's Favorite Problem	GNU C++20 (64)	`binary search` `constructive algorithms` `data structures` `greedy` `implementation` `strings` `two pointers` `*1400`	Mar/10/2023 02:47
577	B - Settlement of Guinea Pigs	GNU C++20 (64)	`greedy` `implementation` `math` `*1000`	Mar/09/2023 22:31
576	A - Likes	GNU C++20 (64)	`greedy` `implementation` `*800`	Mar/09/2023 21:46
575	B - File Name	GNU C++20 (64)	`greedy` `strings` `*800`	Mar/09/2023 17:59
574	A - Snacktower	GNU C++20 (64)	`data structures` `implementation` `*1100`	Mar/09/2023 17:28
573	B - Letter	GNU C++20 (64)	`implementation` `strings` `*1100`	Mar/09/2023 16:36
572	B - Chocolate	GNU C++20 (64)	`combinatorics` `*1300`	Mar/09/2023 02:03
571	C - A-B Palindrome	GNU C++20 (64)	`constructive algorithms` `implementation` `strings` `*1200`	Mar/09/2023 00:49
570	D - Corrupted Array	GNU C++20 (64)	`constructive algorithms` `data structures` `greedy` `*1200`	Mar/08/2023 21:55
569	A - Subtle Substring Subtraction	GNU C++20 (64)	`games` `greedy` `strings` `*800`	Mar/07/2023 20:14
568	C - Perform the Combo	GNU C++20 (64)	`brute force` `*1300`	Mar/06/2023 16:30
567	B - Numbers Box	GNU C++20 (64)	`greedy` `math` `*1000`	Mar/06/2023 02:25
566	A - Prefix and Suffix Array	GNU C++17	`strings` `*800`	Mar/05/2023 02:25
565	B - Not Dividing	GNU C++17	`constructive algorithms` `greedy` `math` `*900`	Mar/05/2023 02:18
564	B - Present from Lena	GNU C++17	`constructive algorithms` `implementation` `*1000`	Mar/04/2023 22:52
563	A - Dungeon	GNU C++17	`binary search` `math` `*1100`	Mar/04/2023 03:38
562	F - Range Update Point Query	GNU C++17	`binary search` `brute force` `data structures` `*1500`	Mar/03/2023 21:20
561	A - Is It a Cat?	GNU C++17	`implementation` `strings` `*800`	Mar/03/2023 19:02
560	D - Remove Two Letters	GNU C++17	`data structures` `greedy` `hashing` `strings` `*1200`	Mar/02/2023 23:22
559	C2 - Powering the Hero (hard version)	GNU C++17	`data structures` `greedy` `*1100`	Mar/02/2023 21:28
558	C1 - Powering the Hero (easy version)	GNU C++17	`data structures` `greedy` `*1000`	Mar/02/2023 21:27
557	B - Count the Number of Pairs	GNU C++17	`greedy` `strings` `*1000`	Mar/02/2023 21:13
556	A - Two Substrings	GNU C++17	`brute force` `dp` `greedy` `implementation` `strings` `*1500`	Mar/02/2023 00:03
555	A - Recent Actions	GNU C++17	`data structures` `greedy` `implementation` `math` `*800`	Mar/01/2023 02:36
554	B - Asterisk-Minor Template	GNU C++17	`implementation` `strings` `*1000`	Feb/28/2023 21:08
553	A - Typical Interview Problem	GNU C++17	`brute force` `implementation` `strings` `*800`	Feb/28/2023 20:49
552	A - Boredom	GNU C++17	`dp` `*1500`	Feb/28/2023 01:54
551	C - Serval and Toxel's Arrays	GNU C++17	`combinatorics` `dp` `implementation` `math` `*1500`	Feb/27/2023 01:19
550	B - Serval and Inversion Magic	GNU C++17	`brute force` `implementation` `strings` `two pointers` `*800`	Feb/26/2023 02:46
549	A - Boys and Girls	GNU C++17	`greedy` `*1100`	Feb/25/2023 00:02
548	A - Shuffle Hashing	GNU C++17	`brute force` `implementation` `strings` `*1000`	Feb/24/2023 00:59
547	B - Turn the Rectangles	GNU C++17	`greedy` `sortings` `*1000`	Feb/23/2023 23:36
546	B - Longest Palindrome	GNU C++17	`brute force` `constructive algorithms` `greedy` `implementation` `strings` `*1100`	Feb/23/2023 16:28
545	B - Balancer	GNU C++17	`greedy` `implementation` `*1600`	Feb/23/2023 00:12
544	B - Hungry Sequence	GNU C++17	`math` `*1200`	Feb/22/2023 22:35
543	A - Round House	GNU C++17	`implementation` `math` `*1000`	Feb/22/2023 03:23
542	A - Minutes Before the New Year	GNU C++17	`math` `*800`	Feb/21/2023 23:08
541	B - Powers of Two	GNU C++17	`brute force` `data structures` `implementation` `math` `*1500`	Feb/20/2023 02:53
540	B - Frog 2	C++ (GCC 9.2.1)	`AtCoder` `*100`	Feb/19/2023 23:43
539	A - Frog 1	C++ (GCC 9.2.1)	`AtCoder` `*100`	Feb/19/2023 23:33
538	A - Construct a Rectangle	GNU C++17	`geometry` `math` `*800`	Feb/19/2023 03:46
537	A - Classroom Watch	GNU C++17	`brute force` `math` `*1200`	Feb/19/2023 03:17
536	A - Odd Selection	GNU C++17	`brute force` `implementation` `math` `*1200`	Feb/18/2023 23:43
535	A - Numbers	GNU C++17	`implementation` `math` `*1000`	Feb/17/2023 02:21
534	B - Ideal Point	GNU C++17	`brute force` `geometry` `greedy` `*900`	Feb/16/2023 21:22
533	A - Two Towers	GNU C++17	`brute force` `implementation` `strings` `*800`	Feb/16/2023 20:48
532	C - Number of Pairs	GNU C++17	`binary search` `data structures` `math` `two pointers` `*1300`	Feb/16/2023 19:34
531	A - Digits Sum	GNU C++17	`math` `number theory` `*800`	Feb/15/2023 20:42
530	B - String LCM	GNU C++17	`brute force` `math` `number theory` `strings` `*1000`	Feb/14/2023 21:30
529	B - Caisa and Pylons	GNU C++17	`brute force` `implementation` `math` `*1100`	Feb/13/2023 21:57
528	G1 - Teleporters (Easy Version)	GNU C++17	`greedy` `sortings` `*1100`	Feb/12/2023 21:45
527	A - Stone Game	GNU C++17	`brute force` `dp` `greedy` `*800`	Feb/11/2023 01:04
526	C - Matching Numbers	GNU C++17	`constructive algorithms` `greedy` `math` `*1300`	Feb/10/2023 14:58
525	B - Sum of Two Numbers	GNU C++17	`constructive algorithms` `greedy` `implementation` `math` `probabilities` `*1100`	Feb/10/2023 01:13
524	A - One and Two	GNU C++17	`brute force` `implementation` `math` `*800`	Feb/09/2023 23:24
523	B - Phoenix and Puzzle	GNU C++17	`brute force` `geometry` `math` `number theory` `*1000`	Feb/09/2023 14:07
522	B - Rooms and Staircases	GNU C++17	`brute force` `implementation` `*1000`	Feb/08/2023 22:44
521	B - Dreamoon Likes Permutations	GNU C++17	`implementation` `math` `*1400`	Feb/07/2023 21:57
520	A - Counterexample	GNU C++17	`brute force` `implementation` `math` `number theory` `*1100`	Feb/06/2023 01:55
519	A - Parallelepiped	GNU C++17	`brute force` `geometry` `math` `*1100`	Feb/05/2023 23:19
518	D - Distinct Split	GNU C++17	`brute force` `greedy` `strings` `*1000`	Feb/04/2023 01:07
517	E - Negatives and Positives	GNU C++17	`dp` `greedy` `sortings` `*1100`	Feb/03/2023 22:41
516	C - Prepend and Append	GNU C++17	`implementation` `two pointers` `*800`	Feb/03/2023 20:56
515	B - Following Directions	GNU C++17	`geometry` `implementation` `*800`	Feb/03/2023 20:48
514	A - Codeforces Checking	GNU C++17	`implementation` `strings` `*800`	Feb/03/2023 20:37
513	B - Anti-Fibonacci Permutation	GNU C++17	`brute force` `constructive algorithms` `implementation` `*800`	Feb/02/2023 22:26
512	A - Doors and Keys	GNU C++17	`implementation` `*800`	Feb/02/2023 21:33
511	C - Building Permutation	GNU C++17	`greedy` `implementation` `sortings` `*1200`	Feb/02/2023 20:54
510	B - Divisors of Two Integers	GNU C++17	`brute force` `greedy` `math` `number theory` `*1100`	Feb/02/2023 01:42
509	A - Flip Flop Sum	GNU C++17	`greedy` `implementation` `*800`	Feb/01/2023 20:43
508	B - President's Office	GNU C++17	`implementation` `*1100`	Feb/01/2023 01:12
507	B - Binary Period	GNU C++17	`constructive algorithms` `strings` `*1100`	Jan/31/2023 20:09
506	A - Candies	GNU C++17	`brute force` `math` `*900`	Jan/30/2023 21:31
505	B - Reverse String	GNU C++17	`brute force` `dp` `hashing` `implementation` `strings` `*1300`	Jan/30/2023 20:34
504	A - Love "A"	GNU C++17	`implementation` `strings` `*800`	Jan/30/2023 01:23
503	A - Spy Detected!	GNU C++17	`brute force` `implementation` `*800`	Jan/30/2023 01:10
502	B - Vlad and Candies	GNU C++17	`math` `*800`	Jan/29/2023 23:49
501	C - Premutation	GNU C++17	`brute force` `implementation` `math` `*1000`	Jan/28/2023 00:51
500	B - Taisia and Dice	GNU C++17	`greedy` `greedy` `math` `*800`	Jan/27/2023 21:26
499	A - Polycarp and the Day of Pi	GNU C++17	`implementation` `math` `strings` `*800`	Jan/27/2023 20:47
498	M - The Pleasant Walk	GNU C++17	`implementation` `*1000`	Jan/27/2023 02:35
497	A - Comparing Strings	GNU C++17	`implementation` `strings` `*1100`	Jan/26/2023 01:42
496	A - Reorder	GNU C++17	`math` `*800`	Jan/26/2023 01:02
495	B - GCD Partition	GNU C++17	`brute force` `greedy` `math` `number theory` `*1100`	Jan/25/2023 21:44
494	A - Hayato and School	GNU C++17	`constructive algorithms` `greedy` `*800`	Jan/25/2023 21:19
493	A - GamingForces	GNU C++17	`greedy` `sortings` `*800`	Jan/24/2023 20:42
492	A - Home Numbers	GNU C++17	`special problem` `constructive algorithms` `math` `1100`	Jan/24/2023 20:05
491	C - Product of Three Numbers	GNU C++17	`greedy` `math` `number theory` `*1300`	Jan/23/2023 21:49
490	F - Eating Candies	GNU C++17	`binary search` `data structures` `greedy` `two pointers` `*1100`	Jan/22/2023 18:49
489	A - Digit Game	GNU C++17	`games` `greedy` `implementation` `*900`	Jan/21/2023 23:57
488	A - Equidistant Letters	GNU C++17	`constructive algorithms` `sortings` `*800`	Jan/20/2023 00:57
487	B - Minor Reduction	GNU C++17	`greedy` `strings` `*1100`	Jan/20/2023 00:50
486	E - Eating Queries	GNU C++17	`binary search` `greedy` `sortings` `*1100`	Jan/19/2023 00:40
485	B - Phone numbers	GNU C++17	`implementation` `*1100`	Jan/18/2023 02:34
484	A - k-th divisor	GNU C++17	`math` `number theory` `*1400`	Jan/17/2023 01:05
483	B - Center Alignment	GNU C++17	`implementation` `strings` `*1200`	Jan/16/2023 19:00
482	E - 2-Letter Strings	GNU C++17	`data structures` `math` `strings` `*1200`	Jan/16/2023 15:04
481	C - Woodcutters	Python 3	`dp` `greedy` `*1500`	Jan/15/2023 01:02
480	D - Double Strings	GNU C++17	`brute force` `data structures` `strings` `*1100`	Jan/14/2023 17:50
479	D - Absolute Sorting	GNU C++17	`constructive algorithms` `math` `*1400`	Jan/14/2023 16:00
478	D - Number into Sequence	GNU C++17	`constructive algorithms` `math` `number theory` `*1300`	Jan/13/2023 18:25
477	A - Joysticks	GNU C++17	`dp` `greedy` `implementation` `math` `*1100`	Jan/13/2023 04:07
476	A - Worms Evolution	GNU C++17	`implementation` `*1200`	Jan/12/2023 01:49
475	B - Bad Prices	GNU C++17	`data structures` `implementation` `*1100`	Jan/11/2023 02:08
474	B - Little Pony and Sort by Shift	GNU C++17	`implementation` `*1200`	Jan/10/2023 21:53
473	A2 - Gardener and the Capybaras (hard version)	GNU C++17	`constructive algorithms` `greedy` `*900`	Jan/10/2023 20:47
472	A1 - Gardener and the Capybaras (easy version)	GNU C++17	`brute force` `constructive algorithms` `implementation` `*800`	Jan/10/2023 20:46
471	C - Letters Cyclic Shift	GNU C++17	`greedy` `strings` `*1200`	Jan/09/2023 00:38
470	A - Juicer	GNU C++17	`implementation` `*900`	Jan/09/2023 00:09
469	A - AB Balance	GNU C++17	`strings` `*900`	Jan/08/2023 23:37
468	B - Matrix of Differences	GNU C++17	`constructive algorithms` `math` `*1100`	Jan/08/2023 22:27
467	A - Make it Beautiful	GNU C++17	`constructive algorithms` `math` `sortings` `*800`	Jan/08/2023 21:18
466	D - Queue	GNU C++17	`greedy` `implementation` `sortings` `*1300`	Jan/08/2023 19:40
465	B - Sort the Array	GNU C++17	`implementation` `sortings` `*1300`	Jan/07/2023 21:15
464	B - Quick Sort	GNU C++17	`greedy` `math` `*900`	Jan/06/2023 21:29
463	A - Greatest Convex	GNU C++17	`greedy` `math` `number theory` `*800`	Jan/06/2023 01:12
462	B - Groups	GNU C++17	`brute force` `implementation` `*1000`	Jan/05/2023 02:15
461	A - Cherry	GNU C++17	`greedy` `*800`	Jan/04/2023 02:19
460	A - Hall of Fame	GNU C++17	`constructive algorithms` `greedy` `strings` `*800`	Jan/04/2023 01:39
459	B - MKnez's ConstructiveForces Task	GNU C++17	`constructive algorithms` `math` `*900`	Jan/03/2023 21:40
458	B - Kill Demodogs	Python 3	`greedy` `math` `*1100`	Jan/02/2023 23:31
457	A - Vasya and Coins	Python 3	`greedy` `math` `*800`	Jan/02/2023 20:36
456	A - Cutting Banner	GNU C++17	`brute force` `implementation` `*1400`	Jan/01/2023 21:39
455	A - Problem About Equation	GNU C++17	`math` `*1100`	Jan/01/2023 19:35
454	A - Fair Game	GNU C++17	`implementation` `sortings` `*1000`	Jan/01/2023 01:28
453	E - Exchange	GNU C++17	`brute force` `math` `*1000`	Dec/31/2022 23:17
452	C - Koxia and Number Theory	GNU C++17	`brute force` `chinese remainder theorem` `math` `number theory` `*1700`	Dec/31/2022 23:02
451	A - Koxia and Whiteboards	GNU C++17	`brute force` `greedy` `*1000`	Dec/31/2022 18:46
450	B - Koxia and Permutation	GNU C++17	`constructive algorithms` `*1000`	Dec/30/2022 22:07
449	B - Mirror in the String	GNU C++17	`greedy` `strings` `*1100`	Dec/30/2022 19:51
448	B - GCD Length	GNU C++17	`constructive algorithms` `math` `number theory` `*1100`	Dec/30/2022 18:08
447	B - Sequential Nim	GNU C++17	`dp` `games` `*1100`	Dec/30/2022 16:24
446	B - T-shirts from Sponsor	GNU C++17	`implementation` `*1100`	Dec/30/2022 00:39
445	A - Carpeting the Room	Pike	`special problem` `implementation` `1100`	Dec/29/2022 22:01
444	B - Polycarp and Letters	GNU C++17	`brute force` `implementation` `strings` `*1000`	Dec/28/2022 23:08
443	A - Johny Likes Numbers	GNU C++17	`implementation` `math` `*800`	Dec/28/2022 22:40
442	A - Sweet Problem	GNU C++17	`math` `*1100`	Dec/28/2022 02:33
441	C - Songs Compression	GNU C++17	`sortings` `*1100`	Dec/28/2022 01:10
440	A - Little Elephant and Bits	GNU C++17	`greedy` `math` `*1100`	Dec/28/2022 00:49
439	A - Joey Takes Money	GNU C++17	`greedy` `math` `*800`	Dec/27/2022 20:43
438	A - Maximum Increase	GNU C++17	`dp` `greedy` `implementation` `*800`	Dec/27/2022 01:36
437	A - Cinema Line	GNU C++17	`greedy` `implementation` `*1100`	Dec/27/2022 01:15
436	A - IQ Test	GNU C++17	`brute force` `implementation` `*1100`	Dec/27/2022 00:46
435	B - Substrings Sort	GNU C++17	`sortings` `strings` `*1100`	Dec/26/2022 23:48
434	C - Similar Pairs	GNU C++17	`constructive algorithms` `graph matchings` `greedy` `sortings` `*1100`	Dec/26/2022 22:45
433	C - Sum of Cubes	GNU C++17	`binary search` `brute force` `brute force` `math` `*1100`	Dec/26/2022 20:25
432	B - Fedor and New Game	GNU C++17	`bitmasks` `brute force` `constructive algorithms` `implementation` `*1100`	Dec/26/2022 00:33
431	A - Sum of Odd Integers	GNU C++17	`math` `*1100`	Dec/25/2022 20:21
430	B - Perfect Number	GNU C++17	`binary search` `brute force` `dp` `implementation` `number theory` `*1100`	Dec/25/2022 19:11
429	B - A and B and Compilation Errors	GNU C++17	`data structures` `implementation` `sortings` `*1100`	Dec/25/2022 13:51
428	B - Sereja and Suffixes	GNU C++17	`data structures` `dp` `*1100`	Dec/25/2022 01:56
427	A - XOR Mixup	GNU C++17	`bitmasks` `brute force` `*800`	Dec/24/2022 20:58
426	B - z-sort	GNU C++17	`sortings` `*1000`	Dec/24/2022 16:44
425	M - Weather Tomorrow	GNU C++17	`implementation` `math` `*1000`	Dec/24/2022 04:45
424	B - Shopping	GNU C++17	`brute force` `*1400`	Dec/24/2022 03:35
423	B - Fair Division	GNU C++17	`dp` `greedy` `math` `*800`	Dec/24/2022 03:05
422	A - Elevator	GNU C++17	`brute force` `implementation` `math` `*1000`	Dec/24/2022 02:14
421	A - Eevee	GNU C++17	`brute force` `implementation` `strings` `*1000`	Dec/24/2022 01:32
420	A - Odds and Ends	GNU C++17	`implementation` `*1000`	Dec/24/2022 00:26
419	A - Minimum Integer	GNU C++17	`math` `*1000`	Dec/24/2022 00:03
418	A - Div. 64	GNU C++17	`implementation` `*1000`	Dec/23/2022 21:00
417	A - Santa Claus and Candies	GNU C++17	`dp` `greedy` `math` `*1000`	Dec/22/2022 22:15
416	A - Infinite Sequence	GNU C++17	`implementation` `math` `*1000`	Dec/22/2022 20:52
415	B - Make it Divisible by 25	GNU C++17	`dfs and similar` `dp` `greedy` `math` `math` `*900`	Dec/22/2022 10:12
414	D - Black and White Stripe	GNU C++17	`implementation` `two pointers` `*1000`	Dec/22/2022 05:28
413	C - Dominant Piranha	GNU C++17	`constructive algorithms` `greedy` `*900`	Dec/22/2022 04:50
412	C - Given Length and Sum of Digits...	GNU C++17	`dp` `greedy` `implementation` `*1400`	Dec/22/2022 00:58
411	A - Balanced Rating Changes	GNU C++17	`implementation` `math` `*1000`	Dec/21/2022 21:58
410	A - Broken Keyboard	GNU C++17	`brute force` `strings` `two pointers` `*1000`	Dec/21/2022 20:34
409	A - Superhero Transformation	GNU C++17	`implementation` `strings` `*1000`	Dec/21/2022 20:17
408	A - 2048 Game	GNU C++17	`brute force` `greedy` `math` `*1000`	Dec/21/2022 19:30
407	A - Magic Numbers	GNU C++17	`brute force` `greedy` `*900`	Dec/21/2022 04:41
406	B - Digital root	GNU C++17	`math` `number theory` `*1000`	Dec/21/2022 04:18
405	B - Permutation	GNU C++17	`greedy` `*1000`	Dec/21/2022 04:01
404	B - Valerii Against Everyone	GNU C++17	`constructive algorithms` `data structures` `greedy` `sortings` `*1000`	Dec/21/2022 03:26
403	A - Circle of Students	GNU C++17	`implementation` `*1000`	Dec/21/2022 00:19
402	A - Reverse a Substring	GNU C++17	`implementation` `sortings` `strings` `*1000`	Dec/20/2022 23:41
401	C - Two Shuffled Sequences	GNU C++17	`constructive algorithms` `sortings` `*1000`	Dec/20/2022 21:45
400	B - Burglar and Matches	GNU C++17	`greedy` `implementation` `sortings` `*900`	Dec/20/2022 01:37
399	C - Double-ended Strings	GNU C++17	`brute force` `implementation` `strings` `*1000`	Dec/19/2022 22:03
398	A - Absolute Maximization	GNU C++17	`bitmasks` `constructive algorithms` `greedy` `math` `*800`	Dec/19/2022 21:07
397	A - Gotta Catch Em' All!	GNU C++17	`implementation` `*1000`	Dec/19/2022 03:57
396	B - Matrix Rotation	GNU C++17	`brute force` `implementation` `*800`	Dec/18/2022 21:02
395	A - A+B?	GNU C++17	`implementation` `*800`	Dec/18/2022 20:38
394	B - Relatively Prime Pairs	GNU C++17	`greedy` `math` `number theory` `*1000`	Dec/18/2022 19:16
393	A - Find Amir	GNU C++17	`constructive algorithms` `greedy` `math` `*1000`	Dec/18/2022 14:58
392	B - Magic Stick	GNU C++17	`math` `*1000`	Dec/18/2022 14:33
391	A - Add Plus Minus Sign	GNU C++17	`constructive algorithms` `math` `*800`	Dec/18/2022 02:29
390	A - Drazil and Date	GNU C++17	`math` `*1000`	Dec/17/2022 19:20
389	B - Water Lily	GNU C++17	`geometry` `math` `*1000`	Dec/17/2022 19:01
388	B - Block Towers	GNU C++17	`data structures` `greedy` `sortings` `*800`	Dec/16/2022 23:05
387	A - Cut the Triangle	GNU C++17	`implementation` `*800`	Dec/16/2022 21:57
386	A - Bar	GNU C++17	`implementation` `*1000`	Dec/16/2022 19:58
385	C - Move Brackets	GNU C++17	`greedy` `strings` `*1000`	Dec/16/2022 17:09
384	B - Make Array Good	GNU C++17	`constructive algorithms` `implementation` `number theory` `sortings` `*1100`	Dec/16/2022 16:51
383	A - 123-sequence	GNU C++17	`implementation` `*900`	Dec/16/2022 05:45
382	A - Contest	GNU C++17	`implementation` `*900`	Dec/16/2022 04:59
381	A - Game	GNU C++17	`constructive algorithms` `math` `*800`	Dec/16/2022 04:47
380	A - Duff and Meat	GNU C++17	`greedy` `*900`	Dec/16/2022 04:41
379	A - Interview	GNU C++17	`brute force` `implementation` `*900`	Dec/16/2022 04:18
378	A - Again Twenty Five!	GNU C++17	`number theory` `*800`	Dec/16/2022 03:57
377	A - Complicated GCD	GNU C++17	`math` `number theory` `*800`	Dec/16/2022 03:50
376	A - Bear and Game	GNU C++17	`implementation` `*800`	Dec/16/2022 03:38
375	A - Divide and Conquer	GNU C++17	`greedy` `math` `number theory` `*800`	Dec/16/2022 00:11
374	B - Ania and Minimizing	GNU C++17	`greedy` `implementation` `*1000`	Dec/15/2022 03:25
373	C - A and B and Team Training	GNU C++17	`greedy` `implementation` `math` `number theory` `*1300`	Dec/15/2022 02:29
372	B - Absent Remainder	GNU C++17	`greedy` `implementation` `sortings` `*1000`	Dec/14/2022 21:52
371	B - New Colony	GNU C++17	`brute force` `greedy` `implementation` `*1100`	Dec/14/2022 00:30
370	D - Decrease the Sum of Digits	GNU C++17	`greedy` `math` `*1500`	Dec/13/2022 02:32
369	B - Notepad#	GNU C++17	`implementation` `*1000`	Dec/12/2022 22:42
368	A - Extremely Round	GNU C++17	`brute force` `implementation` `*800`	Dec/12/2022 21:35
367	B - Balanced Array	GNU C++17	`constructive algorithms` `math` `*800`	Dec/11/2022 23:59
366	A - Hossam and Combinatorics	GNU C++17	`combinatorics` `math` `sortings` `*900`	Dec/11/2022 22:24
365	A - Candy Bags	GNU C++17	`implementation` `*1000`	Dec/10/2022 21:54
364	B - Card Constructions	GNU C++17	`binary search` `brute force` `dp` `math` `*1100`	Dec/09/2022 03:16
363	A - Initial Bet	GNU C++17	`implementation` `*1100`	Dec/09/2022 01:36
362	A - Flipping Game	GNU C++17	`brute force` `dp` `implementation` `*1200`	Dec/09/2022 01:20
361	A - Dreamoon and Stairs	GNU C++17	`implementation` `math` `*1000`	Dec/08/2022 22:10
360	B - Coins	GNU C++17	`implementation` `*1200`	Dec/08/2022 03:11
359	A - Punctuation	GNU C++17	`implementation` `strings` `*1300`	Dec/07/2022 14:19
358	B - BerSU Ball	GNU C++17	`dfs and similar` `dp` `graph matchings` `greedy` `sortings` `two pointers` `*1200`	Dec/07/2022 02:25
357	A - Birthday	GNU C++17	`math` `*1400`	Dec/06/2022 21:16
356	A - Serval and Bus	GNU C++17	`brute force` `math` `*1000`	Dec/05/2022 21:44
355	B - MIN-MEX Cut	GNU C++17	`bitmasks` `constructive algorithms` `dp` `greedy` `*800`	Dec/05/2022 03:30
354	A - Computer Game	GNU C++17	`brute force` `dfs and similar` `dp` `implementation` `*800`	Dec/05/2022 02:49
353	A - Two Subsequences	GNU C++17	`implementation` `*800`	Dec/05/2022 02:35
352	B - Woeful Permutation	GNU C++17	`constructive algorithms` `greedy` `number theory` `*800`	Dec/05/2022 02:22
351	B - Array Decrements	GNU C++17	`greedy` `implementation` `*800`	Dec/05/2022 01:56
350	A - Another String Minimization Problem	GNU C++17	`2-sat` `constructive algorithms` `greedy` `string suffix structures` `strings` `*800`	Dec/05/2022 00:47
349	B - Young Explorers	GNU C++17	`dp` `greedy` `sortings` `*1200`	Dec/04/2022 22:27
348	D - Game With Array	GNU C++17	`constructive algorithms` `math` `*1400`	Dec/04/2022 20:46
347	C - Everyone is a Winner!	GNU C++17	`binary search` `math` `meet-in-the-middle` `number theory` `*1400`	Dec/04/2022 19:45
346	B - Almost Ternary Matrix	GNU C++17	`bitmasks` `constructive algorithms` `matrices` `*900`	Dec/04/2022 18:19
345	A - Dislike of Threes	GNU C++17	`implementation` `*800`	Dec/04/2022 00:54
344	B - Who's Opposite?	GNU C++17	`math` `*800`	Dec/04/2022 00:30
343	B - Ilya and Queries	GNU C++17	`dp` `implementation` `*1100`	Dec/03/2022 21:25
342	B - Buttons	GNU C++17	`implementation` `math` `*1000`	Dec/03/2022 00:15
341	B - Mahmoud and a Triangle	GNU C++17	`constructive algorithms` `geometry` `greedy` `math` `number theory` `sortings` `*1000`	Dec/02/2022 23:57
340	A - NIT orz!	GNU C++17	`bitmasks` `greedy` `*800`	Dec/02/2022 14:35
339	A - Parkway Walk	GNU C++17	`greedy` `implementation` `*800`	Dec/02/2022 03:22
338	B - Best Permutation	GNU C++17	`constructive algorithms` `greedy` `*800`	Dec/02/2022 03:10
337	C - Restoring the Duration of Tasks	GNU C++17	`data structures` `greedy` `implementation` `*800`	Dec/02/2022 02:22
336	A - Beat The Odds	GNU C++17	`brute force` `greedy` `math` `*800`	Dec/02/2022 01:55
335	C - Where's the Bishop?	GNU C++17	`implementation` `*800`	Dec/02/2022 01:25
334	B - Doremy's Perfect Math Class	GNU C++17	`math` `number theory` `*900`	Dec/02/2022 00:54
333	A - Mainak and Array	GNU C++17	`greedy` `math` `*900`	Dec/01/2022 23:40
332	A - Division	GNU C++17	`brute force` `math` `number theory` `*1500`	Dec/01/2022 16:14
331	A - Single Push	GNU C++17	`implementation` `*1000`	Nov/30/2022 23:18
330	B - Two Buttons	GNU C++17	`dfs and similar` `graphs` `greedy` `implementation` `math` `shortest paths` `*1400`	Nov/30/2022 21:56
329	B - Queries on a String	GNU C++17	`implementation` `strings` `*1300`	Nov/30/2022 17:44
328	A - Divide and Multiply	GNU C++17	`greedy` `implementation` `math` `number theory` `*900`	Nov/30/2022 14:01
327	A - Tricky Sum	GNU C++17	`math` `*900`	Nov/29/2022 22:36
326	B - Broken Keyboard	GNU C++17	`greedy` `*800`	Nov/28/2022 18:06
325	M - Minimum LCM	GNU C++17	`math` `number theory` `*1000`	Nov/27/2022 22:42
324	B - Same Parity Summands	GNU C++17	`constructive algorithms` `math` `*1200`	Nov/27/2022 20:21
323	B - Pashmak and Flowers	GNU C++17	`combinatorics` `implementation` `sortings` `*1300`	Nov/26/2022 02:14
322	B - XOR = Average	GNU C++17	`constructive algorithms` `*900`	Nov/25/2022 22:50
321	A - SSeeeeiinngg DDoouubbllee	GNU C++17	`constructive algorithms` `strings` `*800`	Nov/25/2022 21:40
320	C - Cypher	GNU C++17	`brute force` `implementation` `strings` `*800`	Nov/25/2022 21:06
319	A - Triangle	GNU C++17	`brute force` `geometry` `*900`	Nov/25/2022 20:27
318	B - I Hate 1111	GNU C++17	`dp` `math` `number theory` `*1400`	Nov/25/2022 18:16
317	A - Glory Addicts	GNU C++17	`greedy` `implementation` `sortings` `*800`	Nov/25/2022 14:57
316	A - Donut Shops	GNU C++17	`greedy` `implementation` `math` `*1000`	Nov/24/2022 19:54
315	A - Select Three Sticks	GNU C++17	`brute force` `greedy` `sortings` `*800`	Nov/24/2022 16:32
314	C - Minimum Varied Number	GNU C++17	`greedy` `*800`	Nov/24/2022 16:14
313	B - Tea with Tangerines	GNU C++17	`greedy` `math` `*900`	Nov/24/2022 15:58
312	B - Bright, Nice, Brilliant	GNU C++17	`constructive algorithms` `*800`	Nov/24/2022 13:56
311	B - Permutation Value	GNU C++17	`constructive algorithms` `greedy` `*800`	Nov/24/2022 13:28
310	A - Almost Prime	GNU C++17	`number theory` `*900`	Nov/24/2022 12:47
309	A - Red and Blue Beans	GNU C++17	`math` `*800`	Nov/24/2022 12:06
308	A - I'm bored with life	GNU C++17	`implementation` `math` `number theory` `*800`	Nov/24/2022 00:12
307	B - Yet Another Bookshelf	GNU C++17	`greedy` `implementation` `*800`	Nov/23/2022 23:42
306	A - Gregor and Cryptography	GNU C++17	`math` `number theory` `*800`	Nov/23/2022 23:31
305	A - Yes-Yes?	GNU C++17	`implementation` `strings` `*800`	Nov/23/2022 19:43
304	E - Binary Inversions	GNU C++17	`data structures` `greedy` `math` `*1100`	Nov/22/2022 13:03
303	B - Even-Odd Increments	GNU C++17	`implementation` `math` `*800`	Nov/22/2022 02:24
302	C - Traffic Light	GNU C++17	`binary search` `implementation` `two pointers` `*1000`	Nov/22/2022 01:47
301	D - Challenging Valleys	GNU C++17	`implementation` `two pointers` `*1000`	Nov/21/2022 21:47
300	C - Advantage	GNU C++17	`data structures` `implementation` `sortings` `*800`	Nov/21/2022 21:09
299	B - Atilla's Favorite Problem	GNU C++17	`greedy` `implementation` `strings` `*800`	Nov/21/2022 20:54
298	A - Medium Number	GNU C++17	`implementation` `sortings` `*800`	Nov/21/2022 20:37
297	D - Coprime	GNU C++17	`brute force` `greedy` `number theory` `*1100`	Nov/21/2022 16:52
296	B - Elimination of a Ring	GNU C++17	`constructive algorithms` `greedy` `implementation` `*1000`	Nov/20/2022 23:01
295	A - Two Permutations	GNU C++17	`brute force` `constructive algorithms` `*800`	Nov/20/2022 22:54
294	C - Zero-Sum Prefixes	GNU C++17	`brute force` `data structures` `dp` `greedy` `implementation` `*1600`	Nov/20/2022 16:42
293	A - Sereja and Dima	GNU C++17	`greedy` `implementation` `two pointers` `*800`	Nov/20/2022 13:04
292	A - Creep	GNU C++17	`greedy` `implementation` `*800`	Nov/20/2022 01:47
291	C - Lucky Numbers	GNU C++17	`combinatorics` `math` `*1100`	Nov/20/2022 00:49
290	B - Moore's Law	GNU C++17	`math` `*1200`	Nov/20/2022 00:02
289	A - Distance and Axis	GNU C++17	`constructive algorithms` `math` `*900`	Nov/19/2022 15:06
288	A - AvtoBus	GNU C++17	`brute force` `greedy` `math` `number theory` `*900`	Nov/19/2022 12:22
287	B - Lost Permutation	GNU C++17	`math` `*800`	Nov/19/2022 00:30
286	A - Laptops	GNU C++17	`sortings` `*1100`	Nov/18/2022 19:32
285	B - Diverse Substrings	GNU C++17	`brute force` `implementation` `strings` `*1400`	Nov/18/2022 19:08
284	A - Wet Shark and Odd and Even	GNU C++17	`implementation` `*900`	Nov/18/2022 13:56
283	C - Alternating Subsequence	GNU C++17	`dp` `greedy` `two pointers` `*1200`	Nov/18/2022 02:17
282	B - Lecture	GNU C++17	`implementation` `strings` `*1000`	Nov/18/2022 00:09
281	B - Kuriyama Mirai's Stones	GNU C++17	`dp` `implementation` `sortings` `*1200`	Nov/17/2022 23:11
280	A - Arpa’s hard exam and Mehrdad’s naive cheat	GNU C++17	`implementation` `math` `number theory` `*1000`	Nov/17/2022 19:21
279	B - Ela's Fitness and the Luxury Number	GNU C++17	`binary search` `implementation` `math` `*1300`	Nov/17/2022 00:58
278	B - NIT Destroys the Universe	GNU C++17	`greedy` `*900`	Nov/16/2022 01:24
277	A - A and B and Chess	GNU C++17	`implementation` `*900`	Nov/16/2022 00:07
276	A - Lineland Mail	GNU C++17	`greedy` `implementation` `*900`	Nov/15/2022 19:10
275	A - Elections	GNU C++17	`math` `*800`	Nov/15/2022 16:33
274	D - Buying Shovels	GNU C++17	`math` `number theory` `*1300`	Nov/14/2022 06:13
273	A - Olesya and Rodion	GNU C++17	`math` `*1000`	Nov/14/2022 04:53
272	A - Double Cola	GNU C++17	`implementation` `math` `*1100`	Nov/14/2022 03:58
271	B - Worms	GNU C++17	`binary search` `implementation` `*1200`	Nov/14/2022 02:43
270	A - Three Friends	GNU C++17	`brute force` `greedy` `math` `sortings` `*900`	Nov/14/2022 02:09
269	B - Fence	GNU C++17	`brute force` `dp` `*1100`	Nov/14/2022 00:43
268	B - New Year's Number	GNU C++17	`brute force` `dp` `math` `*900`	Nov/13/2022 22:50
267	A - Mike and palindrome	GNU C++17	`brute force` `constructive algorithms` `strings` `*1000`	Nov/13/2022 22:34
266	C - Even Number Addicts	GNU C++17	`dp` `games` `greedy` `math` `*1500`	Nov/13/2022 20:55
265	E - Scuza	GNU C++17	`binary search` `greedy` `math` `*1200`	Nov/13/2022 19:23
264	A - The Ultimate Square	GNU C++17	`math` `*800`	Nov/12/2022 20:46
263	A - Towers	GNU C++17	`sortings` `*1000`	Nov/12/2022 04:54
262	A - Life Without Zeros	GNU C++17	`implementation` `*1000`	Nov/12/2022 04:42
261	D - Same Differences	GNU C++17	`data structures` `hashing` `math` `*1200`	Nov/12/2022 01:18
260	B - Text Document Analysis	GNU C++17	`expression parsing` `implementation` `strings` `*1100`	Nov/12/2022 00:05
259	B - Random Teams	GNU C++17	`combinatorics` `constructive algorithms` `greedy` `math` `*1300`	Nov/11/2022 22:25
258	A - Free Cash	GNU C++17	`implementation` `*1000`	Nov/11/2022 17:31
257	A - Ela Sorting Books	GNU C++17	`greedy` `implementation` `strings` `*900`	Nov/11/2022 03:49
256	A - Required Remainder	GNU C++17	`math` `*800`	Nov/10/2022 04:33
255	C - K-th Not Divisible by n	GNU C++17	`binary search` `math` `*1200`	Nov/10/2022 03:14
254	A - Fancy Fence	GNU C++17	`geometry` `implementation` `math` `*1100`	Nov/10/2022 01:16
253	A - Design Tutorial: Learn from Math	GNU C++17	`math` `number theory` `*800`	Nov/09/2022 21:22
252	B - Interesting drink	GNU C++17	`binary search` `dp` `implementation` `*1100`	Nov/08/2022 22:10
251	C - Division by Two and Permutation	GNU C++17	`constructive algorithms` `flows` `graph matchings` `greedy` `math` `*1100`	Nov/08/2022 18:56
250	B - Make AP	GNU C++17	`implementation` `math` `*900`	Nov/08/2022 03:21
249	A - Plus One on the Subset	GNU C++17	`math` `*800`	Nov/08/2022 01:22
248	A - Do Not Be Distracted!	GNU C++17	`brute force` `implementation` `*800`	Nov/07/2022 05:38
247	C - Less or Equal	GNU C++17	`sortings` `*1200`	Nov/07/2022 04:54
246	B - All Distinct	GNU C++17	`greedy` `sortings` `*800`	Nov/07/2022 04:14
245	A - Indirect Sort	GNU C++17	`constructive algorithms` `implementation` `math` `*800`	Nov/06/2022 22:29
244	B - Maximum Substring	GNU C++17	`brute force` `greedy` `implementation` `*800`	Nov/06/2022 22:17
243	A - Cut Ribbon	GNU C++17	`brute force` `dp` `*1300`	Nov/05/2022 04:37
242	A - Yet Another Two Integers Problem	GNU C++17	`greedy` `math` `*800`	Nov/05/2022 02:52
241	A - Restoring Three Numbers	GNU C++17	`math` `*800`	Nov/05/2022 02:43
240	A - Sum of Round Numbers	GNU C++17	`implementation` `math` `*800`	Nov/05/2022 02:32
239	A - Vasya the Hipster	GNU C++17	`implementation` `math` `*800`	Nov/05/2022 02:02
238	A - I_love_%username%	GNU C++17	`brute force` `*800`	Nov/05/2022 01:42
237	C - Swap Game	GNU C++17	`games` `*1200`	Nov/05/2022 00:33
236	B - BAN BAN	GNU C++17	`constructive algorithms` `*900`	Nov/05/2022 00:16
235	A - Two Groups	GNU C++17	`constructive algorithms` `greedy` `*800`	Nov/04/2022 20:49
234	B - Even Array	GNU C++17	`greedy` `math` `*800`	Nov/04/2022 05:28
233	B - T-primes	GNU C++17	`binary search` `implementation` `math` `number theory` `*1300`	Nov/04/2022 05:11
232	C - Registration System	GNU C++17	`data structures` `hashing` `implementation` `*1300`	Nov/04/2022 04:13
231	A - Candies and Two Sisters	GNU C++17	`math` `*800`	Nov/04/2022 03:57
230	A - Anton and Polyhedrons	GNU C++17	`implementation` `strings` `*800`	Nov/04/2022 03:42
229	A - Pangram	GNU C++17	`implementation` `strings` `*800`	Nov/04/2022 03:25
228	B - Taxi	GNU C++17	`special problem` `greedy` `implementation` `1100`	Nov/04/2022 00:27
227	D - Not a Cheap String	GNU C++17	`greedy` `*1000`	Nov/03/2022 22:54
226	C - Save the Magazines	GNU C++17	`constructive algorithms` `dp` `greedy` `*1100`	Nov/03/2022 04:42
225	A - Remove Smallest	GNU C++17	`greedy` `sortings` `*800`	Nov/03/2022 03:51
224	A - LCM Problem	GNU C++17	`constructive algorithms` `greedy` `math` `number theory` `*800`	Nov/03/2022 01:01
223	A - K-divisible Sum	GNU C++17	`binary search` `constructive algorithms` `greedy` `math` `*1000`	Nov/02/2022 01:23
222	A - New Year Candles	GNU C++17	`implementation` `*1000`	Nov/02/2022 00:31
221	A - Regular Bracket Sequences	GNU C++17	`constructive algorithms` `*800`	Nov/01/2022 19:04
220	A - Crazy Computer	GNU C++17	`implementation` `*800`	Nov/01/2022 17:54
219	A - Sequence with Digits	GNU C++17	`brute force` `implementation` `math` `*1200`	Nov/01/2022 02:53
218	A - Lunch Rush	GNU C++17	`implementation` `*900`	Nov/01/2022 02:20
217	A - Polycarp's Pockets	GNU C++17	`implementation` `*800`	Nov/01/2022 01:46
216	B1 - Palindrome Game (easy version)	GNU C++17	`constructive algorithms` `games` `*1200`	Nov/01/2022 01:03
215	B - Trouble Sort	GNU C++17	`constructive algorithms` `implementation` `*1300`	Oct/31/2022 19:30
214	A - Game 23	GNU C++17	`implementation` `math` `*1000`	Oct/31/2022 18:29
213	A - k-String	GNU C++17	`implementation` `strings` `*1000`	Oct/31/2022 03:36
212	B - Lovely Palindromes	GNU C++17	`constructive algorithms` `math` `*1000`	Oct/31/2022 02:31
211	A - Jzzhu and Children	GNU C++17	`implementation` `*1000`	Oct/31/2022 01:11
210	A - The number of positions	GNU C++17	`math` `*1000`	Oct/31/2022 00:44
209	A - Payment Without Change	GNU C++17	`math` `*1000`	Oct/30/2022 23:43
208	B - Minority	GNU C++17	`greedy` `*800`	Oct/30/2022 22:22
207	B - Yet Another Palindrome Problem	GNU C++17	`brute force` `strings` `*1100`	Oct/30/2022 21:42
206	A - Chewbaсca and Number	GNU C++17	`greedy` `implementation` `*1200`	Oct/30/2022 20:39
205	A - Erasing Zeroes	GNU C++17	`implementation` `strings` `*800`	Oct/30/2022 05:25
204	A - Arithmetic Array	GNU C++17	`greedy` `math` `*800`	Oct/30/2022 01:50
203	B - Maximums	GNU C++17	`implementation` `math` `*900`	Oct/30/2022 01:00
202	B - Permutation Sort	GNU C++17	`constructive algorithms` `greedy` `*900`	Oct/30/2022 00:34
201	B - Mocha and Red and Blue	GNU C++17	`dp` `greedy` `*900`	Oct/29/2022 21:49
200	B - Make It Increasing	GNU C++17	`greedy` `implementation` `*900`	Oct/29/2022 20:29
199	B - Candies Division	GNU C++17	`math` `*900`	Oct/29/2022 19:09
198	A - Factorise N+M	GNU C++17	`constructive algorithms` `number theory` `*800`	Oct/29/2022 16:13
197	A - Restoring Password	GNU C++17	`implementation` `strings` `*900`	Oct/29/2022 05:16
196	A - Football	GNU C++17	`strings` `*1000`	Oct/29/2022 03:10
195	A - cAPS lOCK	GNU C++17	`implementation` `strings` `*1000`	Oct/28/2022 20:12
194	B - AccurateLee	GNU C++17	`greedy` `implementation` `strings` `*1200`	Oct/28/2022 04:58
193	A - FashionabLee	GNU C++17	`geometry` `math` `*800`	Oct/28/2022 02:28
192	A - Business trip	GNU C++17	`greedy` `implementation` `sortings` `*900`	Oct/28/2022 02:14
191	A - C+=	GNU C++17	`brute force` `greedy` `implementation` `math` `*800`	Oct/28/2022 01:57
190	A - Deletions of Two Adjacent Letters	GNU C++17	`implementation` `strings` `*800`	Oct/28/2022 01:01
189	A - Omkar and Completion	GNU C++17	`constructive algorithms` `implementation` `*800`	Oct/28/2022 00:25
188	B - Friends and Candies	GNU C++17	`greedy` `math` `*800`	Oct/27/2022 23:55
187	A - Boring Apartments	GNU C++17	`implementation` `math` `*800`	Oct/27/2022 23:09
186	B - Mammoth's Genome Decoding	GNU C++17	`implementation` `strings` `*900`	Oct/27/2022 22:26
185	G - University Classes	GNU C++17	`implementation` `*900`	Oct/27/2022 00:03
184	B - Promo	GNU C++17	`greedy` `sortings` `*900`	Oct/26/2022 23:03
183	B - Easy Number Challenge	GNU C++17	`implementation` `number theory` `*1300`	Oct/26/2022 19:55
182	B - Construct the String	GNU C++17	`constructive algorithms` `*900`	Oct/26/2022 07:25
181	B - DIV + MOD	GNU C++17	`math` `*900`	Oct/26/2022 05:17
180	B - Two-gram	GNU C++17	`implementation` `strings` `*900`	Oct/26/2022 03:33
179	B - Odd Grasshopper	GNU C++17	`math` `*900`	Oct/26/2022 03:06
178	B - Non-Substring Subsequence	GNU C++17	`dp` `greedy` `implementation` `strings` `*900`	Oct/26/2022 01:42
177	E1 - Permutation Minimization by Deque	GNU C++17	`constructive algorithms` `greedy` `math` `*1000`	Oct/25/2022 22:10
176	B - Delete from the Left	GNU C++17	`brute force` `implementation` `strings` `*900`	Oct/25/2022 17:29
175	B - GCD Problem	GNU C++17	`brute force` `constructive algorithms` `math` `number theory` `*900`	Oct/25/2022 03:31
174	B - Equalize Prices	GNU C++17	`math` `*900`	Oct/25/2022 01:05
173	C - Lunar New Year and Number Division	GNU C++17	`greedy` `implementation` `math` `sortings` `*900`	Oct/25/2022 00:11
172	C - Unique Number	GNU C++17	`brute force` `greedy` `math` `*900`	Oct/24/2022 21:40
171	A - Hexagonal numbers	Befunge	`special problem` `implementation` `900`	Oct/24/2022 17:35
170	B - Maximal Continuous Rest	GNU C++17	`implementation` `*900`	Oct/24/2022 05:20
169	B - 01 Game	GNU C++17	`games` `*900`	Oct/24/2022 03:04
168	B - Sale	GNU C++17	`greedy` `sortings` `*900`	Oct/24/2022 02:42
167	B - Food Buying	GNU C++17	`math` `*900`	Oct/24/2022 02:23
166	A - Keyboard	GNU C++17	`implementation` `*900`	Oct/24/2022 01:17
165	B - Ugu	GNU C++17	`brute force` `dp` `greedy` `implementation` `*900`	Oct/23/2022 21:19
164	B - Kevin and Permutation	GNU C++17	`constructive algorithms` `greedy` `math` `*800`	Oct/23/2022 19:35
163	A - Technical Support	GNU C++17	`greedy` `*800`	Oct/23/2022 14:45
162	A - Long Comparison	GNU C++17	`implementation` `math` `*900`	Oct/22/2022 00:40
161	A - Vasya and Socks	GNU C++17	`brute force` `implementation` `math` `*900`	Oct/21/2022 23:35
160	A - Kefa and First Steps	GNU C++17	`brute force` `dp` `implementation` `*900`	Oct/21/2022 03:06
159	A - Cowardly Rooks	GNU C++17	`greedy` `implementation` `*800`	Oct/20/2022 22:50
158	B - Death's Blessing	GNU C++17	`greedy` `*900`	Oct/20/2022 21:37
157	B - Decode String	GNU C++17	`greedy` `strings` `*800`	Oct/20/2022 03:52
156	B - Triple	GNU C++17	`implementation` `sortings` `*800`	Oct/20/2022 01:56
155	A - Burenka Plays with Fractions	GNU C++17	`math` `number theory` `*900`	Oct/20/2022 00:36
154	A - Line to Cashier	GNU C++17	`implementation` `*900`	Oct/19/2022 22:04
153	A - Choosing Teams	GNU C++17	`greedy` `implementation` `sortings` `*800`	Oct/19/2022 21:09
152	A - Team Olympiad	GNU C++17	`greedy` `implementation` `sortings` `*800`	Oct/19/2022 20:21
151	A - Dragons	GNU C++17	`greedy` `sortings` `*1000`	Oct/19/2022 19:27
150	A - Ilya and Bank Account	GNU C++17	`implementation` `number theory` `*900`	Oct/19/2022 16:31
149	A - I Wanna Be the Guy	GNU C++17	`greedy` `implementation` `*800`	Oct/19/2022 07:17
148	A - Anton and Letters	GNU C++17	`constructive algorithms` `implementation` `*800`	Oct/19/2022 06:04
147	A - Expression	GNU C++17	`brute force` `math` `*1000`	Oct/19/2022 04:45
146	A - Puzzles	GNU C++17	`greedy` `*900`	Oct/19/2022 04:16
145	A - Dubstep	GNU C++17	`strings` `*900`	Oct/19/2022 03:36
144	A - Password	GNU C++17	`brute force` `combinatorics` `implementation` `math` `*800`	Oct/18/2022 00:39
143	A - Games	GNU C++17	`brute force` `*800`	Oct/17/2022 03:57
142	C - Word Game	GNU C++17	`data structures` `implementation` `*800`	Oct/17/2022 03:16
141	A - Number Replacement	GNU C++17	`greedy` `implementation` `*800`	Oct/16/2022 21:29
140	B - Ordinary Numbers	GNU C++17	`brute force` `math` `number theory` `*800`	Oct/16/2022 04:33
139	A - Bad Triangle	GNU C++17	`geometry` `math` `*800`	Oct/16/2022 03:51
138	B - Substring Removal Game	GNU C++17	`games` `greedy` `sortings` `*800`	Oct/16/2022 03:14
137	B - Anton and Digits	GNU C++17	`brute force` `greedy` `implementation` `math` `*800`	Oct/16/2022 01:42
136	A - Red Versus Blue	GNU C++17	`constructive algorithms` `greedy` `implementation` `math` `*1000`	Oct/16/2022 01:10
135	B - Rebellion	GNU C++17	`constructive algorithms` `greedy` `two pointers` `*800`	Oct/15/2022 21:25
134	A - Maxmina	GNU C++17	`constructive algorithms` `greedy` `*800`	Oct/15/2022 20:56
133	A - Equation	GNU C++17	`brute force` `math` `*800`	Oct/15/2022 07:04
132	A - The Rank	GNU C++17	`implementation` `*800`	Oct/15/2022 06:41
131	B - 3-palindrome	GNU C++17	`constructive algorithms` `*1000`	Oct/15/2022 05:25
130	A - Sasha and Sticks	GNU C++17	`games` `math` `*800`	Oct/14/2022 23:53
129	C - Stripes	GNU C++17	`implementation` `*900`	Oct/13/2022 22:28
128	B - Increasing	GNU C++17	`greedy` `implementation` `sortings` `*800`	Oct/13/2022 21:04
127	A - Sum	GNU C++17	`implementation` `*800`	Oct/13/2022 20:57
126	A - Scarborough Fair	GNU C++17	`implementation` `*800`	Oct/12/2022 23:26
125	A - Vus the Cossack and a Contest	GNU C++17	`implementation` `*800`	Oct/12/2022 22:56
124	A - Fafa and his Company	GNU C++17	`brute force` `implementation` `*800`	Oct/12/2022 22:41
123	A - Mahmoud and Ehab and the even-odd game	GNU C++17	`games` `math` `*800`	Oct/12/2022 19:58
122	A - Between the Offices	GNU C++17	`implementation` `*800`	Oct/12/2022 19:48
121	A - Cards	GNU C++17	`implementation` `sortings` `strings` `*800`	Oct/12/2022 04:12
120	B - Decoding	GNU C++17	`implementation` `strings` `*900`	Oct/12/2022 03:18
119	B - Funny Permutation	GNU C++17	`constructive algorithms` `math` `*800`	Oct/12/2022 01:34
118	A - Bachgold Problem	GNU C++17	`greedy` `implementation` `math` `number theory` `*800`	Oct/12/2022 00:02
117	A - Compare T-Shirt Sizes	GNU C++17	`implementation` `implementation` `strings` `*800`	Oct/11/2022 22:33
116	B - Keyboard Layouts	GNU C++17	`implementation` `strings` `*800`	Oct/11/2022 03:16
115	A - Three Pairwise Maximums	GNU C++17	`math` `*800`	Oct/10/2022 18:36
114	B - Restore the Permutation by Merger	GNU C++17	`greedy` `*800`	Oct/10/2022 07:03
113	B - Vanya and Lanterns	GNU C++17	`binary search` `implementation` `math` `sortings` `*1200`	Oct/10/2022 05:23
112	B - Two Arrays And Swaps	GNU C++17	`greedy` `sortings` `*800`	Oct/09/2022 22:20
111	B - Xenia and Ringroad	GNU C++17	`implementation` `*1000`	Oct/09/2022 21:44
110	A - Twins	GNU C++17	`greedy` `sortings` `*900`	Oct/09/2022 03:49
109	A - In Search of an Easy Problem	GNU C++17	`implementation` `*800`	Oct/08/2022 23:09
108	A - The New Year: Meeting Friends	GNU C++17	`implementation` `math` `sortings` `*800`	Oct/08/2022 21:54
107	A - Vanya and Fence	GNU C++17	`implementation` `*800`	Oct/08/2022 20:39
106	B - Queue at the School	GNU C++17	`constructive algorithms` `graph matchings` `implementation` `shortest paths` `*800`	Oct/08/2022 19:32
105	A - Young Physicist	GNU C++17	`implementation` `math` `*1000`	Oct/08/2022 18:44
104	A - Boy or Girl	GNU C++17	`brute force` `implementation` `strings` `*800`	Oct/08/2022 17:51
103	A - Madoka and Strange Thoughts	GNU C++17	`math` `number theory` `*800`	Oct/08/2022 04:49
102	A - Night at the Museum	GNU C++17	`implementation` `strings` `*800`	Oct/08/2022 04:28
101	A - Buy a Shovel	GNU C++17	`brute force` `constructive algorithms` `implementation` `math` `*800`	Oct/08/2022 00:50
100	A - Anton and Danik	GNU C++17	`implementation` `strings` `*800`	Oct/07/2022 23:21
99	A - Ostap and Grasshopper	GNU C++17	`implementation` `strings` `*800`	Oct/07/2022 23:09
98	A - Compote	GNU C++17	`implementation` `math` `*800`	Oct/07/2022 19:42
97	A - Petr and Book	GNU C++17	`implementation` `*1000`	Oct/07/2022 19:06
96	B - Fix You	GNU C++17	`brute force` `greedy` `implementation` `*800`	Oct/07/2022 17:33
95	A - New Year and Hurry	GNU C++17	`binary search` `brute force` `implementation` `math` `*800`	Oct/06/2022 22:03
94	A - PolandBall and Hypothesis	GNU C++17	`brute force` `graphs` `math` `number theory` `*800`	Oct/06/2022 21:07
93	A - Holiday Of Equality	GNU C++17	`implementation` `math` `*800`	Oct/06/2022 20:34
92	A - Taymyr is calling you	GNU C++17	`brute force` `implementation` `math` `*800`	Oct/06/2022 01:07
91	A - Die Roll	GNU C++17	`math` `probabilities` `*800`	Oct/05/2022 21:45
90	A - Fake NP	GNU C++17	`greedy` `math` `*1000`	Oct/05/2022 04:39
89	A - Perfectly Imperfect Array	GNU C++17	`math` `number theory` `*800`	Oct/05/2022 04:11
88	A - Reconnaissance	GNU C++17	`brute force` `*800`	Oct/05/2022 02:34
87	A - Fox And Snake	GNU C++17	`implementation` `*800`	Oct/03/2022 23:31
86	B - Borze	GNU C++17	`expression parsing` `implementation` `*800`	Oct/03/2022 23:07
85	A - Reconnaissance 2	GNU C++17	`implementation` `*800`	Oct/03/2022 19:33
84	A - Army	GNU C++17	`implementation` `*800`	Oct/03/2022 17:33
83	A - George and Accommodation	GNU C++17	`implementation` `*800`	Oct/03/2022 02:15
82	A - Gravity Flip	GNU C++17	`greedy` `implementation` `sortings` `*900`	Oct/03/2022 01:44
81	A - Holidays	GNU C++17	`brute force` `constructive algorithms` `greedy` `math` `*900`	Oct/03/2022 00:54
80	A - Working Week	GNU C++17	`constructive algorithms` `greedy` `math` `*800`	Oct/02/2022 23:40
79	A - Triangular numbers	GNU C++17	`brute force` `math` `*800`	Oct/02/2022 22:41
78	A - Sleuth	GNU C++17	`implementation` `*800`	Oct/02/2022 19:00
77	A - Ultra-Fast Mathematician	GNU C++17	`implementation` `*800`	Oct/02/2022 01:19
76	A - Panoramix's Prediction	GNU C++17	`brute force` `*800`	Oct/02/2022 00:22
75	B - Z mod X = C	GNU C++17	`constructive algorithms` `math` `*800`	Oct/01/2022 04:33
74	A - Chips	GNU C++17	`implementation` `math` `*800`	Oct/01/2022 03:56
73	A - Cheap Travel	GNU C++17	`implementation` `*1200`	Sep/30/2022 03:31
72	A - A+B (Trial Problem)	GNU C++17	`implementation` `*800`	Sep/30/2022 02:14
71	A - Epic Game	GNU C++17	`implementation` `*800`	Sep/30/2022 01:15
70	A - Presents	GNU C++17	`implementation` `*800`	Sep/29/2022 23:14
69	A - Immobile Knight	GNU C++17	`implementation` `*800`	Sep/29/2022 22:50
68	A - Amusing Joke	GNU C++17	`implementation` `sortings` `strings` `*800`	Sep/29/2022 18:58
67	A - Arrival of the General	GNU C++17	`implementation` `*800`	Sep/29/2022 18:37
66	A - Lucky Ticket	GNU C++17	`implementation` `*800`	Sep/28/2022 21:17
65	A - Lucky?	GNU C++17	`implementation` `*800`	Sep/28/2022 01:50
64	A - Insomnia cure	GNU C++17	`constructive algorithms` `implementation` `math` `*800`	Sep/28/2022 01:34
63	A - Soft Drinking	GNU C++17	`implementation` `math` `*800`	Sep/22/2022 00:00
62	A - IQ test	GNU C++17	`brute force` `*1300`	Sep/20/2022 23:17
61	A - System of Equations	GNU C++17	`brute force` `*800`	Sep/19/2022 00:14
60	A - Perfect Permutation	GNU C++17	`implementation` `math` `*800`	Sep/18/2022 02:40
59	A - Maximum GCD	GNU C++17	`greedy` `implementation` `math` `number theory` `*800`	Sep/16/2022 19:22
58	A - Lucky Division	GNU C++17	`brute force` `number theory` `*1000`	Sep/15/2022 06:02
57	A - HQ9+	GNU C++17	`implementation` `*900`	Sep/14/2022 00:34
56	A - Tram	GNU C++17	`implementation` `*800`	Sep/13/2022 03:31
55	A - Two Elevators	GNU C++17	`math` `*800`	Sep/12/2022 21:51
54	A - Word	GNU C++17	`implementation` `strings` `*800`	Sep/12/2022 19:01
53	A - Div. 7	GNU C++17	`brute force` `*800`	Sep/10/2022 23:54
52	A - Pretty Permutations	GNU C++17	`constructive algorithms` `greedy` `implementation` `*800`	Sep/09/2022 23:53
51	A - Food for Animals	GNU C++17	`greedy` `math` `*800`	Sep/08/2022 02:54
50	A - Roma and Lucky Numbers	GNU C++17	`implementation` `*800`	Sep/07/2022 04:26
49	A - Short Substrings	GNU C++17	`implementation` `strings` `*800`	Sep/06/2022 00:33
48	A - Patrick and Shopping	GNU C++17	`implementation` `*800`	Sep/05/2022 00:37
47	A - Odd Divisor	GNU C++17	`math` `number theory` `*900`	Sep/04/2022 19:53
46	A - Hit the Lottery	GNU C++17	`dp` `greedy` `*800`	Sep/03/2022 00:48
45	B - Colourblindness	GNU C++17	`implementation` `*800`	Sep/02/2022 03:57
44	A - Is your horseshoe on the other hoof?	GNU C++17	`implementation` `*800`	Sep/02/2022 01:16
43	A - Spell Check	GNU C++17	`implementation` `*800`	Sep/01/2022 16:12
42	A - Raising Bacteria	GNU C++17	`bitmasks` `*1000`	Aug/31/2022 00:05
41	A - Nearly Lucky Number	GNU C++17	`implementation` `*800`	Aug/30/2022 01:38
40	A - Petya and Strings	GNU C++17	`implementation` `strings` `*800`	Aug/29/2022 20:00
39	B - Martian Dollar	GNU C++17	`brute force` `*1400`	Aug/29/2022 00:30
38	A - Chat room	GNU C++17	`greedy` `strings` `*1000`	Aug/28/2022 01:13
37	A - Image	GNU C++17	`greedy` `implementation` `*800`	Aug/28/2022 00:00
36	A - Translation	GNU C++17	`implementation` `strings` `*800`	Aug/26/2022 00:03
35	A - String Task	GNU C++17	`implementation` `strings` `*1000`	Aug/25/2022 00:10
34	A - Calculating Function	GNU C++17	`implementation` `math` `*800`	Aug/24/2022 23:10
33	A - Soldier and Bananas	GNU C++17	`brute force` `implementation` `math` `*800`	Aug/24/2022 00:48
32	A - Helpful Maths	GNU C++17	`greedy` `implementation` `sortings` `strings` `*800`	Aug/23/2022 00:11
31	A - Hulk	GNU C++17	`implementation` `*800`	Aug/22/2022 00:40
30	A - Magnets	GNU C++17	`implementation` `*800`	Aug/21/2022 01:34
29	A - Crossmarket	GNU C++17	`constructive algorithms` `greedy` `math` `*800`	Aug/20/2022 21:19
28	A - Chip Game	GNU C++17	`games` `math` `*800`	Aug/20/2022 00:26
27	A - Perfect Permutation	GNU C++17	`constructive algorithms` `*800`	Aug/19/2022 17:01
26	A - Football	GNU C++17	`implementation` `strings` `*900`	Aug/19/2022 01:17
25	A - Minimal Square	GNU C++17	`greedy` `math` `*800`	Aug/17/2022 02:31
24	A - Marathon	GNU C++17	`implementation` `*800`	Aug/16/2022 00:05
23	A - Beautiful Matrix	GNU C++17	`implementation` `*800`	Aug/15/2022 19:48
22	A - Bit++	GNU C++17	`implementation` `*800`	Aug/15/2022 00:44
21	A - Word Capitalization	GNU C++17	`implementation` `strings` `*800`	Aug/14/2022 23:03
20	A - Way Too Long Words	GNU C++17	`strings` `*800`	Aug/14/2022 21:53
19	B - Multiply by 2, divide by 6	GNU C++17	`math` `*900`	Aug/14/2022 02:07
18	B - Drinks	GNU C++17	`implementation` `math` `*800`	Aug/13/2022 03:38
17	A - Police Recruits	GNU C++17	`implementation` `*800`	Aug/13/2022 02:46
16	A - Game With Sticks	GNU C++17	`implementation` `*900`	Aug/13/2022 02:03
15	A - Wrong Subtraction	GNU C++17	`implementation` `*800`	Aug/12/2022 20:38
14	A - Bear and Big Brother	GNU C++17	`implementation` `*800`	Aug/12/2022 19:20
13	A - Stones on the Table	GNU C++17	`implementation` `*800`	Aug/12/2022 19:01
12	A - Domino piling	GNU C++17	`greedy` `math` `*800`	Aug/12/2022 17:24
11	A - Traveling Salesman Problem	GNU C++17	`geometry` `greedy` `implementation` `*800`	Aug/12/2022 14:33
10	A - Beautiful Year	GNU C++17	`brute force` `*800`	Aug/11/2022 15:02
9	A - Division?	GNU C++17	`implementation` `*800`	Aug/10/2022 19:10
8	A - Next Round	GNU C++17	`special problem` `implementation` `800`	Aug/10/2022 03:29
7	A - Divisibility Problem	GNU C++17	`math` `*800`	Aug/08/2022 01:26
6	A - Even Odds	GNU C++20 (64)	`math` `*900`	Aug/07/2022 03:49
5	A - Elephant	GNU C++20 (64)	`math` `*800`	Aug/07/2022 00:02
4	A - Team	GNU C++20 (64)	`brute force` `greedy` `*800`	Aug/06/2022 23:17
3	A - Theatre Square	GNU C++20 (64)	`math` `*1000`	Aug/05/2022 23:39
2	A - Mishka and Game	GNU C++20 (64)	`implementation` `*800`	Aug/05/2022 04:20
1	A - Watermelon	GNU C++17	`brute force` `math` `*800`	Aug/05/2022 03:43

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

pFad - (p)hone/(F)rame/(a)nonymizer/(d)eclutterfier! Saves Data!