MatrixStudio/Codeforces-Python-Submissions

989

A

A Blend of Springtime

PROGRAMMING

900

[ "implementation", "strings" ]

null

"What a pity it's already late spring," sighs Mino with regret, "one more drizzling night and they'd be gone." "But these blends are at their best, aren't they?" Absorbed in the landscape, Kanno remains optimistic. The landscape can be expressed as a row of consecutive cells, each of which either contains a flower of colour amber or buff or canary yellow, or is empty. When a flower withers, it disappears from the cell that it originally belonged to, and it spreads petals of its colour in its two neighbouring cells (or outside the field if the cell is on the side of the landscape). In case petals fall outside the given cells, they simply become invisible. You are to help Kanno determine whether it's possible that after some (possibly none or all) flowers shed their petals, at least one of the cells contains all three colours, considering both petals and flowers. Note that flowers can wither in arbitrary order.

The first and only line of input contains a non-empty string $s$ consisting of uppercase English letters 'A', 'B', 'C' and characters '.' (dots) only ($\lvert s \rvert \leq 100$) — denoting cells containing an amber flower, a buff one, a canary yellow one, and no flowers, respectively.

Output "Yes" if it's possible that all three colours appear in some cell, and "No" otherwise. You can print each letter in any case (upper or lower).

[ ".BAC.\n", "AA..CB\n" ]

[ "Yes\n", "No\n" ]

In the first example, the buff and canary yellow flowers can leave their petals in the central cell, blending all three colours in it. In the second example, it's impossible to satisfy the requirement because there is no way that amber and buff meet in any cell.

500

[ { "input": ".BAC.", "output": "Yes" }, { "input": "AA..CB", "output": "No" }, { "input": ".", "output": "No" }, { "input": "ACB.AAAAAA", "output": "Yes" }, { "input": "B.BC.BBBCA", "output": "Yes" }, { "input": "BA..CAB..B", "output": "Yes" }, { "input": "CACCBAA.BC", "output": "Yes" }, { "input": ".CAACCBBA.CBB.AC..BABCCBCCB..B.BC..CBC.CA.CC.C.CC.B.A.CC.BBCCBB..ACAACAC.CBCCB.AABAAC.CBCC.BA..CCBC.", "output": "Yes" }, { "input": "A", "output": "No" }, { "input": "..", "output": "No" }, { "input": "BC", "output": "No" }, { "input": "CAB", "output": "Yes" }, { "input": "A.CB", "output": "No" }, { "input": "B.ACAA.CA..CBCBBAA.B.CCBCB.CAC.ABC...BC.BCCC.BC.CB", "output": "Yes" }, { "input": "B.B...CC.B..CCCB.CB..CBCB..CBCC.CCBC.B.CB..CA.C.C.", "output": "No" }, { "input": "AA.CBAABABCCC..B..B.ABBABAB.B.B.CCA..CB.B...A..CBC", "output": "Yes" }, { "input": "CA.ABB.CC.B.C.BBBABAAB.BBBAACACAAA.C.AACA.AAC.C.BCCB.CCBC.C..CCACA.CBCCB.CCAABAAB.AACAA..A.AAA.", "output": "No" }, { "input": "CBC...AC.BBBB.BBABABA.CAAACC.AAABB..A.BA..BC.CBBBC.BBBBCCCAA.ACCBB.AB.C.BA..CC..AAAC...AB.A.AAABBA.A", "output": "No" }, { "input": "CC.AAAC.BA.BBB.AABABBCCAA.A.CBCCB.B.BC.ABCBCBBAA.CACA.CCCA.CB.CCB.A.BCCCB...C.A.BCCBC..B.ABABB.C.BCB", "output": "Yes" }, { "input": "CCC..A..CACACCA.CA.ABAAB.BBA..C.AAA...ACB.ACA.CA.B.AB.A..C.BC.BC.A.C....ABBCCACCCBCC.BBBAA.ACCACB.BB", "output": "Yes" }, { "input": "BC.ABACAACC..AC.A..CCCAABBCCACAC.AA.CC.BAABABABBCBB.BA..C.C.C.A.BBA.C..BC.ACACCC.AAAACCCCC.AAC.AC.AB", "output": "Yes" }, { "input": "ACAC.BAA.C..CAAC..ABBAACC..BAA...CC...ACCBBCA.BAABABAACCAC.A.BBCACCC..BCB.BABAAAACCBCB.BCAABBC.C.BBB", "output": "Yes" }, { "input": "CCAC.BCBC.A.ABBAB.C.C.BC.CCABBCBCCBC..B.AA.C.BC...B..BAA.ACCCCBBB.AAAACA.CAACCB.CCB.CC.BCCAB.BBBBABB", "output": "Yes" }, { "input": ".AACAA.AAAAC.BBBB.BC...CCACCACAAA.A..CCA..BCC.AB.ABAAB..AABA...B.C.CBAB.BAAB.A.C.AAC.BBBA.ACAAA.BB.C", "output": "Yes" }, { "input": "CC.ACCC.BCCCCAA.BBAACB.ABABAAAA.A.CBAB.CBACBBC..C.CA.AAA..AA..ABBB.A.C..CBBCAAACC.B..CC.AC..CAABACB.", "output": "Yes" }, { "input": ".BAB.", "output": "No" }, { "input": "BBBBBBBBB", "output": "No" }, { "input": "..AAC..", "output": "No" }, { "input": ".AAABBBCCC.", "output": "No" }, { "input": "AAABC", "output": "Yes" }, { "input": "BBB", "output": "No" }, { "input": "AAAAABABAAAAA", "output": "No" }, { "input": "AABBCC", "output": "No" }, { "input": ".BA", "output": "No" }, { "input": "CAAAAB", "output": "No" } ]

1,528,807,832

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

61

0

string=str(input()) for i in range(1,len(string),1): if ord(string[i])!=46 and ord(string[i+1])!=46 and ord(string[i-1])!=46: print("Yes") break else: print("No")

Title: A Blend of Springtime Time Limit: None seconds Memory Limit: None megabytes Problem Description: "What a pity it's already late spring," sighs Mino with regret, "one more drizzling night and they'd be gone." "But these blends are at their best, aren't they?" Absorbed in the landscape, Kanno remains optimistic. The landscape can be expressed as a row of consecutive cells, each of which either contains a flower of colour amber or buff or canary yellow, or is empty. When a flower withers, it disappears from the cell that it originally belonged to, and it spreads petals of its colour in its two neighbouring cells (or outside the field if the cell is on the side of the landscape). In case petals fall outside the given cells, they simply become invisible. You are to help Kanno determine whether it's possible that after some (possibly none or all) flowers shed their petals, at least one of the cells contains all three colours, considering both petals and flowers. Note that flowers can wither in arbitrary order. Input Specification: The first and only line of input contains a non-empty string $s$ consisting of uppercase English letters 'A', 'B', 'C' and characters '.' (dots) only ($\lvert s \rvert \leq 100$) — denoting cells containing an amber flower, a buff one, a canary yellow one, and no flowers, respectively. Output Specification: Output "Yes" if it's possible that all three colours appear in some cell, and "No" otherwise. You can print each letter in any case (upper or lower). Demo Input: ['.BAC.\n', 'AA..CB\n'] Demo Output: ['Yes\n', 'No\n'] Note: In the first example, the buff and canary yellow flowers can leave their petals in the central cell, blending all three colours in it. In the second example, it's impossible to satisfy the requirement because there is no way that amber and buff meet in any cell.

```python string=str(input()) for i in range(1,len(string),1): if ord(string[i])!=46 and ord(string[i+1])!=46 and ord(string[i-1])!=46: print("Yes") break else: print("No") ```

0

550

C

Divisibility by Eight

PROGRAMMING

1,500

[ "brute force", "dp", "math" ]

null

You are given a non-negative integer *n*, its decimal representation consists of at most 100 digits and doesn't contain leading zeroes. Your task is to determine if it is possible in this case to remove some of the digits (possibly not remove any digit at all) so that the result contains at least one digit, forms a non-negative integer, doesn't have leading zeroes and is divisible by 8. After the removing, it is forbidden to rearrange the digits. If a solution exists, you should print it.

The single line of the input contains a non-negative integer *n*. The representation of number *n* doesn't contain any leading zeroes and its length doesn't exceed 100 digits.

Print "NO" (without quotes), if there is no such way to remove some digits from number *n*. Otherwise, print "YES" in the first line and the resulting number after removing digits from number *n* in the second line. The printed number must be divisible by 8. If there are multiple possible answers, you may print any of them.

[ "3454\n", "10\n", "111111\n" ]

[ "YES\n344\n", "YES\n0\n", "NO\n" ]

none

1,000

[ { "input": "3454", "output": "YES\n344" }, { "input": "10", "output": "YES\n0" }, { "input": "111111", "output": "NO" }, { "input": "8996988892", "output": "YES\n8" }, { "input": "5555555555", "output": "NO" }, { "input": "1", "output": "NO" }, { "input": "8147522776919916277306861346922924221557534659480258977017038624458370459299847590937757625791239188", "output": "YES\n8" }, { "input": "8", "output": "YES\n8" }, { "input": "14", "output": "NO" }, { "input": "2363", "output": "NO" }, { "input": "3554", "output": "NO" }, { "input": "312", "output": "YES\n32" }, { "input": "7674", "output": "YES\n64" }, { "input": "126", "output": "YES\n16" }, { "input": "344", "output": "YES\n344" }, { "input": "976", "output": "YES\n96" }, { "input": "3144", "output": "YES\n344" }, { "input": "1492", "output": "YES\n192" }, { "input": "1000", "output": "YES\n0" }, { "input": "303", "output": "YES\n0" }, { "input": "111111111111111111111171111111111111111111111111111112", "output": "YES\n72" }, { "input": "3111111111111111111111411111111111111111111141111111441", "output": "YES\n344" }, { "input": "7486897358699809313898215064443112428113331907121460549315254356705507612143346801724124391167293733", "output": "YES\n8" }, { "input": "1787075866", "output": "YES\n8" }, { "input": "836501278190105055089734832290981", "output": "YES\n8" }, { "input": "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", "output": "NO" }, { "input": "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222", "output": "NO" }, { "input": "3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333", "output": "NO" }, { "input": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "YES\n0" }, { "input": "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555", "output": "NO" }, { "input": "66666666666666666666666666666666666666666666666666666666666666666666666666666", "output": "NO" }, { "input": "88888888888888888888888888888888888888888888888888888888888888888888888888888888", "output": "YES\n8" }, { "input": "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", "output": "NO" }, { "input": "353", "output": "NO" }, { "input": "39", "output": "NO" }, { "input": "3697519", "output": "NO" }, { "input": "6673177113", "output": "NO" }, { "input": "6666351371557713735", "output": "NO" }, { "input": "17943911115335733153157373517", "output": "NO" }, { "input": "619715515939999957957971971757533319177373", "output": "NO" }, { "input": "4655797151375799393395377959959573533195153397997597195199777159133", "output": "NO" }, { "input": "5531399953495399131957773999751571911139197159755793777773799119333593915333593153173775755771193715", "output": "NO" }, { "input": "1319571733331774579193199551977735199771153997797535591739153377377111795579371959933533573517995559", "output": "NO" }, { "input": "3313393139519343957311771319713797711159791515393917539133957799131393735795317131513557337319131993", "output": "NO" }, { "input": "526", "output": "YES\n56" }, { "input": "513", "output": "NO" }, { "input": "674", "output": "YES\n64" }, { "input": "8353", "output": "YES\n8" }, { "input": "3957", "output": "NO" }, { "input": "4426155776626276881222352363321488266188669874572115686737742545442766138617391954346963915982759371", "output": "YES\n8" }, { "input": "9592419524227735697379444145348135927975358347769514686865768941989693174565893724972575152874281772", "output": "YES\n8" }, { "input": "94552498866729239313265973246288189853135485783461", "output": "YES\n8" }, { "input": "647934465937812", "output": "YES\n8" }, { "input": "1327917795375366484539554526312125336", "output": "YES\n8" }, { "input": "295971811535848297878828225646878276486982655866912496735794542", "output": "YES\n8" }, { "input": "7217495392264549817889283233368819844137671271383133997418139697797385729777632527678136", "output": "YES\n8" }, { "input": "11111111111111111111112111111111", "output": "YES\n112" }, { "input": "262626262626262626262626262626262626", "output": "NO" }, { "input": "1000000000000000000000000000000000000", "output": "YES\n0" }, { "input": "9969929446", "output": "YES\n96" }, { "input": "43523522125549722432232256557771715456345544922144", "output": "YES\n32" }, { "input": "9344661521956564755454992376342544254667536539463277572111263273131199437332443253296774957", "output": "YES\n96" }, { "input": "1946374341357914632311595531429723377642197432217137651552992479954116463332543456759911377223599715", "output": "YES\n16" }, { "input": "461259", "output": "NO" }, { "input": "461592", "output": "YES\n152" }, { "input": "46159237", "output": "YES\n152" }, { "input": "42367", "output": "NO" }, { "input": "42376", "output": "YES\n376" }, { "input": "42376159", "output": "YES\n376" }, { "input": "444444444444444444444444444444666666666666666666666666666666222222222222222222222222222222", "output": "NO" }, { "input": "0", "output": "YES\n0" }, { "input": "33332", "output": "YES\n32" }, { "input": "6499999999", "output": "YES\n64" } ]

1,691,683,584

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

3

46

0

v1=input() for i in range(len(v1)): v2=v1[:i]+v1[i+1:] if int(v2)%8==0:print("YES");print(int(v2));break else:print("NO")

Title: Divisibility by Eight Time Limit: None seconds Memory Limit: None megabytes Problem Description: You are given a non-negative integer *n*, its decimal representation consists of at most 100 digits and doesn't contain leading zeroes. Your task is to determine if it is possible in this case to remove some of the digits (possibly not remove any digit at all) so that the result contains at least one digit, forms a non-negative integer, doesn't have leading zeroes and is divisible by 8. After the removing, it is forbidden to rearrange the digits. If a solution exists, you should print it. Input Specification: The single line of the input contains a non-negative integer *n*. The representation of number *n* doesn't contain any leading zeroes and its length doesn't exceed 100 digits. Output Specification: Print "NO" (without quotes), if there is no such way to remove some digits from number *n*. Otherwise, print "YES" in the first line and the resulting number after removing digits from number *n* in the second line. The printed number must be divisible by 8. If there are multiple possible answers, you may print any of them. Demo Input: ['3454\n', '10\n', '111111\n'] Demo Output: ['YES\n344\n', 'YES\n0\n', 'NO\n'] Note: none

```python v1=input() for i in range(len(v1)): v2=v1[:i]+v1[i+1:] if int(v2)%8==0:print("YES");print(int(v2));break else:print("NO") ```

0

52

A

123-sequence

PROGRAMMING

900

[ "implementation" ]

A. 123-sequence

2

256

There is a given sequence of integers *a*1,<=*a*2,<=...,<=*a**n*, where every number is from 1 to 3 inclusively. You have to replace the minimum number of numbers in it so that all the numbers in the sequence are equal to each other.

The first line contains an integer *n* (1<=≤<=*n*<=≤<=106). The second line contains a sequence of integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=3).

Print the minimum number of replacements needed to be performed to make all the numbers in the sequence equal.

[ "9\n1 3 2 2 2 1 1 2 3\n" ]

[ "5\n" ]

In the example all the numbers equal to 1 and 3 should be replaced by 2.

500

[ { "input": "9\n1 3 2 2 2 1 1 2 3", "output": "5" }, { "input": "6\n3 3 2 2 1 3", "output": "3" }, { "input": "12\n3 1 3 1 2 1 3 2 2 1 2 1", "output": "7" }, { "input": "15\n3 2 1 1 1 1 3 2 2 3 3 1 2 3 2", "output": "10" }, { "input": "2\n2 1", "output": "1" }, { "input": "2\n3 2", "output": "1" }, { "input": "2\n3 1", "output": "1" }, { "input": "18\n2 3 2 1 2 3 2 1 2 3 3 3 1 2 3 3 3 2", "output": "10" }, { "input": "30\n2 1 3 2 3 2 2 2 2 3 2 2 3 2 1 1 3 1 3 2 1 2 3 1 1 3 3 1 3 1", "output": "19" }, { "input": "1\n1", "output": "0" }, { "input": "1\n2", "output": "0" }, { "input": "1\n3", "output": "0" } ]

1,695,646,572

2,147,483,647

PyPy 3-64

OK

TESTS

23

528

97,484,800

n=int(input()) a=list(map(int,input().split()))[:n] x=0 y=0 z=0 for i in range(n): if a[i]==1: x+=1 elif a[i]==2: y+=1 else: z+=1 if x==y and x==z: print(n-x) else: if x>=y and x>=z: print(n-x) elif y>=x and y>=z: print(n-y) else: print(n-z)

Title: 123-sequence Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: There is a given sequence of integers *a*1,<=*a*2,<=...,<=*a**n*, where every number is from 1 to 3 inclusively. You have to replace the minimum number of numbers in it so that all the numbers in the sequence are equal to each other. Input Specification: The first line contains an integer *n* (1<=≤<=*n*<=≤<=106). The second line contains a sequence of integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=3). Output Specification: Print the minimum number of replacements needed to be performed to make all the numbers in the sequence equal. Demo Input: ['9\n1 3 2 2 2 1 1 2 3\n'] Demo Output: ['5\n'] Note: In the example all the numbers equal to 1 and 3 should be replaced by 2.

```python n=int(input()) a=list(map(int,input().split()))[:n] x=0 y=0 z=0 for i in range(n): if a[i]==1: x+=1 elif a[i]==2: y+=1 else: z+=1 if x==y and x==z: print(n-x) else: if x>=y and x>=z: print(n-x) elif y>=x and y>=z: print(n-y) else: print(n-z) ```

3.68642

263

A

Beautiful Matrix

PROGRAMMING

800

[ "implementation" ]

null

You've got a 5<=×<=5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix: 1. Swap two neighboring matrix rows, that is, rows with indexes *i* and *i*<=+<=1 for some integer *i* (1<=≤<=*i*<=<<=5). 1. Swap two neighboring matrix columns, that is, columns with indexes *j* and *j*<=+<=1 for some integer *j* (1<=≤<=*j*<=<<=5). You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.

The input consists of five lines, each line contains five integers: the *j*-th integer in the *i*-th line of the input represents the element of the matrix that is located on the intersection of the *i*-th row and the *j*-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.

Print a single integer — the minimum number of moves needed to make the matrix beautiful.

[ "0 0 0 0 0\n0 0 0 0 1\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n", "0 0 0 0 0\n0 0 0 0 0\n0 1 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n" ]

[ "3\n", "1\n" ]

none

500

[ { "input": "0 0 0 0 0\n0 0 0 0 1\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0", "output": "3" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 1 0 0 0\n0 0 0 0 0\n0 0 0 0 0", "output": "1" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 0 1 0 0\n0 0 0 0 0\n0 0 0 0 0", "output": "0" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 1", "output": "4" }, { "input": "0 1 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0", "output": "3" }, { "input": "1 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0", "output": "4" }, { "input": "0 0 1 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0", "output": "2" }, { "input": "0 0 0 1 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0", "output": "3" }, { "input": "0 0 0 0 1\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0", "output": "4" }, { "input": "0 0 0 0 0\n1 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0", "output": "3" }, { "input": "0 0 0 0 0\n0 1 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0", "output": "2" }, { "input": "0 0 0 0 0\n0 0 1 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0", "output": "1" }, { "input": "0 0 0 0 0\n0 0 0 1 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0", "output": "2" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n1 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0", "output": "2" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 1 0\n0 0 0 0 0\n0 0 0 0 0", "output": "1" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 1\n0 0 0 0 0\n0 0 0 0 0", "output": "2" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n1 0 0 0 0\n0 0 0 0 0", "output": "3" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 1 0 0 0\n0 0 0 0 0", "output": "2" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 1 0 0\n0 0 0 0 0", "output": "1" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 1 0\n0 0 0 0 0", "output": "2" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 1\n0 0 0 0 0", "output": "3" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n1 0 0 0 0", "output": "4" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 1 0 0 0", "output": "3" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 1 0 0", "output": "2" }, { "input": "0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 1 0", "output": "3" } ]

1,697,018,474

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

30

0

for i in range(1,6): a=input() if '1' in a: b=a.index('1')+1 c=i break n=abs(b-3)+abs(c-3) print(n)

Title: Beautiful Matrix Time Limit: None seconds Memory Limit: None megabytes Problem Description: You've got a 5<=×<=5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix: 1. Swap two neighboring matrix rows, that is, rows with indexes *i* and *i*<=+<=1 for some integer *i* (1<=≤<=*i*<=<<=5). 1. Swap two neighboring matrix columns, that is, columns with indexes *j* and *j*<=+<=1 for some integer *j* (1<=≤<=*j*<=<<=5). You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful. Input Specification: The input consists of five lines, each line contains five integers: the *j*-th integer in the *i*-th line of the input represents the element of the matrix that is located on the intersection of the *i*-th row and the *j*-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one. Output Specification: Print a single integer — the minimum number of moves needed to make the matrix beautiful. Demo Input: ['0 0 0 0 0\n0 0 0 0 1\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n', '0 0 0 0 0\n0 0 0 0 0\n0 1 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n'] Demo Output: ['3\n', '1\n'] Note: none

```python for i in range(1,6): a=input() if '1' in a: b=a.index('1')+1 c=i break n=abs(b-3)+abs(c-3) print(n) ```

0

610

C

Harmony Analysis

PROGRAMMING

1,800

[ "constructive algorithms" ]

null

The semester is already ending, so Danil made an effort and decided to visit a lesson on harmony analysis to know how does the professor look like, at least. Danil was very bored on this lesson until the teacher gave the group a simple task: find 4 vectors in 4-dimensional space, such that every coordinate of every vector is 1 or <=-<=1 and any two vectors are orthogonal. Just as a reminder, two vectors in *n*-dimensional space are considered to be orthogonal if and only if their scalar product is equal to zero, that is: Danil quickly managed to come up with the solution for this problem and the teacher noticed that the problem can be solved in a more general case for 2*k* vectors in 2*k*-dimensinoal space. When Danil came home, he quickly came up with the solution for this problem. Can you cope with it?

The only line of the input contains a single integer *k* (0<=≤<=*k*<=≤<=9).

Print 2*k* lines consisting of 2*k* characters each. The *j*-th character of the *i*-th line must be equal to '<=*<=' if the *j*-th coordinate of the *i*-th vector is equal to <=-<=1, and must be equal to '<=+<=' if it's equal to <=+<=1. It's guaranteed that the answer always exists. If there are many correct answers, print any.

[ "2\n" ]

[ "++**\n+*+*\n++++\n+**+" ]

Consider all scalar products in example: - Vectors 1 and 2: ( + 1)·( + 1) + ( + 1)·( - 1) + ( - 1)·( + 1) + ( - 1)·( - 1) = 0 - Vectors 1 and 3: ( + 1)·( + 1) + ( + 1)·( + 1) + ( - 1)·( + 1) + ( - 1)·( + 1) = 0 - Vectors 1 and 4: ( + 1)·( + 1) + ( + 1)·( - 1) + ( - 1)·( - 1) + ( - 1)·( + 1) = 0 - Vectors 2 and 3: ( + 1)·( + 1) + ( - 1)·( + 1) + ( + 1)·( + 1) + ( - 1)·( + 1) = 0 - Vectors 2 and 4: ( + 1)·( + 1) + ( - 1)·( - 1) + ( + 1)·( - 1) + ( - 1)·( + 1) = 0 - Vectors 3 and 4: ( + 1)·( + 1) + ( + 1)·( - 1) + ( + 1)·( - 1) + ( + 1)·( + 1) = 0

1,500

[ { "input": "2", "output": "++++\n+*+*\n++**\n+**+" }, { "input": "1", "output": "++\n+*" }, { "input": "3", "output": "++++++++\n+*+*+*+*\n++**++**\n+**++**+\n++++****\n+*+**+*+\n++****++\n+**+*++*" }, { "input": "0", "output": "+" }, { "input": "4", "output": "++++++++++++++++\n+*+*+*+*+*+*+*+*\n++**++**++**++**\n+**++**++**++**+\n++++****++++****\n+*+**+*++*+**+*+\n++****++++****++\n+**+*++*+**+*++*\n++++++++********\n+*+*+*+**+*+*+*+\n++**++****++**++\n+**++**+*++**++*\n++++********++++\n+*+**+*+*+*++*+*\n++****++**++++**\n+**+*++**++*+**+" }, { "input": "5", "output": "++++++++++++++++++++++++++++++++\n+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*\n++**++**++**++**++**++**++**++**\n+**++**++**++**++**++**++**++**+\n++++****++++****++++****++++****\n+*+**+*++*+**+*++*+**+*++*+**+*+\n++****++++****++++****++++****++\n+**+*++*+**+*++*+**+*++*+**+*++*\n++++++++********++++++++********\n+*+*+*+**+*+*+*++*+*+*+**+*+*+*+\n++**++****++**++++**++****++**++\n+**++**+*++**++*+**++**+*++**++*\n++++********++++++++********++++\n+*+**+*+*+*++*+*+*+**+*+*+*++*+*\n++****++**++++**++****++**++++**\n+..." }, { "input": "6", "output": "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*\n++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**\n+**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**+\n++++****++++****++++****++++****++++****++++****++++****++++****\n+*+**+*++*+**+*++*+**+*++*+**+*++*+**+*++*+**+*++*+**+*++*+**+*+\n++****++++****++++****++++****++++****++++****++++****++++****++\n+**+*++*+**+*++*+**+*++*+**+*++*+**+*++*+**+*++*+..." }, { "input": "7", "output": "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*\n++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**\n+**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++**++..." }, { "input": "8", "output": "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+..." }, { "input": "9", "output": "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++..." } ]

1,689,364,961

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

0

30

0

print("_RANDOM_GUESS_1689364961.548565")# 1689364961.548585

Title: Harmony Analysis Time Limit: None seconds Memory Limit: None megabytes Problem Description: The semester is already ending, so Danil made an effort and decided to visit a lesson on harmony analysis to know how does the professor look like, at least. Danil was very bored on this lesson until the teacher gave the group a simple task: find 4 vectors in 4-dimensional space, such that every coordinate of every vector is 1 or <=-<=1 and any two vectors are orthogonal. Just as a reminder, two vectors in *n*-dimensional space are considered to be orthogonal if and only if their scalar product is equal to zero, that is: Danil quickly managed to come up with the solution for this problem and the teacher noticed that the problem can be solved in a more general case for 2*k* vectors in 2*k*-dimensinoal space. When Danil came home, he quickly came up with the solution for this problem. Can you cope with it? Input Specification: The only line of the input contains a single integer *k* (0<=≤<=*k*<=≤<=9). Output Specification: Print 2*k* lines consisting of 2*k* characters each. The *j*-th character of the *i*-th line must be equal to '<=*<=' if the *j*-th coordinate of the *i*-th vector is equal to <=-<=1, and must be equal to '<=+<=' if it's equal to <=+<=1. It's guaranteed that the answer always exists. If there are many correct answers, print any. Demo Input: ['2\n'] Demo Output: ['++**\n+*+*\n++++\n+**+'] Note: Consider all scalar products in example: - Vectors 1 and 2: ( + 1)·( + 1) + ( + 1)·( - 1) + ( - 1)·( + 1) + ( - 1)·( - 1) = 0 - Vectors 1 and 3: ( + 1)·( + 1) + ( + 1)·( + 1) + ( - 1)·( + 1) + ( - 1)·( + 1) = 0 - Vectors 1 and 4: ( + 1)·( + 1) + ( + 1)·( - 1) + ( - 1)·( - 1) + ( - 1)·( + 1) = 0 - Vectors 2 and 3: ( + 1)·( + 1) + ( - 1)·( + 1) + ( + 1)·( + 1) + ( - 1)·( + 1) = 0 - Vectors 2 and 4: ( + 1)·( + 1) + ( - 1)·( - 1) + ( + 1)·( - 1) + ( - 1)·( + 1) = 0 - Vectors 3 and 4: ( + 1)·( + 1) + ( + 1)·( - 1) + ( + 1)·( - 1) + ( + 1)·( + 1) = 0

```python print("_RANDOM_GUESS_1689364961.548565")# 1689364961.548585 ```

0

551

A

GukiZ and Contest

PROGRAMMING

800

[ "brute force", "implementation", "sortings" ]

null

Professor GukiZ likes programming contests. He especially likes to rate his students on the contests he prepares. Now, he has decided to prepare a new contest. In total, *n* students will attend, and before the start, every one of them has some positive integer rating. Students are indexed from 1 to *n*. Let's denote the rating of *i*-th student as *a**i*. After the contest ends, every student will end up with some positive integer position. GukiZ expects that his students will take places according to their ratings. He thinks that each student will take place equal to . In particular, if student *A* has rating strictly lower then student *B*, *A* will get the strictly better position than *B*, and if two students have equal ratings, they will share the same position. GukiZ would like you to reconstruct the results by following his expectations. Help him and determine the position after the end of the contest for each of his students if everything goes as expected.

The first line contains integer *n* (1<=≤<=*n*<=≤<=2000), number of GukiZ's students. The second line contains *n* numbers *a*1,<=*a*2,<=... *a**n* (1<=≤<=*a**i*<=≤<=2000) where *a**i* is the rating of *i*-th student (1<=≤<=*i*<=≤<=*n*).

In a single line, print the position after the end of the contest for each of *n* students in the same order as they appear in the input.

[ "3\n1 3 3\n", "1\n1\n", "5\n3 5 3 4 5\n" ]

[ "3 1 1\n", "1\n", "4 1 4 3 1\n" ]

In the first sample, students 2 and 3 are positioned first (there is no other student with higher rating), and student 1 is positioned third since there are two students with higher rating. In the second sample, first student is the only one on the contest. In the third sample, students 2 and 5 share the first position with highest rating, student 4 is next with third position, and students 1 and 3 are the last sharing fourth position.

500

[ { "input": "3\n1 3 3", "output": "3 1 1" }, { "input": "1\n1", "output": "1" }, { "input": "5\n3 5 3 4 5", "output": "4 1 4 3 1" }, { "input": "7\n1 3 5 4 2 2 1", "output": "6 3 1 2 4 4 6" }, { "input": "11\n5 6 4 2 9 7 6 6 6 6 7", "output": "9 4 10 11 1 2 4 4 4 4 2" }, { "input": "1\n2000", "output": "1" }, { "input": "2\n2000 2000", "output": "1 1" }, { "input": "3\n500 501 502", "output": "3 2 1" }, { "input": "10\n105 106 1 1 1 11 1000 999 1000 999", "output": "6 5 8 8 8 7 1 3 1 3" }, { "input": "6\n1 2 3 4 5 6", "output": "6 5 4 3 2 1" }, { "input": "7\n6 5 4 3 2 1 1", "output": "1 2 3 4 5 6 6" }, { "input": "8\n153 100 87 14 10 8 6 5", "output": "1 2 3 4 5 6 7 8" }, { "input": "70\n11 54 37 62 1 46 13 17 38 47 28 15 63 5 61 34 49 66 32 59 3 41 58 28 23 62 41 64 20 5 14 41 10 37 51 32 65 46 61 8 15 19 16 44 31 42 19 46 66 25 26 58 60 5 19 18 69 53 20 40 45 27 24 41 32 23 57 56 62 10", "output": "62 18 35 7 70 23 61 56 34 22 42 58 6 66 10 37 21 2 38 13 69 29 14 42 48 7 29 5 50 66 60 29 63 35 20 38 4 23 10 65 58 52 57 27 41 28 52 23 2 46 45 14 12 66 52 55 1 19 50 33 26 44 47 29 38 48 16 17 7 63" }, { "input": "5\n1 2000 1 1 2000", "output": "3 1 3 3 1" } ]

1,504,557,250

2,147,483,647

Python 3

OK

TESTS

36

77

307,200

n = int(input()) ratings = [(i,int(x)) for i,x in enumerate(input().split())] out = [0]*n ratings = sorted(ratings, key = lambda x: x[1], reverse=True) pos = 0 score = 0 count = 1 for r in ratings: r_score = r[1] if r_score != score: score = r_score pos +=count count = 1 else: count += 1 out[r[0]] = pos print (' '.join(str(x) for x in out))

Title: GukiZ and Contest Time Limit: None seconds Memory Limit: None megabytes Problem Description: Professor GukiZ likes programming contests. He especially likes to rate his students on the contests he prepares. Now, he has decided to prepare a new contest. In total, *n* students will attend, and before the start, every one of them has some positive integer rating. Students are indexed from 1 to *n*. Let's denote the rating of *i*-th student as *a**i*. After the contest ends, every student will end up with some positive integer position. GukiZ expects that his students will take places according to their ratings. He thinks that each student will take place equal to . In particular, if student *A* has rating strictly lower then student *B*, *A* will get the strictly better position than *B*, and if two students have equal ratings, they will share the same position. GukiZ would like you to reconstruct the results by following his expectations. Help him and determine the position after the end of the contest for each of his students if everything goes as expected. Input Specification: The first line contains integer *n* (1<=≤<=*n*<=≤<=2000), number of GukiZ's students. The second line contains *n* numbers *a*1,<=*a*2,<=... *a**n* (1<=≤<=*a**i*<=≤<=2000) where *a**i* is the rating of *i*-th student (1<=≤<=*i*<=≤<=*n*). Output Specification: In a single line, print the position after the end of the contest for each of *n* students in the same order as they appear in the input. Demo Input: ['3\n1 3 3\n', '1\n1\n', '5\n3 5 3 4 5\n'] Demo Output: ['3 1 1\n', '1\n', '4 1 4 3 1\n'] Note: In the first sample, students 2 and 3 are positioned first (there is no other student with higher rating), and student 1 is positioned third since there are two students with higher rating. In the second sample, first student is the only one on the contest. In the third sample, students 2 and 5 share the first position with highest rating, student 4 is next with third position, and students 1 and 3 are the last sharing fourth position.

```python n = int(input()) ratings = [(i,int(x)) for i,x in enumerate(input().split())] out = [0]*n ratings = sorted(ratings, key = lambda x: x[1], reverse=True) pos = 0 score = 0 count = 1 for r in ratings: r_score = r[1] if r_score != score: score = r_score pos +=count count = 1 else: count += 1 out[r[0]] = pos print (' '.join(str(x) for x in out)) ```

3

883

E

Field of Wonders

PROGRAMMING

1,500

[ "implementation", "strings" ]

null

Polycarpus takes part in the "Field of Wonders" TV show. The participants of the show have to guess a hidden word as fast as possible. Initially all the letters of the word are hidden. The game consists of several turns. At each turn the participant tells a letter and the TV show host responds if there is such letter in the word or not. If there is such letter then the host reveals all such letters. For example, if the hidden word is "abacaba" and the player tells the letter "a", the host will reveal letters at all positions, occupied by "a": 1, 3, 5 and 7 (positions are numbered from left to right starting from 1). Polycarpus knows *m* words of exactly the same length as the hidden word. The hidden word is also known to him and appears as one of these *m* words. At current moment a number of turns have already been made and some letters (possibly zero) of the hidden word are already revealed. Previously Polycarp has told exactly the letters which are currently revealed. It is Polycarpus' turn. He wants to tell a letter in such a way, that the TV show host will assuredly reveal at least one more letter. Polycarpus cannot tell the letters, which are already revealed. Your task is to help Polycarpus and find out the number of letters he can tell so that the show host will assuredly reveal at least one of the remaining letters.

The first line contains one integer *n* (1<=≤<=*n*<=≤<=50) — the length of the hidden word. The following line describes already revealed letters. It contains the string of length *n*, which consists of lowercase Latin letters and symbols "*". If there is a letter at some position, then this letter was already revealed. If the position contains symbol "*", then the letter at this position has not been revealed yet. It is guaranteed, that at least one letter is still closed. The third line contains an integer *m* (1<=≤<=*m*<=≤<=1000) — the number of words of length *n*, which Polycarpus knows. The following *m* lines contain the words themselves — *n*-letter strings of lowercase Latin letters. All words are distinct. It is guaranteed that the hidden word appears as one of the given *m* words. Before the current move Polycarp has told exactly the letters which are currently revealed.

Output the single integer — the number of letters Polycarpus can tell so that the TV show host definitely reveals at least one more letter. It is possible that this number is zero.

[ "4\na**d\n2\nabcd\nacbd\n", "5\nlo*er\n2\nlover\nloser\n", "3\na*a\n2\naaa\naba\n" ]

[ "2\n", "0\n", "1\n" ]

In the first example Polycarpus can tell letters "b" and "c", which assuredly will be revealed. The second example contains no letters which can be told as it is not clear, which of the letters "v" or "s" is located at the third position of the hidden word. In the third example Polycarpus exactly knows that the hidden word is "aba", because in case it was "aaa", then the second letter "a" would have already been revealed in one of previous turns.

0

[ { "input": "4\na**d\n2\nabcd\nacbd", "output": "2" }, { "input": "5\nlo*er\n2\nlover\nloser", "output": "0" }, { "input": "3\na*a\n2\naaa\naba", "output": "1" }, { "input": "1\n*\n1\na", "output": "1" }, { "input": "1\n*\n1\nz", "output": "1" }, { "input": "1\n*\n2\na\nz", "output": "0" }, { "input": "2\n**\n1\naa", "output": "1" }, { "input": "2\n**\n1\nfx", "output": "2" }, { "input": "2\n**\n2\nfx\nab", "output": "0" }, { "input": "2\n**\n2\nfx\naf", "output": "1" }, { "input": "2\na*\n2\naa\nab", "output": "1" }, { "input": "4\na*b*\n2\nabbc\nadbd", "output": "1" }, { "input": "4\na*b*\n3\nabbc\nadbd\nacbe", "output": "0" }, { "input": "4\na*b*\n3\nabbc\nadbd\nacbd", "output": "1" }, { "input": "3\n***\n2\naaa\nbbb", "output": "0" }, { "input": "3\n***\n2\naab\nabb", "output": "2" }, { "input": "3\n*a*\n4\naaa\ncac\naab\nbaa", "output": "1" }, { "input": "42\n*****o*******t********************oo******\n10\nvcrccobltkeidtxhsxhccaslkjhfyeqsetoowaemso\nuimjsoxifamvctkgqmrwhyjrgmlydczzqjoobnnwch\nuvmjsoqizfavctkxemrpaycngmlyemzzqjoobszwbh\nusmjsoviskzvctkljmrlmylugmlydfzzqvoobzawgh\nfeqweodinkhiatqmfokaxwcmlmbmvskssyookgcrax\ntackfosjhxeqftkgjynbbedrczegtimuvooosypczy\nxanuvoeismzmctruyplxgmfcpyrpqopyctoozlquvg\nurmjsouirdrvctkepmrwjyaxgmlyzvzzqcoobjgwih\nuymjsogivzivctkydmrgwyavgmlyphzzquoobclwhh\nkodyeoyihylgrtrdwudrsyonmuhtxaqklcoolsaclu", "output": "18" }, { "input": "50\n***********************************o**************\n5\nwrubnrgpqmduhgxtlxymsmcaiimivvypkkeouspglhzkfbpzcu\nfrubkrgplrduhgjuuxdmsgeaiimavvypkkeousulbhnkebpzcu\nwrubkrgpdrduhgfanxdmsufaiimgvvypkkeouwvsshikhbpzcu\nvhyfvnnobcguishyvuswkaxhkesgatuvbkyodxdrvlwwifiimd\nwrubwrgpvaduhgfnqxtmsjqaiimcvvypkkeouiqpyhckkbpzcu", "output": "20" }, { "input": "10\n**********\n10\nmvsthotcmi\nhmivtctsmo\nmmcostthiv\ntmomihtsvc\nmottsivmch\nhtomvcsmit\nsvhmotmcti\nmitotmvhcs\nvomcttmish\ncmostitvmh", "output": "8" }, { "input": "20\n********************\n1\nlaizpfbafxrugjcytfbs", "output": "16" }, { "input": "50\n**************************************************\n1\nqgaeytghzvvtgeitpovqozyclectzcohivbggudhiylaecbdzq", "output": "17" }, { "input": "50\n**************************************************\n2\nhvjbrfkhdaobruoptrrachzuvkxvvsckycfiroipqicoqvcqpr\nuirvabciccxdvpryroisvpoqvthrpurkzhoovcfqcjbhkarkqf", "output": "20" }, { "input": "26\n**************************\n10\nevfsnczuiodgbhqmlypkjatxrw\nuapqfdtoxkzynlbrehgwismvjc\nwjuyacngtzmvhqelikxoprdfbs\nyjgstlkvrhoqadxwfbiucpznem\nvebnxtrlocgkajqmwfuiszhypd\nroaqchwlpvtzxymnbkjigfedsu\noxmwaqpcendihzkutsybrjgfvl\nbnfzlwcsagxojdiyktqvruemhp\npdjahwnvmouxgqlciktzrfeysb\nbznurcyefxiapgktmqwjvsdloh", "output": "26" }, { "input": "26\n**************************\n1\nayvguplhjsoiencbkxdrfwmqtz", "output": "26" }, { "input": "26\n*lmnotuvwxyzjkabcdehiqfgrs\n2\nblmnotuvwxyzjkabcdehiqfgrs\nplmnotuvwxyzjkabcdehiqfgrs", "output": "1" }, { "input": "16\nx*d**s******xd*u\n22\nxfdeoshogyqjxdmu\nxvdvdsnwfwakxdyu\nxfdjoshftykjxdmu\nxfdcoshfwyajxdmu\nxfdfoshkmyajxdmu\nxfdyoshpoycjxdmu\nxmdhcswqnhxjxdtu\nxxdxwsoogqzwxdcu\nxxdhhsxqzciuxdfu\nxddcmswqzksqxdhu\nxfdtoshioyvjxdmu\nxsdxmsfmgjbyxdgu\nxadfssplfnlbxdru\nxndcasykmqmbxdru\nxrdxgszaisicxdlu\nxfdfoshhmypjxdmu\nxfdioshfiyhjxdmu\nxvdzysydlmyuxdnu\nxjdbqszgkuwhxdmu\nxfdfoshjyymjxdmu\nxgdjksubrmrfxdpu\nxkdshsfszixmxdcu", "output": "2" }, { "input": "3\n*vt\n2\ncvt\nqvb", "output": "1" }, { "input": "3\ntv*\n2\ntvc\nbvq", "output": "1" }, { "input": "41\n*z*hjcxxdgkny*tc*rmaov***fra**efs*lbi*puw\n1\nqzqhjcxxdgknyqtcqrmaovqqqfraqqefsqlbiqpuw", "output": "1" }, { "input": "48\n*h*i**ag**um**fuxvmxlj*dsyt*gb*dxkzp*brnelctkq*w\n1\nohoiooagooumoofuxvmxljodsytogbodxkzpobrnelctkqow", "output": "1" } ]

1,650,816,613

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

15

0

_, w, m = input(), input(), int(input()) ws = set() for _ in range(m): q = input() for a, b in zip(w, q): if a!='*' and a!=b or a=='*' and b in w: break else: ws.add(q) ans, all = set(), set() for i, c in enumerate(w): if c!='*': continue l = set() for q in ws: l.add(q[i]) if not all: all = l else: all.intersection_update(l) print(ws, l, all, ans) if len(l)==1: ans.add(l.pop()) if w.count('*')==1: all.clear() print(len(ans.union(all)))

Title: Field of Wonders Time Limit: None seconds Memory Limit: None megabytes Problem Description: Polycarpus takes part in the "Field of Wonders" TV show. The participants of the show have to guess a hidden word as fast as possible. Initially all the letters of the word are hidden. The game consists of several turns. At each turn the participant tells a letter and the TV show host responds if there is such letter in the word or not. If there is such letter then the host reveals all such letters. For example, if the hidden word is "abacaba" and the player tells the letter "a", the host will reveal letters at all positions, occupied by "a": 1, 3, 5 and 7 (positions are numbered from left to right starting from 1). Polycarpus knows *m* words of exactly the same length as the hidden word. The hidden word is also known to him and appears as one of these *m* words. At current moment a number of turns have already been made and some letters (possibly zero) of the hidden word are already revealed. Previously Polycarp has told exactly the letters which are currently revealed. It is Polycarpus' turn. He wants to tell a letter in such a way, that the TV show host will assuredly reveal at least one more letter. Polycarpus cannot tell the letters, which are already revealed. Your task is to help Polycarpus and find out the number of letters he can tell so that the show host will assuredly reveal at least one of the remaining letters. Input Specification: The first line contains one integer *n* (1<=≤<=*n*<=≤<=50) — the length of the hidden word. The following line describes already revealed letters. It contains the string of length *n*, which consists of lowercase Latin letters and symbols "*". If there is a letter at some position, then this letter was already revealed. If the position contains symbol "*", then the letter at this position has not been revealed yet. It is guaranteed, that at least one letter is still closed. The third line contains an integer *m* (1<=≤<=*m*<=≤<=1000) — the number of words of length *n*, which Polycarpus knows. The following *m* lines contain the words themselves — *n*-letter strings of lowercase Latin letters. All words are distinct. It is guaranteed that the hidden word appears as one of the given *m* words. Before the current move Polycarp has told exactly the letters which are currently revealed. Output Specification: Output the single integer — the number of letters Polycarpus can tell so that the TV show host definitely reveals at least one more letter. It is possible that this number is zero. Demo Input: ['4\na**d\n2\nabcd\nacbd\n', '5\nlo*er\n2\nlover\nloser\n', '3\na*a\n2\naaa\naba\n'] Demo Output: ['2\n', '0\n', '1\n'] Note: In the first example Polycarpus can tell letters "b" and "c", which assuredly will be revealed. The second example contains no letters which can be told as it is not clear, which of the letters "v" or "s" is located at the third position of the hidden word. In the third example Polycarpus exactly knows that the hidden word is "aba", because in case it was "aaa", then the second letter "a" would have already been revealed in one of previous turns.

```python _, w, m = input(), input(), int(input()) ws = set() for _ in range(m): q = input() for a, b in zip(w, q): if a!='*' and a!=b or a=='*' and b in w: break else: ws.add(q) ans, all = set(), set() for i, c in enumerate(w): if c!='*': continue l = set() for q in ws: l.add(q[i]) if not all: all = l else: all.intersection_update(l) print(ws, l, all, ans) if len(l)==1: ans.add(l.pop()) if w.count('*')==1: all.clear() print(len(ans.union(all))) ```

0

71

A

Way Too Long Words

PROGRAMMING

800

[ "strings" ]

A. Way Too Long Words

1

256

Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome. Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation. This abbreviation is made like this: we write down the first and the last letter of a word and between them we write the number of letters between the first and the last letters. That number is in decimal system and doesn't contain any leading zeroes. Thus, "localization" will be spelt as "l10n", and "internationalization» will be spelt as "i18n". You are suggested to automatize the process of changing the words with abbreviations. At that all too long words should be replaced by the abbreviation and the words that are not too long should not undergo any changes.

The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). Each of the following *n* lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters.

Print *n* lines. The *i*-th line should contain the result of replacing of the *i*-th word from the input data.

[ "4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis\n" ]

[ "word\nl10n\ni18n\np43s\n" ]

none

500

[ { "input": "4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis", "output": "word\nl10n\ni18n\np43s" }, { "input": "5\nabcdefgh\nabcdefghi\nabcdefghij\nabcdefghijk\nabcdefghijklm", "output": "abcdefgh\nabcdefghi\nabcdefghij\na9k\na11m" }, { "input": "3\nnjfngnrurunrgunrunvurn\njfvnjfdnvjdbfvsbdubruvbubvkdb\nksdnvidnviudbvibd", "output": "n20n\nj27b\nk15d" }, { "input": "1\ntcyctkktcctrcyvbyiuhihhhgyvyvyvyvjvytchjckt", "output": "t41t" }, { "input": "24\nyou\nare\nregistered\nfor\npractice\nyou\ncan\nsolve\nproblems\nunofficially\nresults\ncan\nbe\nfound\nin\nthe\ncontest\nstatus\nand\nin\nthe\nbottom\nof\nstandings", "output": "you\nare\nregistered\nfor\npractice\nyou\ncan\nsolve\nproblems\nu10y\nresults\ncan\nbe\nfound\nin\nthe\ncontest\nstatus\nand\nin\nthe\nbottom\nof\nstandings" }, { "input": "1\na", "output": "a" }, { "input": "26\na\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np\nq\nr\ns\nt\nu\nv\nw\nx\ny\nz", "output": "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\nm\nn\no\np\nq\nr\ns\nt\nu\nv\nw\nx\ny\nz" }, { "input": "1\nabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij", "output": "a98j" }, { "input": "10\ngyartjdxxlcl\nfzsck\nuidwu\nxbymclornemdmtj\nilppyoapitawgje\ncibzc\ndrgbeu\nhezplmsdekhhbo\nfeuzlrimbqbytdu\nkgdco", "output": "g10l\nfzsck\nuidwu\nx13j\ni13e\ncibzc\ndrgbeu\nh12o\nf13u\nkgdco" }, { "input": "20\nlkpmx\nkovxmxorlgwaomlswjxlpnbvltfv\nhykasjxqyjrmybejnmeumzha\ntuevlumpqbbhbww\nqgqsphvrmupxxc\ntrissbaf\nqfgrlinkzvzqdryckaizutd\nzzqtoaxkvwoscyx\noswytrlnhpjvvnwookx\nlpuzqgec\ngyzqfwxggtvpjhzmzmdw\nrlxjgmvdftvrmvbdwudra\nvsntnjpepnvdaxiporggmglhagv\nxlvcqkqgcrbgtgglj\nlyxwxbiszyhlsrgzeedzprbmcpduvq\nyrmqqvrkqskqukzqrwukpsifgtdc\nxpuohcsjhhuhvr\nvvlfrlxpvqejngwrbfbpmqeirxlw\nsvmasocxdvadmaxtrpakysmeaympy\nyuflqboqfdt", "output": "lkpmx\nk26v\nh22a\nt13w\nq12c\ntrissbaf\nq21d\nz13x\no17x\nlpuzqgec\ng18w\nr19a\nv25v\nx15j\nl28q\ny26c\nx12r\nv26w\ns27y\ny9t" }, { "input": "100\nm\nz\ns\nv\nd\nr\nv\ny\ny\ne\np\nt\nc\na\nn\nm\np\ng\ni\nj\nc\na\nb\nq\ne\nn\nv\no\nk\nx\nf\ni\nl\na\nq\nr\nu\nb\ns\nl\nc\nl\ne\nv\nj\nm\nx\nb\na\nq\nb\na\nf\nj\nv\nm\nq\nc\nt\nt\nn\nx\no\ny\nr\nu\nh\nm\nj\np\nj\nq\nz\ns\nj\no\ng\nc\nm\nn\no\nm\nr\no\ns\nt\nh\nr\np\nk\nb\nz\ng\no\nc\nc\nz\nz\ng\nr", "output": "m\nz\ns\nv\nd\nr\nv\ny\ny\ne\np\nt\nc\na\nn\nm\np\ng\ni\nj\nc\na\nb\nq\ne\nn\nv\no\nk\nx\nf\ni\nl\na\nq\nr\nu\nb\ns\nl\nc\nl\ne\nv\nj\nm\nx\nb\na\nq\nb\na\nf\nj\nv\nm\nq\nc\nt\nt\nn\nx\no\ny\nr\nu\nh\nm\nj\np\nj\nq\nz\ns\nj\no\ng\nc\nm\nn\no\nm\nr\no\ns\nt\nh\nr\np\nk\nb\nz\ng\no\nc\nc\nz\nz\ng\nr" } ]

1,674,627,693

2,147,483,647

PyPy 3-64

OK

TESTS

20

62

0

# -*- coding: utf-8 -*- # @Author: Fei_xiangShi # @Date: 2023-01-25 14:18:18 # @Last Modified by: FXS # @Last Modified time: 2023-01-25 14:21:29 n = int(input()) for _ in range(n): a = input() if len(a) < 11: print(a) else: print(a[0]+str(len(a)-2)+a[-1])

Title: Way Too Long Words Time Limit: 1 seconds Memory Limit: 256 megabytes Problem Description: Sometimes some words like "localization" or "internationalization" are so long that writing them many times in one text is quite tiresome. Let's consider a word too long, if its length is strictly more than 10 characters. All too long words should be replaced with a special abbreviation. This abbreviation is made like this: we write down the first and the last letter of a word and between them we write the number of letters between the first and the last letters. That number is in decimal system and doesn't contain any leading zeroes. Thus, "localization" will be spelt as "l10n", and "internationalization» will be spelt as "i18n". You are suggested to automatize the process of changing the words with abbreviations. At that all too long words should be replaced by the abbreviation and the words that are not too long should not undergo any changes. Input Specification: The first line contains an integer *n* (1<=≤<=*n*<=≤<=100). Each of the following *n* lines contains one word. All the words consist of lowercase Latin letters and possess the lengths of from 1 to 100 characters. Output Specification: Print *n* lines. The *i*-th line should contain the result of replacing of the *i*-th word from the input data. Demo Input: ['4\nword\nlocalization\ninternationalization\npneumonoultramicroscopicsilicovolcanoconiosis\n'] Demo Output: ['word\nl10n\ni18n\np43s\n'] Note: none

```python # -*- coding: utf-8 -*- # @Author: Fei_xiangShi # @Date: 2023-01-25 14:18:18 # @Last Modified by: FXS # @Last Modified time: 2023-01-25 14:21:29 n = int(input()) for _ in range(n): a = input() if len(a) < 11: print(a) else: print(a[0]+str(len(a)-2)+a[-1]) ```

3.969

427

A

Police Recruits

PROGRAMMING

800

[ "implementation" ]

null

The police department of your city has just started its journey. Initially, they don’t have any manpower. So, they started hiring new recruits in groups. Meanwhile, crimes keeps occurring within the city. One member of the police force can investigate only one crime during his/her lifetime. If there is no police officer free (isn't busy with crime) during the occurrence of a crime, it will go untreated. Given the chronological order of crime occurrences and recruit hirings, find the number of crimes which will go untreated.

The first line of input will contain an integer *n* (1<=≤<=*n*<=≤<=105), the number of events. The next line will contain *n* space-separated integers. If the integer is -1 then it means a crime has occurred. Otherwise, the integer will be positive, the number of officers recruited together at that time. No more than 10 officers will be recruited at a time.

Print a single integer, the number of crimes which will go untreated.

[ "3\n-1 -1 1\n", "8\n1 -1 1 -1 -1 1 1 1\n", "11\n-1 -1 2 -1 -1 -1 -1 -1 -1 -1 -1\n" ]

[ "2\n", "1\n", "8\n" ]

Lets consider the second example: 1. Firstly one person is hired. 1. Then crime appears, the last hired person will investigate this crime. 1. One more person is hired. 1. One more crime appears, the last hired person will investigate this crime. 1. Crime appears. There is no free policeman at the time, so this crime will go untreated. 1. One more person is hired. 1. One more person is hired. 1. One more person is hired. The answer is one, as one crime (on step 5) will go untreated.

500

[ { "input": "3\n-1 -1 1", "output": "2" }, { "input": "8\n1 -1 1 -1 -1 1 1 1", "output": "1" }, { "input": "11\n-1 -1 2 -1 -1 -1 -1 -1 -1 -1 -1", "output": "8" }, { "input": "7\n-1 -1 1 1 -1 -1 1", "output": "2" }, { "input": "21\n-1 -1 -1 -1 -1 3 2 -1 6 -1 -1 2 1 -1 2 2 1 6 5 -1 5", "output": "5" }, { "input": "98\n-1 -1 1 -1 -1 -1 -1 1 -1 -1 1 -1 -1 1 -1 1 1 1 -1 1 1 1 1 1 -1 1 -1 -1 -1 -1 1 -1 -1 1 1 -1 1 1 1 -1 -1 -1 -1 -1 -1 1 -1 -1 -1 1 -1 1 -1 1 -1 1 1 1 1 1 1 1 -1 -1 1 1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 1 -1 1 1 1 -1 1 1 -1 -1 -1 1 1 1 -1 -1 -1 1 -1 1 1", "output": "13" }, { "input": "3\n-1 5 4", "output": "1" }, { "input": "146\n4 -1 -1 -1 -1 -1 -1 -1 -1 -1 4 -1 3 -1 3 -1 -1 1 4 -1 2 -1 -1 3 -1 -1 -1 4 1 -1 -1 -1 4 -1 -1 -1 -1 -1 -1 3 2 -1 3 2 4 5 2 4 1 5 -1 -1 2 -1 -1 1 -1 5 3 -1 1 2 2 3 5 3 -1 -1 3 -1 -1 3 5 5 -1 -1 5 -1 4 4 1 -1 -1 -1 2 1 -1 -1 -1 2 5 3 -1 -1 -1 3 -1 5 4 -1 1 -1 -1 3 -1 -1 3 1 1 2 -1 -1 -1 1 3 1 -1 2 -1 -1 5 5 -1 -1 3 4 5 1 -1 2 -1 -1 -1 3 -1 5 3 2 -1 2 -1 -1 5 -1 3 -1", "output": "5" }, { "input": "1\n2", "output": "0" }, { "input": "1\n-1", "output": "1" }, { "input": "2\n1 -1", "output": "0" }, { "input": "2\n-1 1", "output": "1" }, { "input": "2\n1 1", "output": "0" }, { "input": "2\n-1 -1", "output": "2" }, { "input": "4\n10 -1 -1 -1", "output": "0" }, { "input": "1\n1", "output": "0" }, { "input": "4\n-1 -1 1 1", "output": "2" } ]

1,684,007,644

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

3

31

0

v1=int(input()) v2=list(map(int,input().split())) s=0 j=0 for i in range(1,v1): if s>v2[i-1]: s-=1 if v2[i]<v2[i-1] : s+=v2[i-1]-v2[i] elif v2[i]==v2[i-1] and v2[i]>0: s+=v2[i] else: if s>=1: j+=s-1 else: j+=1 print(j)

Title: Police Recruits Time Limit: None seconds Memory Limit: None megabytes Problem Description: The police department of your city has just started its journey. Initially, they don’t have any manpower. So, they started hiring new recruits in groups. Meanwhile, crimes keeps occurring within the city. One member of the police force can investigate only one crime during his/her lifetime. If there is no police officer free (isn't busy with crime) during the occurrence of a crime, it will go untreated. Given the chronological order of crime occurrences and recruit hirings, find the number of crimes which will go untreated. Input Specification: The first line of input will contain an integer *n* (1<=≤<=*n*<=≤<=105), the number of events. The next line will contain *n* space-separated integers. If the integer is -1 then it means a crime has occurred. Otherwise, the integer will be positive, the number of officers recruited together at that time. No more than 10 officers will be recruited at a time. Output Specification: Print a single integer, the number of crimes which will go untreated. Demo Input: ['3\n-1 -1 1\n', '8\n1 -1 1 -1 -1 1 1 1\n', '11\n-1 -1 2 -1 -1 -1 -1 -1 -1 -1 -1\n'] Demo Output: ['2\n', '1\n', '8\n'] Note: Lets consider the second example: 1. Firstly one person is hired. 1. Then crime appears, the last hired person will investigate this crime. 1. One more person is hired. 1. One more crime appears, the last hired person will investigate this crime. 1. Crime appears. There is no free policeman at the time, so this crime will go untreated. 1. One more person is hired. 1. One more person is hired. 1. One more person is hired. The answer is one, as one crime (on step 5) will go untreated.

```python v1=int(input()) v2=list(map(int,input().split())) s=0 j=0 for i in range(1,v1): if s>v2[i-1]: s-=1 if v2[i]<v2[i-1] : s+=v2[i-1]-v2[i] elif v2[i]==v2[i-1] and v2[i]>0: s+=v2[i] else: if s>=1: j+=s-1 else: j+=1 print(j) ```

0

774

C

Maximum Number

PROGRAMMING

1,200

[ "*special", "constructive algorithms", "greedy", "implementation" ]

null

Stepan has the newest electronic device with a display. Different digits can be shown on it. Each digit is shown on a seven-section indicator like it is shown on the picture below. So, for example, to show the digit 3 on the display, 5 sections must be highlighted; and for the digit 6, 6 sections must be highlighted. The battery of the newest device allows to highlight at most *n* sections on the display. Stepan wants to know the maximum possible integer number which can be shown on the display of his newest device. Your task is to determine this number. Note that this number must not contain leading zeros. Assume that the size of the display is enough to show any integer.

The first line contains the integer *n* (2<=≤<=*n*<=≤<=100<=000) — the maximum number of sections which can be highlighted on the display.

Print the maximum integer which can be shown on the display of Stepan's newest device.

[ "2\n", "3\n" ]

[ "1\n", "7\n" ]

none

0

[ { "input": "2", "output": "1" }, { "input": "3", "output": "7" }, { "input": "4", "output": "11" }, { "input": "5", "output": "71" }, { "input": "6", "output": "111" }, { "input": "85651", "output": "7111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..." }, { "input": "85666", "output": "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..." }, { "input": "99999", "output": "7111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..." }, { "input": "100000", "output": "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..." }, { "input": "99998", "output": "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..." }, { "input": "9", "output": "7111" }, { "input": "99997", "output": "7111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..." }, { "input": "99996", "output": "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..." }, { "input": "99995", "output": "7111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..." }, { "input": "156", "output": "111111111111111111111111111111111111111111111111111111111111111111111111111111" }, { "input": "255", "output": "7111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" }, { "input": "4568", "output": "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..." }, { "input": "5431", "output": "7111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..." }, { "input": "6782", "output": "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..." }, { "input": "8343", "output": "7111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..." }, { "input": "9514", "output": "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111..." } ]

1,491,409,249

2,749

Python 3

WRONG_ANSWER

TESTS

3

46

4,608,000

n = int(input()) ans = '' if n % 2 == 0: for i in range(n//2): ans += '1' else: for i in range(n//2-1): ans += '1' ans += '7' print(ans)

Title: Maximum Number Time Limit: None seconds Memory Limit: None megabytes Problem Description: Stepan has the newest electronic device with a display. Different digits can be shown on it. Each digit is shown on a seven-section indicator like it is shown on the picture below. So, for example, to show the digit 3 on the display, 5 sections must be highlighted; and for the digit 6, 6 sections must be highlighted. The battery of the newest device allows to highlight at most *n* sections on the display. Stepan wants to know the maximum possible integer number which can be shown on the display of his newest device. Your task is to determine this number. Note that this number must not contain leading zeros. Assume that the size of the display is enough to show any integer. Input Specification: The first line contains the integer *n* (2<=≤<=*n*<=≤<=100<=000) — the maximum number of sections which can be highlighted on the display. Output Specification: Print the maximum integer which can be shown on the display of Stepan's newest device. Demo Input: ['2\n', '3\n'] Demo Output: ['1\n', '7\n'] Note: none

```python n = int(input()) ans = '' if n % 2 == 0: for i in range(n//2): ans += '1' else: for i in range(n//2-1): ans += '1' ans += '7' print(ans) ```

0

851

B

Arpa and an exam about geometry

PROGRAMMING

1,400

[ "geometry", "math" ]

null

Arpa is taking a geometry exam. Here is the last problem of the exam. You are given three points *a*,<=*b*,<=*c*. Find a point and an angle such that if we rotate the page around the point by the angle, the new position of *a* is the same as the old position of *b*, and the new position of *b* is the same as the old position of *c*. Arpa is doubting if the problem has a solution or not (i.e. if there exists a point and an angle satisfying the condition). Help Arpa determine if the question has a solution or not.

The only line contains six integers *a**x*,<=*a**y*,<=*b**x*,<=*b**y*,<=*c**x*,<=*c**y* (|*a**x*|,<=|*a**y*|,<=|*b**x*|,<=|*b**y*|,<=|*c**x*|,<=|*c**y*|<=≤<=109). It's guaranteed that the points are distinct.

Print "Yes" if the problem has a solution, "No" otherwise. You can print each letter in any case (upper or lower).

[ "0 1 1 1 1 0\n", "1 1 0 0 1000 1000\n" ]

[ "Yes\n", "No\n" ]

In the first sample test, rotate the page around (0.5, 0.5) by <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/9d845923f4d356a48d8ede337db0303821311f0c.png" style="max-width: 100.0%;max-height: 100.0%;"/>. In the second sample test, you can't find any solution.

1,000

[ { "input": "0 1 1 1 1 0", "output": "Yes" }, { "input": "1 1 0 0 1000 1000", "output": "No" }, { "input": "1 0 2 0 3 0", "output": "No" }, { "input": "3 4 0 0 4 3", "output": "Yes" }, { "input": "-1000000000 1 0 0 1000000000 1", "output": "Yes" }, { "input": "49152 0 0 0 0 81920", "output": "No" }, { "input": "1 -1 4 4 2 -3", "output": "No" }, { "input": "-2 -2 1 4 -2 0", "output": "No" }, { "input": "5 0 4 -2 0 1", "output": "No" }, { "input": "-4 -3 2 -1 -3 4", "output": "No" }, { "input": "-3 -3 5 2 3 -1", "output": "No" }, { "input": "-1000000000 -1000000000 0 0 1000000000 999999999", "output": "No" }, { "input": "-1000000000 -1000000000 0 0 1000000000 1000000000", "output": "No" }, { "input": "-357531221 381512519 -761132895 -224448284 328888775 -237692564", "output": "No" }, { "input": "264193194 -448876521 736684426 -633906160 -328597212 -47935734", "output": "No" }, { "input": "419578772 -125025887 169314071 89851312 961404059 21419450", "output": "No" }, { "input": "-607353321 -620687860 248029390 477864359 728255275 -264646027", "output": "No" }, { "input": "299948862 -648908808 338174789 841279400 -850322448 350263551", "output": "No" }, { "input": "48517753 416240699 7672672 272460100 -917845051 199790781", "output": "No" }, { "input": "-947393823 -495674431 211535284 -877153626 -522763219 -778236665", "output": "No" }, { "input": "-685673792 -488079395 909733355 385950193 -705890324 256550506", "output": "No" }, { "input": "-326038504 547872194 49630307 713863100 303770000 -556852524", "output": "No" }, { "input": "-706921242 -758563024 -588592101 -443440080 858751713 238854303", "output": "No" }, { "input": "-1000000000 -1000000000 0 1000000000 1000000000 -1000000000", "output": "Yes" }, { "input": "1000000000 1000000000 0 -1000000000 -1000000000 1000000000", "output": "Yes" }, { "input": "-999999999 -1000000000 0 0 1000000000 999999999", "output": "Yes" }, { "input": "-1000000000 -999999999 0 0 1000000000 999999999", "output": "No" }, { "input": "-1 -1000000000 0 1000000000 1 -1000000000", "output": "Yes" }, { "input": "0 1000000000 1 0 0 -1000000000", "output": "Yes" }, { "input": "0 1000000000 0 0 0 -1000000000", "output": "No" }, { "input": "0 1 1 2 2 3", "output": "No" }, { "input": "999999999 1000000000 0 0 -1000000000 -999999999", "output": "Yes" }, { "input": "0 0 1 1 2 0", "output": "Yes" }, { "input": "0 0 1 1 2 2", "output": "No" }, { "input": "1 1 2 2 3 3", "output": "No" }, { "input": "0 2 0 3 0 4", "output": "No" }, { "input": "1 1 1 2 1 3", "output": "No" }, { "input": "0 0 3 4 3 9", "output": "Yes" }, { "input": "589824 196608 262144 196608 0 0", "output": "Yes" }, { "input": "0 0 1000000000 1 1000000000 -999999999", "output": "No" }, { "input": "0 0 2 45 0 90", "output": "Yes" }, { "input": "0 0 0 2 0 1", "output": "No" }, { "input": "0 2 4 5 4 0", "output": "Yes" }, { "input": "0 0 2 0 4 0", "output": "No" }, { "input": "1 1 3 3 5 5", "output": "No" }, { "input": "1 1 2 2 3 1", "output": "Yes" } ]

1,504,538,941

3,241

Python 3

WRONG_ANSWER

PRETESTS

3

61

0

import math ax,ay,bx,by,cx,cy = map(int,input().split()) btx = (ax + cx) / 2.0 bty = (ay + cy) / 2.0 f = math.sqrt(pow(ax-btx,2)+pow(ay-bty,2)) a = math.sqrt(pow(bx-btx,2)+pow(by-bty,2)) c = math.sqrt(pow(cx-btx,2)+pow(cy-bty,2)) if (a == f)and c==f: print("Yes") else: print("No")

Title: Arpa and an exam about geometry Time Limit: None seconds Memory Limit: None megabytes Problem Description: Arpa is taking a geometry exam. Here is the last problem of the exam. You are given three points *a*,<=*b*,<=*c*. Find a point and an angle such that if we rotate the page around the point by the angle, the new position of *a* is the same as the old position of *b*, and the new position of *b* is the same as the old position of *c*. Arpa is doubting if the problem has a solution or not (i.e. if there exists a point and an angle satisfying the condition). Help Arpa determine if the question has a solution or not. Input Specification: The only line contains six integers *a**x*,<=*a**y*,<=*b**x*,<=*b**y*,<=*c**x*,<=*c**y* (|*a**x*|,<=|*a**y*|,<=|*b**x*|,<=|*b**y*|,<=|*c**x*|,<=|*c**y*|<=≤<=109). It's guaranteed that the points are distinct. Output Specification: Print "Yes" if the problem has a solution, "No" otherwise. You can print each letter in any case (upper or lower). Demo Input: ['0 1 1 1 1 0\n', '1 1 0 0 1000 1000\n'] Demo Output: ['Yes\n', 'No\n'] Note: In the first sample test, rotate the page around (0.5, 0.5) by <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/9d845923f4d356a48d8ede337db0303821311f0c.png" style="max-width: 100.0%;max-height: 100.0%;"/>. In the second sample test, you can't find any solution.

```python import math ax,ay,bx,by,cx,cy = map(int,input().split()) btx = (ax + cx) / 2.0 bty = (ay + cy) / 2.0 f = math.sqrt(pow(ax-btx,2)+pow(ay-bty,2)) a = math.sqrt(pow(bx-btx,2)+pow(by-bty,2)) c = math.sqrt(pow(cx-btx,2)+pow(cy-bty,2)) if (a == f)and c==f: print("Yes") else: print("No") ```

0

137

B

Permutation

PROGRAMMING

1,000

[ "greedy" ]

null

"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him. The sequence of *n* integers is called a permutation if it contains all integers from 1 to *n* exactly once. You are given an arbitrary sequence *a*1,<=*a*2,<=...,<=*a**n* containing *n* integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).

The first line of the input data contains an integer *n* (1<=≤<=*n*<=≤<=5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers *a**i* (1<=≤<=*a**i*<=≤<=5000,<=1<=≤<=*i*<=≤<=*n*).

Print the only number — the minimum number of changes needed to get the permutation.

[ "3\n3 1 2\n", "2\n2 2\n", "5\n5 3 3 3 1\n" ]

[ "0\n", "1\n", "2\n" ]

The first sample contains the permutation, which is why no replacements are required. In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation. In the third sample we can replace the second element with number 4 and the fourth element with number 2.

1,000

[ { "input": "3\n3 1 2", "output": "0" }, { "input": "2\n2 2", "output": "1" }, { "input": "5\n5 3 3 3 1", "output": "2" }, { "input": "5\n6 6 6 6 6", "output": "5" }, { "input": "10\n1 1 2 2 8 8 7 7 9 9", "output": "5" }, { "input": "8\n9 8 7 6 5 4 3 2", "output": "1" }, { "input": "15\n1 2 3 4 5 5 4 3 2 1 1 2 3 4 5", "output": "10" }, { "input": "1\n1", "output": "0" }, { "input": "1\n5000", "output": "1" }, { "input": "4\n5000 5000 5000 5000", "output": "4" }, { "input": "5\n3366 3461 4 5 4370", "output": "3" }, { "input": "10\n8 2 10 3 4 6 1 7 9 5", "output": "0" }, { "input": "10\n551 3192 3213 2846 3068 1224 3447 1 10 9", "output": "7" }, { "input": "15\n4 1459 12 4281 3241 2748 10 3590 14 845 3518 1721 2 2880 1974", "output": "10" }, { "input": "15\n15 1 8 2 13 11 12 7 3 14 6 10 9 4 5", "output": "0" }, { "input": "15\n2436 2354 4259 1210 2037 2665 700 3578 2880 973 1317 1024 24 3621 4142", "output": "15" }, { "input": "30\n28 1 3449 9 3242 4735 26 3472 15 21 2698 7 4073 3190 10 3 29 1301 4526 22 345 3876 19 12 4562 2535 2 630 18 27", "output": "14" }, { "input": "100\n50 39 95 30 66 78 2169 4326 81 31 74 34 80 40 19 48 97 63 82 6 88 16 21 57 92 77 10 1213 17 93 32 91 38 4375 29 75 44 22 4 45 14 2395 3254 59 3379 2 85 96 8 83 27 94 1512 2960 100 9 73 79 7 25 55 69 90 99 51 87 98 62 18 35 43 4376 4668 28 72 56 4070 61 65 36 54 4106 11 24 15 86 70 71 4087 23 13 76 20 4694 26 4962 4726 37 14 64", "output": "18" }, { "input": "100\n340 14 3275 2283 2673 1107 817 2243 1226 32 2382 3638 4652 418 68 4962 387 764 4647 159 1846 225 2760 4904 3150 403 3 2439 91 4428 92 4705 75 348 1566 1465 69 6 49 4 62 4643 564 1090 3447 1871 2255 139 24 99 2669 969 86 61 4550 158 4537 3993 1589 872 2907 1888 401 80 1825 1483 63 1 2264 4068 4113 2548 41 885 4806 36 67 167 4447 34 1248 2593 82 202 81 1783 1284 4973 16 43 95 7 865 2091 3008 1793 20 947 4912 3604", "output": "70" }, { "input": "1\n2", "output": "1" }, { "input": "2\n5000 5000", "output": "2" }, { "input": "2\n1 2", "output": "0" }, { "input": "2\n1 1", "output": "1" }, { "input": "2\n2 3", "output": "1" }, { "input": "2\n3 4", "output": "2" }, { "input": "10\n1 2 3 4 5 6 7 1000 10 10", "output": "2" } ]

1,619,336,452

2,147,483,647

Python 3

OK

TESTS

48

124

409,600

n=int(input()) a={*map(int,input().split())} k=0 for i in range(1,n+1): if i not in a:k+=1 print(k)

Title: Permutation Time Limit: None seconds Memory Limit: None megabytes Problem Description: "Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him. The sequence of *n* integers is called a permutation if it contains all integers from 1 to *n* exactly once. You are given an arbitrary sequence *a*1,<=*a*2,<=...,<=*a**n* containing *n* integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer). Input Specification: The first line of the input data contains an integer *n* (1<=≤<=*n*<=≤<=5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers *a**i* (1<=≤<=*a**i*<=≤<=5000,<=1<=≤<=*i*<=≤<=*n*). Output Specification: Print the only number — the minimum number of changes needed to get the permutation. Demo Input: ['3\n3 1 2\n', '2\n2 2\n', '5\n5 3 3 3 1\n'] Demo Output: ['0\n', '1\n', '2\n'] Note: The first sample contains the permutation, which is why no replacements are required. In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation. In the third sample we can replace the second element with number 4 and the fourth element with number 2.

```python n=int(input()) a={*map(int,input().split())} k=0 for i in range(1,n+1): if i not in a:k+=1 print(k) ```

3

764

B

Timofey and cubes

PROGRAMMING

900

[ "constructive algorithms", "implementation" ]

null

Young Timofey has a birthday today! He got kit of *n* cubes as a birthday present from his parents. Every cube has a number *a**i*, which is written on it. Timofey put all the cubes in a row and went to unpack other presents. In this time, Timofey's elder brother, Dima reordered the cubes using the following rule. Suppose the cubes are numbered from 1 to *n* in their order. Dima performs several steps, on step *i* he reverses the segment of cubes from *i*-th to (*n*<=-<=*i*<=+<=1)-th. He does this while *i*<=≤<=*n*<=-<=*i*<=+<=1. After performing the operations Dima went away, being very proud of himself. When Timofey returned to his cubes, he understood that their order was changed. Help Timofey as fast as you can and save the holiday — restore the initial order of the cubes using information of their current location.

The first line contains single integer *n* (1<=≤<=*n*<=≤<=2·105) — the number of cubes. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=109<=≤<=*a**i*<=≤<=109), where *a**i* is the number written on the *i*-th cube after Dima has changed their order.

Print *n* integers, separated by spaces — the numbers written on the cubes in their initial order. It can be shown that the answer is unique.

[ "7\n4 3 7 6 9 1 2\n", "8\n6 1 4 2 5 6 9 2\n" ]

[ "2 3 9 6 7 1 4", "2 1 6 2 5 4 9 6" ]

Consider the first sample. 1. At the begining row was [2, 3, 9, 6, 7, 1, 4]. 1. After first operation row was [4, 1, 7, 6, 9, 3, 2]. 1. After second operation row was [4, 3, 9, 6, 7, 1, 2]. 1. After third operation row was [4, 3, 7, 6, 9, 1, 2]. 1. At fourth operation we reverse just middle element, so nothing has changed. The final row is [4, 3, 7, 6, 9, 1, 2]. So the answer for this case is row [2, 3, 9, 6, 7, 1, 4].

1,000

[ { "input": "7\n4 3 7 6 9 1 2", "output": "2 3 9 6 7 1 4" }, { "input": "8\n6 1 4 2 5 6 9 2", "output": "2 1 6 2 5 4 9 6" }, { "input": "1\n1424", "output": "1424" }, { "input": "9\n-7 9 -4 9 -6 11 15 2 -10", "output": "-10 9 15 9 -6 11 -4 2 -7" }, { "input": "2\n21968 5686", "output": "5686 21968" }, { "input": "5\n241218936 -825949895 -84926813 491336344 -872198236", "output": "-872198236 -825949895 -84926813 491336344 241218936" }, { "input": "42\n-557774624 828320986 -345782722 -62979938 -681259411 -945983652 -139095040 832293378 -82572118 432027535 88438103 568183540 961782904 73543295 615958219 -5050584 322982437 -146046730 759453379 129267920 -819827396 -348156048 805080102 390723009 -771277251 -79011872 -592313207 528489973 656201270 -127795621 17284747 145139617 -565641608 83452176 -223074608 545811186 -657981923 -204657836 154779765 -476867246 180386291 202782486", "output": "202782486 828320986 -476867246 -62979938 -204657836 -945983652 545811186 832293378 83452176 432027535 145139617 568183540 -127795621 73543295 528489973 -5050584 -79011872 -146046730 390723009 129267920 -348156048 -819827396 805080102 759453379 -771277251 322982437 -592313207 615958219 656201270 961782904 17284747 88438103 -565641608 -82572118 -223074608 -139095040 -657981923 -681259411 154779765 -345782722 180386291 -557774624" }, { "input": "2\n1 2", "output": "2 1" }, { "input": "6\n1 2 3 4 5 6", "output": "6 2 4 3 5 1" }, { "input": "4\n0 1 2 3", "output": "3 1 2 0" }, { "input": "10\n1 2 3 4 5 6 7 8 9 10", "output": "10 2 8 4 6 5 7 3 9 1" }, { "input": "2\n4 5", "output": "5 4" }, { "input": "2\n1 5", "output": "5 1" }, { "input": "2\n2 5", "output": "5 2" }, { "input": "2\n3 4", "output": "4 3" }, { "input": "2\n10 0", "output": "0 10" }, { "input": "66\n8229 5299 5562 1259 2258 1126 5026 8796 3497 7111 6680 1180 1426 4821 3322 3502 400 2951 4187 417 5234 1266 7525 7648 417 9297 174 670 1790 4121 9737 938 4616 3402 2009 2461 474 3728 327 3353 9773 6818 8781 874 2209 1260 1647 6126 9287 9638 5049 1256 4459 863 1835 4822 6809 348 5053 7784 6927 2140 9173 7817 5095 4184", "output": "4184 5299 7817 1259 2140 1126 7784 8796 348 7111 4822 1180 863 4821 1256 3502 9638 2951 6126 417 1260 1266 874 7648 6818 9297 3353 670 3728 4121 2461 938 3402 4616 2009 9737 474 1790 327 174 9773 417 8781 7525 2209 5234 1647 4187 9287 400 5049 3322 4459 1426 1835 6680 6809 3497 5053 5026 6927 2258 9173 5562 5095 8229" } ]

1,510,233,313

2,147,483,647

PyPy 3

OK

TESTS

34

764

20,070,400

n = int(input()) a = list(map(int, input().split())) if n % 2 == 0: for i in range(n//2): if i % 2 == 0: print(a[-i - 1], end=' ') else: print(a[i], end=' ') for i in range(n//2, n): if i % 2 == 0: print(a[i], end=' ') else: print(a[-i - 1], end=' ') else: for i in range(n): if i % 2 == 0: print(a[-i - 1], end=' ') else: print(a[i], end=' ')

Title: Timofey and cubes Time Limit: None seconds Memory Limit: None megabytes Problem Description: Young Timofey has a birthday today! He got kit of *n* cubes as a birthday present from his parents. Every cube has a number *a**i*, which is written on it. Timofey put all the cubes in a row and went to unpack other presents. In this time, Timofey's elder brother, Dima reordered the cubes using the following rule. Suppose the cubes are numbered from 1 to *n* in their order. Dima performs several steps, on step *i* he reverses the segment of cubes from *i*-th to (*n*<=-<=*i*<=+<=1)-th. He does this while *i*<=≤<=*n*<=-<=*i*<=+<=1. After performing the operations Dima went away, being very proud of himself. When Timofey returned to his cubes, he understood that their order was changed. Help Timofey as fast as you can and save the holiday — restore the initial order of the cubes using information of their current location. Input Specification: The first line contains single integer *n* (1<=≤<=*n*<=≤<=2·105) — the number of cubes. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=109<=≤<=*a**i*<=≤<=109), where *a**i* is the number written on the *i*-th cube after Dima has changed their order. Output Specification: Print *n* integers, separated by spaces — the numbers written on the cubes in their initial order. It can be shown that the answer is unique. Demo Input: ['7\n4 3 7 6 9 1 2\n', '8\n6 1 4 2 5 6 9 2\n'] Demo Output: ['2 3 9 6 7 1 4', '2 1 6 2 5 4 9 6'] Note: Consider the first sample. 1. At the begining row was [2, 3, 9, 6, 7, 1, 4]. 1. After first operation row was [4, 1, 7, 6, 9, 3, 2]. 1. After second operation row was [4, 3, 9, 6, 7, 1, 2]. 1. After third operation row was [4, 3, 7, 6, 9, 1, 2]. 1. At fourth operation we reverse just middle element, so nothing has changed. The final row is [4, 3, 7, 6, 9, 1, 2]. So the answer for this case is row [2, 3, 9, 6, 7, 1, 4].

```python n = int(input()) a = list(map(int, input().split())) if n % 2 == 0: for i in range(n//2): if i % 2 == 0: print(a[-i - 1], end=' ') else: print(a[i], end=' ') for i in range(n//2, n): if i % 2 == 0: print(a[i], end=' ') else: print(a[-i - 1], end=' ') else: for i in range(n): if i % 2 == 0: print(a[-i - 1], end=' ') else: print(a[i], end=' ') ```

3

572

A

Arrays

PROGRAMMING

900

[ "sortings" ]

null

You are given two arrays *A* and *B* consisting of integers, sorted in non-decreasing order. Check whether it is possible to choose *k* numbers in array *A* and choose *m* numbers in array *B* so that any number chosen in the first array is strictly less than any number chosen in the second array.

The first line contains two integers *n**A*,<=*n**B* (1<=≤<=*n**A*,<=*n**B*<=≤<=105), separated by a space — the sizes of arrays *A* and *B*, correspondingly. The second line contains two integers *k* and *m* (1<=≤<=*k*<=≤<=*n**A*,<=1<=≤<=*m*<=≤<=*n**B*), separated by a space. The third line contains *n**A* numbers *a*1,<=*a*2,<=... *a**n**A* (<=-<=109<=≤<=*a*1<=≤<=*a*2<=≤<=...<=≤<=*a**n**A*<=≤<=109), separated by spaces — elements of array *A*. The fourth line contains *n**B* integers *b*1,<=*b*2,<=... *b**n**B* (<=-<=109<=≤<=*b*1<=≤<=*b*2<=≤<=...<=≤<=*b**n**B*<=≤<=109), separated by spaces — elements of array *B*.

Print "YES" (without the quotes), if you can choose *k* numbers in array *A* and *m* numbers in array *B* so that any number chosen in array *A* was strictly less than any number chosen in array *B*. Otherwise, print "NO" (without the quotes).

[ "3 3\n2 1\n1 2 3\n3 4 5\n", "3 3\n3 3\n1 2 3\n3 4 5\n", "5 2\n3 1\n1 1 1 1 1\n2 2\n" ]

[ "YES\n", "NO\n", "YES\n" ]

In the first sample test you can, for example, choose numbers 1 and 2 from array *A* and number 3 from array *B* (1 < 3 and 2 < 3). In the second sample test the only way to choose *k* elements in the first array and *m* elements in the second one is to choose all numbers in both arrays, but then not all the numbers chosen in *A* will be less than all the numbers chosen in *B*: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/7280148ed5eab0a7d418d4f92b32061243a8ca58.png" style="max-width: 100.0%;max-height: 100.0%;"/>.

500

[ { "input": "3 3\n2 1\n1 2 3\n3 4 5", "output": "YES" }, { "input": "3 3\n3 3\n1 2 3\n3 4 5", "output": "NO" }, { "input": "5 2\n3 1\n1 1 1 1 1\n2 2", "output": "YES" }, { "input": "3 5\n1 1\n5 5 5\n5 5 5 5 5", "output": "NO" }, { "input": "1 1\n1 1\n1\n1", "output": "NO" }, { "input": "3 3\n1 1\n1 2 3\n1 2 3", "output": "YES" }, { "input": "3 3\n1 2\n1 2 3\n1 2 3", "output": "YES" }, { "input": "3 3\n2 2\n1 2 3\n1 2 3", "output": "NO" }, { "input": "10 15\n10 1\n1 1 5 17 22 29 32 36 39 48\n9 10 20 23 26 26 32 32 33 39 43 45 47 49 49", "output": "YES" }, { "input": "10 15\n1 15\n91 91 91 92 92 94 94 95 98 100\n92 92 93 93 93 94 95 96 97 98 98 99 99 100 100", "output": "YES" }, { "input": "15 10\n12 5\n9 25 25 32 32 38 40 41 46 46 48 51 64 64 73\n5 14 30 35 50 52 67 79 89 99", "output": "YES" }, { "input": "15 10\n4 10\n22 32 35 45 45 50 51 55 79 80 83 88 90 92 93\n46 48 52 55 60 60 68 75 80 81", "output": "YES" }, { "input": "20 30\n2 8\n6 7 7 7 7 7 7 8 8 8 8 9 9 9 9 10 10 10 10 10\n1 1 2 2 2 2 2 2 2 3 3 4 5 5 5 5 6 6 6 6 6 6 7 7 7 8 8 9 10 10", "output": "NO" }, { "input": "20 30\n19 29\n1 1 2 2 2 3 4 4 7 7 7 8 8 8 8 8 9 9 9 9\n6 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 10 10 10 10 10 10 10 10 10 10 10 10 10 10", "output": "NO" }, { "input": "1 1\n1 1\n-1000000000\n30", "output": "YES" }, { "input": "3 3\n1 3\n1 3 3\n3 3 3", "output": "YES" }, { "input": "3 3\n1 1\n3 3 3\n2 2 2", "output": "NO" }, { "input": "5 5\n3 3\n1 5 6 7 8\n1 2 5 6 7", "output": "NO" }, { "input": "3 4\n2 2\n5 6 7\n1 2 3 4", "output": "NO" }, { "input": "3 3\n3 3\n1 2 3\n4 5 6", "output": "YES" }, { "input": "5 5\n4 5\n2 2 3 4 5\n5 6 7 8 9", "output": "YES" } ]

1,688,974,219

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

31

0

n, k, m = map(int, input().split()) a = sorted(list(map(int, input().split()))) b = sorted(list(map(int, input().split())), reverse=True) if a[k-1] < b[m-1]: print("YES") else: print("NO")

Title: Arrays Time Limit: None seconds Memory Limit: None megabytes Problem Description: You are given two arrays *A* and *B* consisting of integers, sorted in non-decreasing order. Check whether it is possible to choose *k* numbers in array *A* and choose *m* numbers in array *B* so that any number chosen in the first array is strictly less than any number chosen in the second array. Input Specification: The first line contains two integers *n**A*,<=*n**B* (1<=≤<=*n**A*,<=*n**B*<=≤<=105), separated by a space — the sizes of arrays *A* and *B*, correspondingly. The second line contains two integers *k* and *m* (1<=≤<=*k*<=≤<=*n**A*,<=1<=≤<=*m*<=≤<=*n**B*), separated by a space. The third line contains *n**A* numbers *a*1,<=*a*2,<=... *a**n**A* (<=-<=109<=≤<=*a*1<=≤<=*a*2<=≤<=...<=≤<=*a**n**A*<=≤<=109), separated by spaces — elements of array *A*. The fourth line contains *n**B* integers *b*1,<=*b*2,<=... *b**n**B* (<=-<=109<=≤<=*b*1<=≤<=*b*2<=≤<=...<=≤<=*b**n**B*<=≤<=109), separated by spaces — elements of array *B*. Output Specification: Print "YES" (without the quotes), if you can choose *k* numbers in array *A* and *m* numbers in array *B* so that any number chosen in array *A* was strictly less than any number chosen in array *B*. Otherwise, print "NO" (without the quotes). Demo Input: ['3 3\n2 1\n1 2 3\n3 4 5\n', '3 3\n3 3\n1 2 3\n3 4 5\n', '5 2\n3 1\n1 1 1 1 1\n2 2\n'] Demo Output: ['YES\n', 'NO\n', 'YES\n'] Note: In the first sample test you can, for example, choose numbers 1 and 2 from array *A* and number 3 from array *B* (1 < 3 and 2 < 3). In the second sample test the only way to choose *k* elements in the first array and *m* elements in the second one is to choose all numbers in both arrays, but then not all the numbers chosen in *A* will be less than all the numbers chosen in *B*: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/7280148ed5eab0a7d418d4f92b32061243a8ca58.png" style="max-width: 100.0%;max-height: 100.0%;"/>.

```python n, k, m = map(int, input().split()) a = sorted(list(map(int, input().split()))) b = sorted(list(map(int, input().split())), reverse=True) if a[k-1] < b[m-1]: print("YES") else: print("NO") ```

-1

382

A

Ksenia and Pan Scales

PROGRAMMING

1,100

[ "greedy", "implementation" ]

null

Ksenia has ordinary pan scales and several weights of an equal mass. Ksenia has already put some weights on the scales, while other weights are untouched. Ksenia is now wondering whether it is possible to put all the remaining weights on the scales so that the scales were in equilibrium. The scales is in equilibrium if the total sum of weights on the left pan is equal to the total sum of weights on the right pan.

The first line has a non-empty sequence of characters describing the scales. In this sequence, an uppercase English letter indicates a weight, and the symbol "|" indicates the delimiter (the character occurs in the sequence exactly once). All weights that are recorded in the sequence before the delimiter are initially on the left pan of the scale. All weights that are recorded in the sequence after the delimiter are initially on the right pan of the scale. The second line contains a non-empty sequence containing uppercase English letters. Each letter indicates a weight which is not used yet. It is guaranteed that all the English letters in the input data are different. It is guaranteed that the input does not contain any extra characters.

If you cannot put all the weights on the scales so that the scales were in equilibrium, print string "Impossible". Otherwise, print the description of the resulting scales, copy the format of the input. If there are multiple answers, print any of them.

[ "AC|T\nL\n", "|ABC\nXYZ\n", "W|T\nF\n", "ABC|\nD\n" ]

[ "AC|TL\n", "XYZ|ABC\n", "Impossible\n", "Impossible\n" ]

none

500

[ { "input": "AC|T\nL", "output": "AC|TL" }, { "input": "|ABC\nXYZ", "output": "XYZ|ABC" }, { "input": "W|T\nF", "output": "Impossible" }, { "input": "ABC|\nD", "output": "Impossible" }, { "input": "A|BC\nDEF", "output": "ADF|BCE" }, { "input": "|\nABC", "output": "Impossible" }, { "input": "|\nZXCVBANMIO", "output": "XVAMO|ZCBNI" }, { "input": "|C\nA", "output": "A|C" }, { "input": "|\nAB", "output": "B|A" }, { "input": "A|XYZ\nUIOPL", "output": "Impossible" }, { "input": "K|B\nY", "output": "Impossible" }, { "input": "EQJWDOHKZRBISPLXUYVCMNFGT|\nA", "output": "Impossible" }, { "input": "|MACKERIGZPVHNDYXJBUFLWSO\nQT", "output": "Impossible" }, { "input": "ERACGIZOVPT|WXUYMDLJNQS\nKB", "output": "ERACGIZOVPTB|WXUYMDLJNQSK" }, { "input": "CKQHRUZMISGE|FBVWPXDLTJYN\nOA", "output": "CKQHRUZMISGEA|FBVWPXDLTJYNO" }, { "input": "V|CMOEUTAXBFWSK\nDLRZJGIYNQHP", "output": "VDLRZJGIYNQHP|CMOEUTAXBFWSK" }, { "input": "QWHNMALDGKTJ|\nPBRYVXZUESCOIF", "output": "QWHNMALDGKTJF|PBRYVXZUESCOI" }, { "input": "|\nFXCVMUEWZAHNDOSITPRLKQJYBG", "output": "XVUWANOIPLQYG|FCMEZHDSTRKJB" }, { "input": "IB|PCGHZ\nFXWTJQNEKAUM", "output": "Impossible" }, { "input": "EC|IWAXQ\nJUHSRKGZTOMYN", "output": "ECJUHRGTMN|IWAXQSKZOY" }, { "input": "VDINYMA|UQKWBCLRHZJ\nXEGOF", "output": "Impossible" }, { "input": "ZLTPSIQUBAR|XFDEMYC\nHNOJWG", "output": "ZLTPSIQUBARG|XFDEMYCHNOJW" }, { "input": "R|FLZOTJNU\nGIYHKVX", "output": "RGIYHKVX|FLZOTJNU" }, { "input": "W|TL\nQROFSADYPKHEJNMXBZVUCIG", "output": "WQOSDPHJMBVCG|TLRFAYKENXZUI" }, { "input": "NRDFQSEKLAYMOT|ZH\nGUXIBJCVPW", "output": "Impossible" }, { "input": "FGRT|\nAC", "output": "Impossible" }, { "input": "|FGRT\nAC", "output": "Impossible" }, { "input": "A|\nB", "output": "A|B" }, { "input": "|A\nB", "output": "B|A" }, { "input": "|\nA", "output": "Impossible" }, { "input": "|\nQWERTYUIOPASDFGHJKLZXCVBNM", "output": "WRYIPSFHKZCBM|QETUOADGJLXVN" }, { "input": "QWERTYUIOPASDFGHJKLZXCVBN|\nM", "output": "Impossible" }, { "input": "QWERTY|VBN\nUIOPASDFGHJKLZXC", "output": "Impossible" }, { "input": "ABC|D\nKSL", "output": "Impossible" }, { "input": "A|BCDEF\nGH", "output": "Impossible" }, { "input": "|ABC\nD", "output": "Impossible" }, { "input": "A|BC\nDE", "output": "Impossible" }, { "input": "|ASD\nX", "output": "Impossible" }, { "input": "AB|CDEF\nXYZRT", "output": "Impossible" } ]

1,443,869,360

2,147,483,647

Python 3

OK

TESTS

39

62

0

def main(): mode="filee" if mode=="file":f=open("test.txt","r") #f.readline() #input() get = lambda :[str(x) for x in (f.readline()[:-1] if mode=="file" else input()).split("|")] scale = get() q = input() if abs(len(scale[0]) - len(scale[1]))%2 != len(q)%2 or abs(len(scale[0]) - len(scale[1]))>len(q): print("Impossible") return if len(scale[0])<len(scale[1]): mid = len(scale[1])-len(scale[0]) scale[0]+=q[:mid] else: mid = len(scale[0])-len(scale[1]) scale[1]+=q[:mid] for z in range(mid,len(q),2): scale[0]+=q[z] scale[1]+=q[z+1] print("|".join(scale)) if mode=="file":f.close() if __name__=="__main__": main()

Title: Ksenia and Pan Scales Time Limit: None seconds Memory Limit: None megabytes Problem Description: Ksenia has ordinary pan scales and several weights of an equal mass. Ksenia has already put some weights on the scales, while other weights are untouched. Ksenia is now wondering whether it is possible to put all the remaining weights on the scales so that the scales were in equilibrium. The scales is in equilibrium if the total sum of weights on the left pan is equal to the total sum of weights on the right pan. Input Specification: The first line has a non-empty sequence of characters describing the scales. In this sequence, an uppercase English letter indicates a weight, and the symbol "|" indicates the delimiter (the character occurs in the sequence exactly once). All weights that are recorded in the sequence before the delimiter are initially on the left pan of the scale. All weights that are recorded in the sequence after the delimiter are initially on the right pan of the scale. The second line contains a non-empty sequence containing uppercase English letters. Each letter indicates a weight which is not used yet. It is guaranteed that all the English letters in the input data are different. It is guaranteed that the input does not contain any extra characters. Output Specification: If you cannot put all the weights on the scales so that the scales were in equilibrium, print string "Impossible". Otherwise, print the description of the resulting scales, copy the format of the input. If there are multiple answers, print any of them. Demo Input: ['AC|T\nL\n', '|ABC\nXYZ\n', 'W|T\nF\n', 'ABC|\nD\n'] Demo Output: ['AC|TL\n', 'XYZ|ABC\n', 'Impossible\n', 'Impossible\n'] Note: none

```python def main(): mode="filee" if mode=="file":f=open("test.txt","r") #f.readline() #input() get = lambda :[str(x) for x in (f.readline()[:-1] if mode=="file" else input()).split("|")] scale = get() q = input() if abs(len(scale[0]) - len(scale[1]))%2 != len(q)%2 or abs(len(scale[0]) - len(scale[1]))>len(q): print("Impossible") return if len(scale[0])<len(scale[1]): mid = len(scale[1])-len(scale[0]) scale[0]+=q[:mid] else: mid = len(scale[0])-len(scale[1]) scale[1]+=q[:mid] for z in range(mid,len(q),2): scale[0]+=q[z] scale[1]+=q[z+1] print("|".join(scale)) if mode=="file":f.close() if __name__=="__main__": main() ```

3

897

A

Scarborough Fair

PROGRAMMING

800

[ "implementation" ]

null

Parsley, sage, rosemary and thyme. Remember me to one who lives there. He once was the true love of mine. Willem is taking the girl to the highest building in island No.28, however, neither of them knows how to get there. Willem asks his friend, Grick for directions, Grick helped them, and gave them a task. Although the girl wants to help, Willem insists on doing it by himself. Grick gave Willem a string of length *n*. Willem needs to do *m* operations, each operation has four parameters *l*,<=*r*,<=*c*1,<=*c*2, which means that all symbols *c*1 in range [*l*,<=*r*] (from *l*-th to *r*-th, including *l* and *r*) are changed into *c*2. String is 1-indexed. Grick wants to know the final string after all the *m* operations.

The first line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100). The second line contains a string *s* of length *n*, consisting of lowercase English letters. Each of the next *m* lines contains four parameters *l*,<=*r*,<=*c*1,<=*c*2 (1<=≤<=*l*<=≤<=*r*<=≤<=*n*, *c*1,<=*c*2 are lowercase English letters), separated by space.

Output string *s* after performing *m* operations described above.

[ "3 1\nioi\n1 1 i n\n", "5 3\nwxhak\n3 3 h x\n1 5 x a\n1 3 w g\n" ]

[ "noi", "gaaak" ]

For the second example: After the first operation, the string is wxxak. After the second operation, the string is waaak. After the third operation, the string is gaaak.

500

[ { "input": "3 1\nioi\n1 1 i n", "output": "noi" }, { "input": "5 3\nwxhak\n3 3 h x\n1 5 x a\n1 3 w g", "output": "gaaak" }, { "input": "9 51\nbhfbdcgff\n2 3 b b\n2 8 e f\n3 8 g f\n5 7 d a\n1 5 e b\n3 4 g b\n6 7 c d\n3 6 e g\n3 6 e h\n5 6 a e\n7 9 a c\n4 9 a h\n3 7 c b\n6 9 b g\n1 7 h b\n4 5 a e\n3 9 f a\n1 2 c h\n4 8 a c\n3 5 e d\n3 4 g f\n2 3 d h\n2 3 d e\n1 7 d g\n2 6 e g\n2 3 d g\n5 5 h h\n2 8 g d\n8 9 a f\n5 9 c e\n1 7 f d\n1 6 e e\n5 7 c a\n8 9 b b\n2 6 e b\n6 6 g h\n1 2 b b\n1 5 a f\n5 8 f h\n1 5 e g\n3 9 f h\n6 8 g a\n4 6 h g\n1 5 f a\n5 6 a c\n4 8 e d\n1 4 d g\n7 8 b f\n5 6 h b\n3 9 c e\n1 9 b a", "output": "aahaddddh" }, { "input": "28 45\ndcbbaddjhbeefjadjchgkhgggfha\n10 25 c a\n13 19 a f\n12 28 e d\n12 27 e a\n9 20 b e\n7 17 g d\n22 26 j j\n8 16 c g\n14 16 a d\n3 10 f c\n10 26 d b\n8 17 i e\n10 19 d i\n6 21 c j\n7 22 b k\n17 19 a i\n4 18 j k\n8 25 a g\n10 27 j e\n9 18 g d\n16 23 h a\n17 26 k e\n8 16 h f\n1 15 d f\n22 28 k k\n11 20 c k\n6 11 b h\n17 17 e i\n15 22 g h\n8 18 c f\n4 16 e a\n8 25 b c\n6 24 d g\n5 9 f j\n12 19 i h\n4 25 e f\n15 25 c j\n15 27 e e\n11 20 b f\n19 27 e k\n2 21 d a\n9 27 k e\n14 24 b a\n3 6 i g\n2 26 k f", "output": "fcbbajjfjaaefefehfahfagggfha" }, { "input": "87 5\nnfinedeojadjmgafnaogekfjkjfncnliagfchjfcmellgigjjcaaoeakdolchjcecljdeblmheimkibkgdkcdml\n47 56 a k\n51 81 o d\n5 11 j h\n48 62 j d\n16 30 k m", "output": "nfinedeohadjmgafnaogemfjmjfncnliagfchjfcmellgigddckkdekkddlchdcecljdeblmheimkibkgdkcdml" }, { "input": "5 16\nacfbb\n1 2 e f\n2 5 a f\n2 3 b e\n4 4 f a\n2 3 f a\n1 2 b e\n4 5 c d\n2 4 e c\n1 4 e a\n1 3 d c\n3 5 e b\n3 5 e b\n2 2 e d\n1 3 e c\n3 3 a e\n1 5 a a", "output": "acebb" }, { "input": "94 13\nbcaaaaaaccacddcdaacbdaabbcbaddbccbccbbbddbadddcccbddadddaadbdababadaacdcdbcdadabdcdcbcbcbcbbcd\n52 77 d d\n21 92 d b\n45 48 c b\n20 25 d a\n57 88 d b\n3 91 b d\n64 73 a a\n5 83 b d\n2 69 c c\n28 89 a b\n49 67 c b\n41 62 a c\n49 87 b c", "output": "bcaaaaaaccacddcdaacddaaddcdbdddccdccddddddbdddddcdddcdddccdddcdcdcdcccdcddcdcdcddcdcdcdcdcdbcd" }, { "input": "67 39\nacbcbccccbabaabcabcaaaaaaccbcbbcbaaaacbbcccbcbabbcacccbbabbabbabaac\n4 36 a b\n25 38 a a\n3 44 b c\n35 57 b a\n4 8 a c\n20 67 c a\n30 66 b b\n27 40 a a\n2 56 a b\n10 47 c a\n22 65 c b\n29 42 a b\n1 46 c b\n57 64 b c\n20 29 b a\n14 51 c a\n12 55 b b\n20 20 a c\n2 57 c a\n22 60 c b\n16 51 c c\n31 64 a c\n17 30 c a\n23 36 c c\n28 67 a c\n37 40 a c\n37 50 b c\n29 48 c b\n2 34 b c\n21 53 b a\n26 63 a c\n23 28 c a\n51 56 c b\n32 61 b b\n64 67 b b\n21 67 b c\n8 53 c c\n40 62 b b\n32 38 c c", "output": "accccccccaaaaaaaaaaaaaaaaaaaccccccccccccccccccccccccccccccccccccccc" }, { "input": "53 33\nhhcbhfafeececbhadfbdbehdfacfchbhdbfebdfeghebfcgdhehfh\n27 41 h g\n18 35 c b\n15 46 h f\n48 53 e g\n30 41 b c\n12 30 b f\n10 37 e f\n18 43 a h\n10 52 d a\n22 48 c e\n40 53 f d\n7 12 b h\n12 51 f a\n3 53 g a\n19 41 d h\n22 29 b h\n2 30 a b\n26 28 e h\n25 35 f a\n19 31 h h\n44 44 d e\n19 22 e c\n29 44 d h\n25 33 d h\n3 53 g c\n18 44 h b\n19 28 f e\n3 22 g h\n8 17 c a\n37 51 d d\n3 28 e h\n27 50 h h\n27 46 f b", "output": "hhcbhfbfhfababbbbbbbbbbbbbbbbbeaaeaaeaaeabebdeaahahdh" }, { "input": "83 10\nfhbecdgadecabbbecedcgfdcefcbgechbedagecgdgfgdaahchdgchbeaedgafdefecdchceececfcdhcdh\n9 77 e e\n26 34 b g\n34 70 b a\n40 64 e g\n33 78 h f\n14 26 a a\n17 70 d g\n56 65 a c\n8 41 d c\n11 82 c b", "output": "fhbecdgacebabbbebegbgfgbefbggebhgegagebgggfggaafbfggbfagbgggbfggfebgbfbeebebfbdhbdh" }, { "input": "1 4\ne\n1 1 c e\n1 1 e a\n1 1 e c\n1 1 d a", "output": "a" }, { "input": "71 21\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n61 61 a a\n32 56 a a\n10 67 a a\n7 32 a a\n26 66 a a\n41 55 a a\n49 55 a a\n4 61 a a\n53 59 a a\n37 58 a a\n7 63 a a\n39 40 a a\n51 64 a a\n27 37 a a\n22 71 a a\n4 45 a a\n7 8 a a\n43 46 a a\n19 28 a a\n51 54 a a\n14 67 a a", "output": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "30 4\neaaddabedcbbcccddbabdecadcecce\n2 17 c a\n16 29 e e\n16 21 c b\n7 11 b c", "output": "eaaddacedacbaaaddbabdecadcecce" }, { "input": "48 30\naaaabaabbaababbbaabaabaababbabbbaabbbaabaaaaaaba\n3 45 a b\n1 14 a a\n15 32 a b\n37 47 a b\n9 35 a b\n36 39 b b\n6 26 a b\n36 44 a a\n28 44 b a\n29 31 b a\n20 39 a a\n45 45 a b\n21 32 b b\n7 43 a b\n14 48 a b\n14 33 a b\n39 44 a a\n9 36 b b\n4 23 b b\n9 42 b b\n41 41 b a\n30 47 a b\n8 42 b a\n14 38 b b\n3 15 a a\n35 47 b b\n14 34 a b\n38 43 a b\n1 35 b a\n16 28 b a", "output": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbb" }, { "input": "89 29\nbabaabaaabaaaababbbbbbbabbbaaaaababbaababababbababaaabbababaaabbbbaaabaaaaaabaaabaabbabab\n39 70 b b\n3 56 b b\n5 22 b a\n4 39 a b\n41 87 b b\n34 41 a a\n10 86 a b\n29 75 a b\n2 68 a a\n27 28 b b\n42 51 b a\n18 61 a a\n6 67 b a\n47 63 a a\n8 68 a b\n4 74 b a\n19 65 a b\n8 55 a b\n5 30 a a\n3 65 a b\n16 57 a b\n34 56 b a\n1 70 a b\n59 68 b b\n29 57 b a\n47 49 b b\n49 73 a a\n32 61 b b\n29 42 a a", "output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbaaaabbbbbbbbbbbbbab" }, { "input": "59 14\nfbebcfabdefbaaedcefdeecababcabebadfbccaaedaebfdaefdbbcbebbe\n5 32 e f\n8 46 e e\n31 43 e f\n3 10 e a\n53 54 f d\n55 59 d a\n39 58 e b\n54 56 f a\n9 40 b e\n28 37 d a\n7 35 e b\n7 56 c f\n23 26 e a\n15 44 e d", "output": "fbabcfabdffbaafdfffdfffababfabfbaafdffaafdabbfdabfdbbfbbbbe" }, { "input": "7 17\nbbaabab\n3 5 a b\n5 7 a a\n5 5 a a\n4 4 b a\n7 7 a a\n5 6 b b\n1 3 b a\n6 7 a b\n4 6 a b\n6 6 a a\n2 4 b a\n1 7 b a\n4 6 b b\n2 5 b b\n2 5 a b\n1 4 a a\n4 4 b a", "output": "abbabaa" }, { "input": "100 1\ndebaaagbfdgehagadabfgheegggfghghgeeeabgceffeffggcbcegfgebbdhebhfagcgadcbdbabddbcadgbgdebdfehceehcaef\n13 99 f c", "output": "debaaagbfdgehagadabcgheegggcghghgeeeabgcecceccggcbcegcgebbdhebhcagcgadcbdbabddbcadgbgdebdcehceehcaef" }, { "input": "1 1\na\n1 1 a b", "output": "b" }, { "input": "100 1\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n1 100 a b", "output": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" }, { "input": "2 2\naa\n1 2 a b\n1 2 b c", "output": "cc" }, { "input": "3 3\naaa\n1 3 a b\n1 3 b c\n1 3 c d", "output": "ddd" }, { "input": "2 2\naa\n2 2 a b\n1 1 a b", "output": "bb" } ]

1,619,968,505

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

46

0

n,m=map(int,input().split()) s=list(intput()) for i in range(m): l,r,c1,c2=input().split() l=int(l) r=int(r) for j in range(l-1,r): if s[j]==c1: s[j]=c2 print("".join(s))

Title: Scarborough Fair Time Limit: None seconds Memory Limit: None megabytes Problem Description: Parsley, sage, rosemary and thyme. Remember me to one who lives there. He once was the true love of mine. Willem is taking the girl to the highest building in island No.28, however, neither of them knows how to get there. Willem asks his friend, Grick for directions, Grick helped them, and gave them a task. Although the girl wants to help, Willem insists on doing it by himself. Grick gave Willem a string of length *n*. Willem needs to do *m* operations, each operation has four parameters *l*,<=*r*,<=*c*1,<=*c*2, which means that all symbols *c*1 in range [*l*,<=*r*] (from *l*-th to *r*-th, including *l* and *r*) are changed into *c*2. String is 1-indexed. Grick wants to know the final string after all the *m* operations. Input Specification: The first line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100). The second line contains a string *s* of length *n*, consisting of lowercase English letters. Each of the next *m* lines contains four parameters *l*,<=*r*,<=*c*1,<=*c*2 (1<=≤<=*l*<=≤<=*r*<=≤<=*n*, *c*1,<=*c*2 are lowercase English letters), separated by space. Output Specification: Output string *s* after performing *m* operations described above. Demo Input: ['3 1\nioi\n1 1 i n\n', '5 3\nwxhak\n3 3 h x\n1 5 x a\n1 3 w g\n'] Demo Output: ['noi', 'gaaak'] Note: For the second example: After the first operation, the string is wxxak. After the second operation, the string is waaak. After the third operation, the string is gaaak.

```python n,m=map(int,input().split()) s=list(intput()) for i in range(m): l,r,c1,c2=input().split() l=int(l) r=int(r) for j in range(l-1,r): if s[j]==c1: s[j]=c2 print("".join(s)) ```

-1

620

A

Professor GukiZ's Robot

PROGRAMMING

800

[ "implementation", "math" ]

null

Professor GukiZ makes a new robot. The robot are in the point with coordinates (*x*1,<=*y*1) and should go to the point (*x*2,<=*y*2). In a single step the robot can change any of its coordinates (maybe both of them) by one (decrease or increase). So the robot can move in one of the 8 directions. Find the minimal number of steps the robot should make to get the finish position.

The first line contains two integers *x*1,<=*y*1 (<=-<=109<=≤<=*x*1,<=*y*1<=≤<=109) — the start position of the robot. The second line contains two integers *x*2,<=*y*2 (<=-<=109<=≤<=*x*2,<=*y*2<=≤<=109) — the finish position of the robot.

Print the only integer *d* — the minimal number of steps to get the finish position.

[ "0 0\n4 5\n", "3 4\n6 1\n" ]

[ "5\n", "3\n" ]

In the first example robot should increase both of its coordinates by one four times, so it will be in position (4, 4). After that robot should simply increase its *y* coordinate and get the finish position. In the second example robot should simultaneously increase *x* coordinate and decrease *y* coordinate by one three times.

0

[ { "input": "0 0\n4 5", "output": "5" }, { "input": "3 4\n6 1", "output": "3" }, { "input": "0 0\n4 6", "output": "6" }, { "input": "1 1\n-3 -5", "output": "6" }, { "input": "-1 -1\n-10 100", "output": "101" }, { "input": "1 -1\n100 -100", "output": "99" }, { "input": "-1000000000 -1000000000\n1000000000 1000000000", "output": "2000000000" }, { "input": "-1000000000 -1000000000\n0 999999999", "output": "1999999999" }, { "input": "0 0\n2 1", "output": "2" }, { "input": "10 0\n100 0", "output": "90" }, { "input": "1 5\n6 4", "output": "5" }, { "input": "0 0\n5 4", "output": "5" }, { "input": "10 1\n20 1", "output": "10" }, { "input": "1 1\n-3 4", "output": "4" }, { "input": "-863407280 504312726\n786535210 -661703810", "output": "1649942490" }, { "input": "-588306085 -741137832\n341385643 152943311", "output": "929691728" }, { "input": "0 0\n4 0", "output": "4" }, { "input": "93097194 -48405232\n-716984003 -428596062", "output": "810081197" }, { "input": "9 1\n1 1", "output": "8" }, { "input": "4 6\n0 4", "output": "4" }, { "input": "2 4\n5 2", "output": "3" }, { "input": "-100000000 -100000000\n100000000 100000123", "output": "200000123" }, { "input": "5 6\n5 7", "output": "1" }, { "input": "12 16\n12 1", "output": "15" }, { "input": "0 0\n5 1", "output": "5" }, { "input": "0 1\n1 1", "output": "1" }, { "input": "-44602634 913365223\n-572368780 933284951", "output": "527766146" }, { "input": "-2 0\n2 -2", "output": "4" }, { "input": "0 0\n3 1", "output": "3" }, { "input": "-458 2\n1255 4548", "output": "4546" }, { "input": "-5 -4\n-3 -3", "output": "2" }, { "input": "4 5\n7 3", "output": "3" }, { "input": "-1000000000 -999999999\n1000000000 999999998", "output": "2000000000" }, { "input": "-1000000000 -1000000000\n1000000000 -1000000000", "output": "2000000000" }, { "input": "-464122675 -898521847\n656107323 -625340409", "output": "1120229998" }, { "input": "-463154699 -654742385\n-699179052 -789004997", "output": "236024353" }, { "input": "982747270 -593488945\n342286841 -593604186", "output": "640460429" }, { "input": "-80625246 708958515\n468950878 574646184", "output": "549576124" }, { "input": "0 0\n1 0", "output": "1" }, { "input": "109810 1\n2 3", "output": "109808" }, { "input": "-9 0\n9 9", "output": "18" }, { "input": "9 9\n9 9", "output": "0" }, { "input": "1 1\n4 3", "output": "3" }, { "input": "1 2\n45 1", "output": "44" }, { "input": "207558188 -313753260\n-211535387 -721675423", "output": "419093575" }, { "input": "-11 0\n0 0", "output": "11" }, { "input": "-1000000000 1000000000\n1000000000 -1000000000", "output": "2000000000" }, { "input": "0 0\n1 1", "output": "1" }, { "input": "0 0\n0 1", "output": "1" }, { "input": "0 0\n-1 1", "output": "1" }, { "input": "0 0\n-1 0", "output": "1" }, { "input": "0 0\n-1 -1", "output": "1" }, { "input": "0 0\n0 -1", "output": "1" }, { "input": "0 0\n1 -1", "output": "1" }, { "input": "10 90\n90 10", "output": "80" }, { "input": "851016864 573579544\n-761410925 -380746263", "output": "1612427789" }, { "input": "1 9\n9 9", "output": "8" }, { "input": "1000 1000\n1000 1000", "output": "0" }, { "input": "1 9\n9 1", "output": "8" }, { "input": "1 90\n90 90", "output": "89" }, { "input": "100 100\n1000 1000", "output": "900" }, { "input": "-1 0\n0 0", "output": "1" }, { "input": "-750595959 -2984043\n649569876 -749608783", "output": "1400165835" }, { "input": "958048496 712083589\n423286949 810566863", "output": "534761547" }, { "input": "146316710 53945094\n-523054748 147499505", "output": "669371458" }, { "input": "50383856 -596516251\n-802950224 -557916272", "output": "853334080" }, { "input": "-637204864 -280290367\n-119020929 153679771", "output": "518183935" }, { "input": "-100 -100\n-60 -91", "output": "40" }, { "input": "337537326 74909428\n-765558776 167951547", "output": "1103096102" }, { "input": "0 81\n18 90", "output": "18" }, { "input": "283722202 -902633305\n-831696497 -160868946", "output": "1115418699" }, { "input": "1000 1000\n-1000 1000", "output": "2000" }, { "input": "5 6\n4 8", "output": "2" }, { "input": "40572000 597493595\n-935051731 368493185", "output": "975623731" }, { "input": "-5 5\n5 5", "output": "10" } ]

1,649,393,381

2,147,483,647

Python 3

OK

TESTS

75

62

409,600

#!/usr/bin/env python import math import sys import itertools import fractions if __name__ == '__main__': wtf = sys.stdin.read() wtf = wtf.strip().split('\n') x1,y1 = map(int, wtf[0].split()) x2,y2 = map(int, wtf[1].split()) print(max(abs(y1-y2),abs(x1-x2)))

Title: Professor GukiZ's Robot Time Limit: None seconds Memory Limit: None megabytes Problem Description: Professor GukiZ makes a new robot. The robot are in the point with coordinates (*x*1,<=*y*1) and should go to the point (*x*2,<=*y*2). In a single step the robot can change any of its coordinates (maybe both of them) by one (decrease or increase). So the robot can move in one of the 8 directions. Find the minimal number of steps the robot should make to get the finish position. Input Specification: The first line contains two integers *x*1,<=*y*1 (<=-<=109<=≤<=*x*1,<=*y*1<=≤<=109) — the start position of the robot. The second line contains two integers *x*2,<=*y*2 (<=-<=109<=≤<=*x*2,<=*y*2<=≤<=109) — the finish position of the robot. Output Specification: Print the only integer *d* — the minimal number of steps to get the finish position. Demo Input: ['0 0\n4 5\n', '3 4\n6 1\n'] Demo Output: ['5\n', '3\n'] Note: In the first example robot should increase both of its coordinates by one four times, so it will be in position (4, 4). After that robot should simply increase its *y* coordinate and get the finish position. In the second example robot should simultaneously increase *x* coordinate and decrease *y* coordinate by one three times.

```python #!/usr/bin/env python import math import sys import itertools import fractions if __name__ == '__main__': wtf = sys.stdin.read() wtf = wtf.strip().split('\n') x1,y1 = map(int, wtf[0].split()) x2,y2 = map(int, wtf[1].split()) print(max(abs(y1-y2),abs(x1-x2))) ```

3

292

B

Network Topology

PROGRAMMING

1,200

[ "graphs", "implementation" ]

null

This problem uses a simplified network topology model, please read the problem statement carefully and use it as a formal document as you develop the solution. Polycarpus continues working as a system administrator in a large corporation. The computer network of this corporation consists of *n* computers, some of them are connected by a cable. The computers are indexed by integers from 1 to *n*. It's known that any two computers connected by cable directly or through other computers Polycarpus decided to find out the network's topology. A network topology is the way of describing the network configuration, the scheme that shows the location and the connections of network devices. Polycarpus knows three main network topologies: bus, ring and star. A bus is the topology that represents a shared cable with all computers connected with it. In the ring topology the cable connects each computer only with two other ones. A star is the topology where all computers of a network are connected to the single central node. Let's represent each of these network topologies as a connected non-directed graph. A bus is a connected graph that is the only path, that is, the graph where all nodes are connected with two other ones except for some two nodes that are the beginning and the end of the path. A ring is a connected graph, where all nodes are connected with two other ones. A star is a connected graph, where a single central node is singled out and connected with all other nodes. For clarifications, see the picture. You've got a connected non-directed graph that characterizes the computer network in Polycarpus' corporation. Help him find out, which topology type the given network is. If that is impossible to do, say that the network's topology is unknown.

The first line contains two space-separated integers *n* and *m* (4<=≤<=*n*<=≤<=105; 3<=≤<=*m*<=≤<=105) — the number of nodes and edges in the graph, correspondingly. Next *m* lines contain the description of the graph's edges. The *i*-th line contains a space-separated pair of integers *x**i*, *y**i* (1<=≤<=*x**i*,<=*y**i*<=≤<=*n*) — the numbers of nodes that are connected by the *i*-the edge. It is guaranteed that the given graph is connected. There is at most one edge between any two nodes. No edge connects a node with itself.

In a single line print the network topology name of the given graph. If the answer is the bus, print "bus topology" (without the quotes), if the answer is the ring, print "ring topology" (without the quotes), if the answer is the star, print "star topology" (without the quotes). If no answer fits, print "unknown topology" (without the quotes).

[ "4 3\n1 2\n2 3\n3 4\n", "4 4\n1 2\n2 3\n3 4\n4 1\n", "4 3\n1 2\n1 3\n1 4\n", "4 4\n1 2\n2 3\n3 1\n1 4\n" ]

[ "bus topology\n", "ring topology\n", "star topology\n", "unknown topology\n" ]

none

1,000

[ { "input": "4 3\n1 2\n2 3\n3 4", "output": "bus topology" }, { "input": "4 4\n1 2\n2 3\n3 4\n4 1", "output": "ring topology" }, { "input": "4 3\n1 2\n1 3\n1 4", "output": "star topology" }, { "input": "4 4\n1 2\n2 3\n3 1\n1 4", "output": "unknown topology" }, { "input": "5 4\n1 2\n3 5\n1 4\n5 4", "output": "bus topology" }, { "input": "5 5\n3 4\n5 2\n2 1\n5 4\n3 1", "output": "ring topology" }, { "input": "5 4\n4 2\n5 2\n1 2\n2 3", "output": "star topology" }, { "input": "5 9\n5 3\n4 5\n3 1\n3 2\n2 1\n2 5\n1 5\n1 4\n4 2", "output": "unknown topology" }, { "input": "4 3\n2 4\n1 3\n4 1", "output": "bus topology" }, { "input": "4 4\n2 4\n4 1\n1 3\n2 3", "output": "ring topology" }, { "input": "4 3\n1 2\n2 4\n3 2", "output": "star topology" }, { "input": "4 4\n3 2\n2 4\n4 1\n1 2", "output": "unknown topology" }, { "input": "10 9\n10 6\n3 4\n8 9\n8 4\n6 1\n2 9\n5 1\n7 5\n10 3", "output": "bus topology" }, { "input": "10 10\n1 4\n3 6\n10 7\n5 8\n2 10\n3 4\n7 5\n9 6\n8 1\n2 9", "output": "ring topology" }, { "input": "10 9\n1 4\n4 10\n4 9\n8 4\n4 7\n4 5\n4 2\n4 6\n4 3", "output": "star topology" }, { "input": "10 14\n3 2\n7 2\n6 4\n8 1\n3 9\n5 6\n6 3\n4 1\n2 5\n7 10\n9 5\n7 1\n8 10\n3 4", "output": "unknown topology" }, { "input": "4 4\n1 2\n2 3\n2 4\n3 4", "output": "unknown topology" }, { "input": "5 4\n1 2\n1 3\n1 4\n4 5", "output": "unknown topology" }, { "input": "10 9\n10 1\n10 2\n10 3\n10 4\n10 5\n10 6\n10 7\n10 8\n10 9", "output": "star topology" }, { "input": "6 6\n1 2\n2 3\n3 1\n4 5\n5 6\n6 1", "output": "unknown topology" }, { "input": "6 5\n1 2\n1 3\n1 4\n4 5\n4 6", "output": "unknown topology" }, { "input": "4 4\n1 2\n2 3\n3 4\n4 2", "output": "unknown topology" }, { "input": "4 6\n1 2\n1 3\n1 4\n2 3\n2 4\n3 4", "output": "unknown topology" } ]

1,610,863,780

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

0

122

0

n,m = map(int, input().split()) adj = [[] for i in range(n+1)] for i in range(m): a,b = map(int, input().split()) adj[a].append(b) adj[b].append(a) edgeCount = [0] for i in range(1,n+1): edgeCount.append(len(adj[i])) edgeCountCount = [0 for i in range(n+1)] for i in edgeCount: edgeCountCount[i] += 1 print(edgeCountCount) if edgeCountCount[1] == 2 and edgeCountCount[2] == n-2: print('bus topology') elif edgeCountCount[2] == m: print('ring topology') elif edgeCountCount[1] == m and edgeCountCount[m] == 1: print('star topology') else: print('unknown topology')

Title: Network Topology Time Limit: None seconds Memory Limit: None megabytes Problem Description: This problem uses a simplified network topology model, please read the problem statement carefully and use it as a formal document as you develop the solution. Polycarpus continues working as a system administrator in a large corporation. The computer network of this corporation consists of *n* computers, some of them are connected by a cable. The computers are indexed by integers from 1 to *n*. It's known that any two computers connected by cable directly or through other computers Polycarpus decided to find out the network's topology. A network topology is the way of describing the network configuration, the scheme that shows the location and the connections of network devices. Polycarpus knows three main network topologies: bus, ring and star. A bus is the topology that represents a shared cable with all computers connected with it. In the ring topology the cable connects each computer only with two other ones. A star is the topology where all computers of a network are connected to the single central node. Let's represent each of these network topologies as a connected non-directed graph. A bus is a connected graph that is the only path, that is, the graph where all nodes are connected with two other ones except for some two nodes that are the beginning and the end of the path. A ring is a connected graph, where all nodes are connected with two other ones. A star is a connected graph, where a single central node is singled out and connected with all other nodes. For clarifications, see the picture. You've got a connected non-directed graph that characterizes the computer network in Polycarpus' corporation. Help him find out, which topology type the given network is. If that is impossible to do, say that the network's topology is unknown. Input Specification: The first line contains two space-separated integers *n* and *m* (4<=≤<=*n*<=≤<=105; 3<=≤<=*m*<=≤<=105) — the number of nodes and edges in the graph, correspondingly. Next *m* lines contain the description of the graph's edges. The *i*-th line contains a space-separated pair of integers *x**i*, *y**i* (1<=≤<=*x**i*,<=*y**i*<=≤<=*n*) — the numbers of nodes that are connected by the *i*-the edge. It is guaranteed that the given graph is connected. There is at most one edge between any two nodes. No edge connects a node with itself. Output Specification: In a single line print the network topology name of the given graph. If the answer is the bus, print "bus topology" (without the quotes), if the answer is the ring, print "ring topology" (without the quotes), if the answer is the star, print "star topology" (without the quotes). If no answer fits, print "unknown topology" (without the quotes). Demo Input: ['4 3\n1 2\n2 3\n3 4\n', '4 4\n1 2\n2 3\n3 4\n4 1\n', '4 3\n1 2\n1 3\n1 4\n', '4 4\n1 2\n2 3\n3 1\n1 4\n'] Demo Output: ['bus topology\n', 'ring topology\n', 'star topology\n', 'unknown topology\n'] Note: none

```python n,m = map(int, input().split()) adj = [[] for i in range(n+1)] for i in range(m): a,b = map(int, input().split()) adj[a].append(b) adj[b].append(a) edgeCount = [0] for i in range(1,n+1): edgeCount.append(len(adj[i])) edgeCountCount = [0 for i in range(n+1)] for i in edgeCount: edgeCountCount[i] += 1 print(edgeCountCount) if edgeCountCount[1] == 2 and edgeCountCount[2] == n-2: print('bus topology') elif edgeCountCount[2] == m: print('ring topology') elif edgeCountCount[1] == m and edgeCountCount[m] == 1: print('star topology') else: print('unknown topology') ```

0

614

B

Gena's Code

PROGRAMMING

1,400

[ "implementation", "math" ]

null

It's the year 4527 and the tanks game that we all know and love still exists. There also exists Great Gena's code, written in 2016. The problem this code solves is: given the number of tanks that go into the battle from each country, find their product. If it is turns to be too large, then the servers might have not enough time to assign tanks into teams and the whole game will collapse! There are exactly *n* distinct countries in the world and the *i*-th country added *a**i* tanks to the game. As the developers of the game are perfectionists, the number of tanks from each country is beautiful. A beautiful number, according to the developers, is such number that its decimal representation consists only of digits '1' and '0', moreover it contains at most one digit '1'. However, due to complaints from players, some number of tanks of one country was removed from the game, hence the number of tanks of this country may not remain beautiful. Your task is to write the program that solves exactly the same problem in order to verify Gena's code correctness. Just in case.

The first line of the input contains the number of countries *n* (1<=≤<=*n*<=≤<=100<=000). The second line contains *n* non-negative integers *a**i* without leading zeroes — the number of tanks of the *i*-th country. It is guaranteed that the second line contains at least *n*<=-<=1 beautiful numbers and the total length of all these number's representations doesn't exceed 100<=000.

Print a single number without leading zeroes — the product of the number of tanks presented by each country.

[ "3\n5 10 1\n", "4\n1 1 10 11\n", "5\n0 3 1 100 1\n" ]

[ "50", "110", "0" ]

In sample 1 numbers 10 and 1 are beautiful, number 5 is not not. In sample 2 number 11 is not beautiful (contains two '1's), all others are beautiful. In sample 3 number 3 is not beautiful, all others are beautiful.

1,000

[ { "input": "3\n5 10 1", "output": "50" }, { "input": "4\n1 1 10 11", "output": "110" }, { "input": "5\n0 3 1 100 1", "output": "0" }, { "input": "40\n10 100 10 1 10 10 100 10 10 100 10 100 100 10 1824868942 100 100 1 10 100 100 10 100 100 10 100 10 1 10 100 100 100 10 1 10 1 10 10 100 100", "output": "1824868942000000000000000000000000000000000000000000000000000" }, { "input": "6\n1000000000000000000000000000000000000 6643573784 1000000000000000000000000000000000000 1000000000000000000000000000000000000 1000000000000000000000000000000000000 1000000000000000000000000000000000000", "output": "6643573784000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }, { "input": "1\n0", "output": "0" }, { "input": "1\n1", "output": "1" }, { "input": "1\n9", "output": "9" }, { "input": "2\n10 50", "output": "500" }, { "input": "3\n500 1 10", "output": "5000" } ]

1,693,621,994

2,147,483,647

Python 3

OK

TESTS

32

265

2,560,000

# LUOGU_RID: 123536784 n=int(input()) ans=1 x=list(input().split()); while n>0: n-=1 ans*=int(x[n]) print(ans)

Title: Gena's Code Time Limit: None seconds Memory Limit: None megabytes Problem Description: It's the year 4527 and the tanks game that we all know and love still exists. There also exists Great Gena's code, written in 2016. The problem this code solves is: given the number of tanks that go into the battle from each country, find their product. If it is turns to be too large, then the servers might have not enough time to assign tanks into teams and the whole game will collapse! There are exactly *n* distinct countries in the world and the *i*-th country added *a**i* tanks to the game. As the developers of the game are perfectionists, the number of tanks from each country is beautiful. A beautiful number, according to the developers, is such number that its decimal representation consists only of digits '1' and '0', moreover it contains at most one digit '1'. However, due to complaints from players, some number of tanks of one country was removed from the game, hence the number of tanks of this country may not remain beautiful. Your task is to write the program that solves exactly the same problem in order to verify Gena's code correctness. Just in case. Input Specification: The first line of the input contains the number of countries *n* (1<=≤<=*n*<=≤<=100<=000). The second line contains *n* non-negative integers *a**i* without leading zeroes — the number of tanks of the *i*-th country. It is guaranteed that the second line contains at least *n*<=-<=1 beautiful numbers and the total length of all these number's representations doesn't exceed 100<=000. Output Specification: Print a single number without leading zeroes — the product of the number of tanks presented by each country. Demo Input: ['3\n5 10 1\n', '4\n1 1 10 11\n', '5\n0 3 1 100 1\n'] Demo Output: ['50', '110', '0'] Note: In sample 1 numbers 10 and 1 are beautiful, number 5 is not not. In sample 2 number 11 is not beautiful (contains two '1's), all others are beautiful. In sample 3 number 3 is not beautiful, all others are beautiful.

```python # LUOGU_RID: 123536784 n=int(input()) ans=1 x=list(input().split()); while n>0: n-=1 ans*=int(x[n]) print(ans) ```

3

842

B

Gleb And Pizza

PROGRAMMING

1,100

[ "geometry" ]

null

Gleb ordered pizza home. When the courier delivered the pizza, he was very upset, because several pieces of sausage lay on the crust, and he does not really like the crust. The pizza is a circle of radius *r* and center at the origin. Pizza consists of the main part — circle of radius *r*<=-<=*d* with center at the origin, and crust around the main part of the width *d*. Pieces of sausage are also circles. The radius of the *i* -th piece of the sausage is *r**i*, and the center is given as a pair (*x**i*, *y**i*). Gleb asks you to help determine the number of pieces of sausage caught on the crust. A piece of sausage got on the crust, if it completely lies on the crust.

First string contains two integer numbers *r* and *d* (0<=≤<=*d*<=<<=*r*<=≤<=500) — the radius of pizza and the width of crust. Next line contains one integer number *n* — the number of pieces of sausage (1<=≤<=*n*<=≤<=105). Each of next *n* lines contains three integer numbers *x**i*, *y**i* and *r**i* (<=-<=500<=≤<=*x**i*,<=*y**i*<=≤<=500, 0<=≤<=*r**i*<=≤<=500), where *x**i* and *y**i* are coordinates of the center of *i*-th peace of sausage, *r**i* — radius of *i*-th peace of sausage.

Output the number of pieces of sausage that lay on the crust.

[ "8 4\n7\n7 8 1\n-7 3 2\n0 2 1\n0 -2 2\n-3 -3 1\n0 6 2\n5 3 1\n", "10 8\n4\n0 0 9\n0 0 10\n1 0 1\n1 0 2\n" ]

[ "2\n", "0\n" ]

Below is a picture explaining the first example. Circles of green color denote pieces of sausage lying on the crust.

1,000

[ { "input": "8 4\n7\n7 8 1\n-7 3 2\n0 2 1\n0 -2 2\n-3 -3 1\n0 6 2\n5 3 1", "output": "2" }, { "input": "10 8\n4\n0 0 9\n0 0 10\n1 0 1\n1 0 2", "output": "0" }, { "input": "1 0\n1\n1 1 0", "output": "0" }, { "input": "3 0\n5\n3 0 0\n0 3 0\n-3 0 0\n0 -3 0\n3 0 1", "output": "4" }, { "input": "9 0\n5\n8 1 0\n8 2 0\n8 3 0\n-8 3 0\n-8 2 0", "output": "0" }, { "input": "10 2\n11\n1 1 0\n2 2 3\n3 3 0\n4 4 0\n5 5 0\n6 6 0\n7 7 4\n8 8 7\n9 9 3\n10 10 100\n9 0 1", "output": "2" }, { "input": "5 3\n1\n500 500 10", "output": "0" } ]

1,504,021,908

2,808

Python 3

WRONG_ANSWER

PRETESTS

4

46

0

# cook your dish here r,d=map(int,input().strip().split(' ')) n=int(input()) k=0 for i in range(n): x,y,r1=map(int,input().strip().split(' ')) dis=pow(x*x+y*y,.5) if(dis+r1<=r and dis-r1>=d): k+=1 print(k)

Title: Gleb And Pizza Time Limit: None seconds Memory Limit: None megabytes Problem Description: Gleb ordered pizza home. When the courier delivered the pizza, he was very upset, because several pieces of sausage lay on the crust, and he does not really like the crust. The pizza is a circle of radius *r* and center at the origin. Pizza consists of the main part — circle of radius *r*<=-<=*d* with center at the origin, and crust around the main part of the width *d*. Pieces of sausage are also circles. The radius of the *i* -th piece of the sausage is *r**i*, and the center is given as a pair (*x**i*, *y**i*). Gleb asks you to help determine the number of pieces of sausage caught on the crust. A piece of sausage got on the crust, if it completely lies on the crust. Input Specification: First string contains two integer numbers *r* and *d* (0<=≤<=*d*<=<<=*r*<=≤<=500) — the radius of pizza and the width of crust. Next line contains one integer number *n* — the number of pieces of sausage (1<=≤<=*n*<=≤<=105). Each of next *n* lines contains three integer numbers *x**i*, *y**i* and *r**i* (<=-<=500<=≤<=*x**i*,<=*y**i*<=≤<=500, 0<=≤<=*r**i*<=≤<=500), where *x**i* and *y**i* are coordinates of the center of *i*-th peace of sausage, *r**i* — radius of *i*-th peace of sausage. Output Specification: Output the number of pieces of sausage that lay on the crust. Demo Input: ['8 4\n7\n7 8 1\n-7 3 2\n0 2 1\n0 -2 2\n-3 -3 1\n0 6 2\n5 3 1\n', '10 8\n4\n0 0 9\n0 0 10\n1 0 1\n1 0 2\n'] Demo Output: ['2\n', '0\n'] Note: Below is a picture explaining the first example. Circles of green color denote pieces of sausage lying on the crust.

```python # cook your dish here r,d=map(int,input().strip().split(' ')) n=int(input()) k=0 for i in range(n): x,y,r1=map(int,input().strip().split(' ')) dis=pow(x*x+y*y,.5) if(dis+r1<=r and dis-r1>=d): k+=1 print(k) ```

0

379

A

New Year Candles

PROGRAMMING

1,000

[ "implementation" ]

null

Vasily the Programmer loves romance, so this year he decided to illuminate his room with candles. Vasily has *a* candles.When Vasily lights up a new candle, it first burns for an hour and then it goes out. Vasily is smart, so he can make *b* went out candles into a new candle. As a result, this new candle can be used like any other new candle. Now Vasily wonders: for how many hours can his candles light up the room if he acts optimally well? Help him find this number.

The single line contains two integers, *a* and *b* (1<=≤<=*a*<=≤<=1000; 2<=≤<=*b*<=≤<=1000).

Print a single integer — the number of hours Vasily can light up the room for.

[ "4 2\n", "6 3\n" ]

[ "7\n", "8\n" ]

Consider the first sample. For the first four hours Vasily lights up new candles, then he uses four burned out candles to make two new ones and lights them up. When these candles go out (stop burning), Vasily can make another candle. Overall, Vasily can light up the room for 7 hours.

500

[ { "input": "4 2", "output": "7" }, { "input": "6 3", "output": "8" }, { "input": "1000 1000", "output": "1001" }, { "input": "123 5", "output": "153" }, { "input": "1000 2", "output": "1999" }, { "input": "1 2", "output": "1" }, { "input": "1 3", "output": "1" }, { "input": "1 4", "output": "1" }, { "input": "2 2", "output": "3" }, { "input": "3 2", "output": "5" }, { "input": "3 3", "output": "4" }, { "input": "999 2", "output": "1997" }, { "input": "1000 3", "output": "1499" }, { "input": "1000 4", "output": "1333" }, { "input": "1 1000", "output": "1" }, { "input": "80 970", "output": "80" }, { "input": "80 970", "output": "80" }, { "input": "80 970", "output": "80" }, { "input": "80 970", "output": "80" }, { "input": "80 970", "output": "80" }, { "input": "80 970", "output": "80" }, { "input": "10 4", "output": "13" }, { "input": "4 3", "output": "5" }, { "input": "91 5", "output": "113" }, { "input": "777 17", "output": "825" }, { "input": "100 4", "output": "133" }, { "input": "5 3", "output": "7" }, { "input": "6 4", "output": "7" }, { "input": "26 8", "output": "29" }, { "input": "9 4", "output": "11" }, { "input": "20 3", "output": "29" }, { "input": "17 3", "output": "25" } ]

1,657,796,792

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

3

46

0

def calc_hours(a, b): hours = a a = int(a/b) if a >= 1: hours += calc_hours(a, b) return hours a_b = input() a = int(a_b.split()[0]) b = int(a_b.split()[1]) hours = calc_hours(a, b) print(hours)

Title: New Year Candles Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vasily the Programmer loves romance, so this year he decided to illuminate his room with candles. Vasily has *a* candles.When Vasily lights up a new candle, it first burns for an hour and then it goes out. Vasily is smart, so he can make *b* went out candles into a new candle. As a result, this new candle can be used like any other new candle. Now Vasily wonders: for how many hours can his candles light up the room if he acts optimally well? Help him find this number. Input Specification: The single line contains two integers, *a* and *b* (1<=≤<=*a*<=≤<=1000; 2<=≤<=*b*<=≤<=1000). Output Specification: Print a single integer — the number of hours Vasily can light up the room for. Demo Input: ['4 2\n', '6 3\n'] Demo Output: ['7\n', '8\n'] Note: Consider the first sample. For the first four hours Vasily lights up new candles, then he uses four burned out candles to make two new ones and lights them up. When these candles go out (stop burning), Vasily can make another candle. Overall, Vasily can light up the room for 7 hours.

```python def calc_hours(a, b): hours = a a = int(a/b) if a >= 1: hours += calc_hours(a, b) return hours a_b = input() a = int(a_b.split()[0]) b = int(a_b.split()[1]) hours = calc_hours(a, b) print(hours) ```

0

58

A

Chat room

PROGRAMMING

1,000

[ "greedy", "strings" ]

A. Chat room

1

256

Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word *s*. It is considered that Vasya managed to say hello if several letters can be deleted from the typed word so that it resulted in the word "hello". For example, if Vasya types the word "ahhellllloou", it will be considered that he said hello, and if he types "hlelo", it will be considered that Vasya got misunderstood and he didn't manage to say hello. Determine whether Vasya managed to say hello by the given word *s*.

The first and only line contains the word *s*, which Vasya typed. This word consisits of small Latin letters, its length is no less that 1 and no more than 100 letters.

If Vasya managed to say hello, print "YES", otherwise print "NO".

[ "ahhellllloou\n", "hlelo\n" ]

[ "YES\n", "NO\n" ]

none

500

[ { "input": "ahhellllloou", "output": "YES" }, { "input": "hlelo", "output": "NO" }, { "input": "helhcludoo", "output": "YES" }, { "input": "hehwelloho", "output": "YES" }, { "input": "pnnepelqomhhheollvlo", "output": "YES" }, { "input": "tymbzjyqhymedasloqbq", "output": "NO" }, { "input": "yehluhlkwo", "output": "NO" }, { "input": "hatlevhhalrohairnolsvocafgueelrqmlqlleello", "output": "YES" }, { "input": "hhhtehdbllnhwmbyhvelqqyoulretpbfokflhlhreeflxeftelziclrwllrpflflbdtotvlqgoaoqldlroovbfsq", "output": "YES" }, { "input": "rzlvihhghnelqtwlexmvdjjrliqllolhyewgozkuovaiezgcilelqapuoeglnwmnlftxxiigzczlouooi", "output": "YES" }, { "input": "pfhhwctyqdlkrwhebfqfelhyebwllhemtrmeblgrynmvyhioesqklclocxmlffuormljszllpoo", "output": "YES" }, { "input": "lqllcolohwflhfhlnaow", "output": "NO" }, { "input": "heheeellollvoo", "output": "YES" }, { "input": "hellooo", "output": "YES" }, { "input": "o", "output": "NO" }, { "input": "hhqhzeclohlehljlhtesllylrolmomvuhcxsobtsckogdv", "output": "YES" }, { "input": "yoegfuzhqsihygnhpnukluutocvvwuldiighpogsifealtgkfzqbwtmgghmythcxflebrkctlldlkzlagovwlstsghbouk", "output": "YES" }, { "input": "uatqtgbvrnywfacwursctpagasnhydvmlinrcnqrry", "output": "NO" }, { "input": "tndtbldbllnrwmbyhvqaqqyoudrstpbfokfoclnraefuxtftmgzicorwisrpfnfpbdtatvwqgyalqtdtrjqvbfsq", "output": "NO" }, { "input": "rzlvirhgemelnzdawzpaoqtxmqucnahvqnwldklrmjiiyageraijfivigvozgwngiulttxxgzczptusoi", "output": "YES" }, { "input": "kgyelmchocojsnaqdsyeqgnllytbqietpdlgknwwumqkxrexgdcnwoldicwzwofpmuesjuxzrasscvyuqwspm", "output": "YES" }, { "input": "pnyvrcotjvgynbeldnxieghfltmexttuxzyac", "output": "NO" }, { "input": "dtwhbqoumejligbenxvzhjlhosqojetcqsynlzyhfaevbdpekgbtjrbhlltbceobcok", "output": "YES" }, { "input": "crrfpfftjwhhikwzeedrlwzblckkteseofjuxjrktcjfsylmlsvogvrcxbxtffujqshslemnixoeezivksouefeqlhhokwbqjz", "output": "YES" }, { "input": "jhfbndhyzdvhbvhmhmefqllujdflwdpjbehedlsqfdsqlyelwjtyloxwsvasrbqosblzbowlqjmyeilcvotdlaouxhdpoeloaovb", "output": "YES" }, { "input": "hwlghueoemiqtjhhpashjsouyegdlvoyzeunlroypoprnhlyiwiuxrghekaylndhrhllllwhbebezoglydcvykllotrlaqtvmlla", "output": "YES" }, { "input": "wshiaunnqnqxodholbipwhhjmyeblhgpeleblklpzwhdunmpqkbuzloetmwwxmeltkrcomulxauzlwmlklldjodozxryghsnwgcz", "output": "YES" }, { "input": "shvksednttggehroewuiptvvxtrzgidravtnjwuqrlnnkxbplctzkckinpkgjopjfoxdbojtcvsuvablcbkrzajrlhgobkcxeqti", "output": "YES" }, { "input": "hyyhddqhxhekehkwfhlnlsihzefwchzerevcjtokefplholrbvxlltdlafjxrfhleglrvlolojoqaolagtbeyogxlbgfolllslli", "output": "YES" }, { "input": "iaagrdhhelxpdegueiulflquvlzidoprzkehthkldaytrjwhyhprwjxlltinxvuilxohqgjqcvkkdcuoliekcnlilwgqlnlzouoo", "output": "YES" }, { "input": "wfluaeseldgxyvxpwuhkptdmlflnlhktwxiabsvkolsquymrmhzczzoybvlilhmvsuunggvgxzgyyffk", "output": "NO" }, { "input": "loee", "output": "NO" }, { "input": "izdipwylefqmjbuoznfglgcfvedeouflkeehxbasaqmiooppfsqlhprospqgxvzrcpwlfdddngoqvpwvggsnvvxhmjoslwjudjlo", "output": "NO" }, { "input": "pplynflbjlseflaegzqpdxswgunhnlglqhycrbcwdfhclmcrwekkzsoosmfblljeenwfjyifcvxihhhbyhmhlkvtskeglaovjnsi", "output": "YES" }, { "input": "xqjqmenkodmlhzyzmmvofdngktygbbxbzpluzcohohmalkoeuwfikblltaaigv", "output": "NO" }, { "input": "hello", "output": "YES" }, { "input": "oohell", "output": "NO" }, { "input": "hell", "output": "NO" }, { "input": "eloellohoelo", "output": "NO" }, { "input": "helllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllo", "output": "YES" } ]

1,617,989,811

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

2

62

0

a=input() s='hello' for i in a: if i not in s: a=a.replace(i,'') x=[] new=[] for i in a: x.append(i) prev=None for i in x: if i!='l': if i!=prev: new.append(i) prev=i else: prev=i new.append('l') new=''.join(new) if new.count('l')>2: new=new.replace('l'*(new.count('l')-2),'') print('YES' if new==s else 'NO')

Title: Chat room Time Limit: 1 seconds Memory Limit: 256 megabytes Problem Description: Vasya has recently learned to type and log on to the Internet. He immediately entered a chat room and decided to say hello to everybody. Vasya typed the word *s*. It is considered that Vasya managed to say hello if several letters can be deleted from the typed word so that it resulted in the word "hello". For example, if Vasya types the word "ahhellllloou", it will be considered that he said hello, and if he types "hlelo", it will be considered that Vasya got misunderstood and he didn't manage to say hello. Determine whether Vasya managed to say hello by the given word *s*. Input Specification: The first and only line contains the word *s*, which Vasya typed. This word consisits of small Latin letters, its length is no less that 1 and no more than 100 letters. Output Specification: If Vasya managed to say hello, print "YES", otherwise print "NO". Demo Input: ['ahhellllloou\n', 'hlelo\n'] Demo Output: ['YES\n', 'NO\n'] Note: none

```python a=input() s='hello' for i in a: if i not in s: a=a.replace(i,'') x=[] new=[] for i in a: x.append(i) prev=None for i in x: if i!='l': if i!=prev: new.append(i) prev=i else: prev=i new.append('l') new=''.join(new) if new.count('l')>2: new=new.replace('l'*(new.count('l')-2),'') print('YES' if new==s else 'NO') ```

0

none

0

[ "none" ]

null

Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting. The game consists of multiple rounds. Its rules are very simple: in each round, a natural number *k* is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by *k*2, and the loser's score is multiplied by *k*. In the beginning of the game, both Slastyona and Pushok have scores equal to one. Unfortunately, Slastyona had lost her notepad where the history of all *n* games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.

In the first string, the number of games *n* (1<=≤<=*n*<=≤<=350000) is given. Each game is represented by a pair of scores *a*, *b* (1<=≤<=*a*,<=*b*<=≤<=109) – the results of Slastyona and Pushok, correspondingly.

For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise. You can output each letter in arbitrary case (upper or lower).

[ "6\n2 4\n75 45\n8 8\n16 16\n247 994\n1000000000 1000000\n" ]

[ "Yes\nYes\nYes\nNo\nNo\nYes\n" ]

First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won. The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.

0

[ { "input": "6\n2 4\n75 45\n8 8\n16 16\n247 994\n1000000000 1000000", "output": "Yes\nYes\nYes\nNo\nNo\nYes" }, { "input": "3\n1 1\n8 27\n1000 1331", "output": "Yes\nNo\nNo" }, { "input": "1\n12004 18012002", "output": "Yes" }, { "input": "1\n3331 11095561", "output": "Yes" }, { "input": "1\n2 3", "output": "No" }, { "input": "1\n1062961 1031", "output": "Yes" }, { "input": "1\n6 12", "output": "No" }, { "input": "1\n3 1", "output": "No" }, { "input": "1\n3 10", "output": "No" }, { "input": "1\n31159 970883281", "output": "Yes" }, { "input": "1\n9907 98148649", "output": "Yes" }, { "input": "1\n16 8", "output": "No" }, { "input": "1\n90 72", "output": "No" } ]

1,592,402,634

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

49

1,000

26,419,200

from sys import stdin test = stdin.readlines() n = int(test[0]) output = [] for i in range(1, n + 1): a, b = map(int, test[i].split()) p = a * b root = round(p ** (1 / 3)) ok = root ** 3 == p and a % root == b % root == 0 output.append('Yes' if ok else 'No') print('\n'.join(output))

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting. The game consists of multiple rounds. Its rules are very simple: in each round, a natural number *k* is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by *k*2, and the loser's score is multiplied by *k*. In the beginning of the game, both Slastyona and Pushok have scores equal to one. Unfortunately, Slastyona had lost her notepad where the history of all *n* games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not. Input Specification: In the first string, the number of games *n* (1<=≤<=*n*<=≤<=350000) is given. Each game is represented by a pair of scores *a*, *b* (1<=≤<=*a*,<=*b*<=≤<=109) – the results of Slastyona and Pushok, correspondingly. Output Specification: For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise. You can output each letter in arbitrary case (upper or lower). Demo Input: ['6\n2 4\n75 45\n8 8\n16 16\n247 994\n1000000000 1000000\n'] Demo Output: ['Yes\nYes\nYes\nNo\nNo\nYes\n'] Note: First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won. The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.

```python from sys import stdin test = stdin.readlines() n = int(test[0]) output = [] for i in range(1, n + 1): a, b = map(int, test[i].split()) p = a * b root = round(p ** (1 / 3)) ok = root ** 3 == p and a % root == b % root == 0 output.append('Yes' if ok else 'No') print('\n'.join(output)) ```

0

488

A

Giga Tower

PROGRAMMING

1,100

[ "brute force" ]

null

Giga Tower is the tallest and deepest building in Cyberland. There are 17<=777<=777<=777 floors, numbered from <=-<=8<=888<=888<=888 to 8<=888<=888<=888. In particular, there is floor 0 between floor <=-<=1 and floor 1. Every day, thousands of tourists come to this place to enjoy the wonderful view. In Cyberland, it is believed that the number "8" is a lucky number (that's why Giga Tower has 8<=888<=888<=888 floors above the ground), and, an integer is lucky, if and only if its decimal notation contains at least one digit "8". For example, 8,<=<=-<=180,<=808 are all lucky while 42,<=<=-<=10 are not. In the Giga Tower, if you write code at a floor with lucky floor number, good luck will always be with you (Well, this round is #278, also lucky, huh?). Tourist Henry goes to the tower to seek good luck. Now he is at the floor numbered *a*. He wants to find the minimum positive integer *b*, such that, if he walks *b* floors higher, he will arrive at a floor with a lucky number.

The only line of input contains an integer *a* (<=-<=109<=≤<=*a*<=≤<=109).

Print the minimum *b* in a line.

[ "179\n", "-1\n", "18\n" ]

[ "1\n", "9\n", "10\n" ]

For the first sample, he has to arrive at the floor numbered 180. For the second sample, he will arrive at 8. Note that *b* should be positive, so the answer for the third sample is 10, not 0.

500

[ { "input": "179", "output": "1" }, { "input": "-1", "output": "9" }, { "input": "18", "output": "10" }, { "input": "-410058385", "output": "1" }, { "input": "-586825624", "output": "1" }, { "input": "852318890", "output": "1" }, { "input": "919067153", "output": "5" }, { "input": "690422411", "output": "7" }, { "input": "-408490162", "output": "1" }, { "input": "-8", "output": "16" }, { "input": "-6", "output": "14" }, { "input": "-4", "output": "12" }, { "input": "-2", "output": "10" }, { "input": "0", "output": "8" }, { "input": "2", "output": "6" }, { "input": "4", "output": "4" }, { "input": "6", "output": "2" }, { "input": "8", "output": "10" }, { "input": "1000000000", "output": "8" }, { "input": "-1000000000", "output": "2" }, { "input": "88888", "output": "1" }, { "input": "89", "output": "9" }, { "input": "-80000000", "output": "2" }, { "input": "-8888", "output": "1" }, { "input": "-17", "output": "9" }, { "input": "78", "output": "2" }, { "input": "-19", "output": "1" }, { "input": "-999999998", "output": "9" }, { "input": "-999999997", "output": "8" }, { "input": "999999997", "output": "1" }, { "input": "811111111", "output": "1" }, { "input": "-8", "output": "16" }, { "input": "-5", "output": "13" }, { "input": "-7", "output": "15" }, { "input": "1000000000", "output": "8" } ]

1,522,530,869

2,147,483,647

Python 3

OK

TESTS

35

93

7,065,600

n=int(input()) i=n+1 while True: d=str(i) if d.count('8')>=1: print(i-n) break else: i+=1

Title: Giga Tower Time Limit: None seconds Memory Limit: None megabytes Problem Description: Giga Tower is the tallest and deepest building in Cyberland. There are 17<=777<=777<=777 floors, numbered from <=-<=8<=888<=888<=888 to 8<=888<=888<=888. In particular, there is floor 0 between floor <=-<=1 and floor 1. Every day, thousands of tourists come to this place to enjoy the wonderful view. In Cyberland, it is believed that the number "8" is a lucky number (that's why Giga Tower has 8<=888<=888<=888 floors above the ground), and, an integer is lucky, if and only if its decimal notation contains at least one digit "8". For example, 8,<=<=-<=180,<=808 are all lucky while 42,<=<=-<=10 are not. In the Giga Tower, if you write code at a floor with lucky floor number, good luck will always be with you (Well, this round is #278, also lucky, huh?). Tourist Henry goes to the tower to seek good luck. Now he is at the floor numbered *a*. He wants to find the minimum positive integer *b*, such that, if he walks *b* floors higher, he will arrive at a floor with a lucky number. Input Specification: The only line of input contains an integer *a* (<=-<=109<=≤<=*a*<=≤<=109). Output Specification: Print the minimum *b* in a line. Demo Input: ['179\n', '-1\n', '18\n'] Demo Output: ['1\n', '9\n', '10\n'] Note: For the first sample, he has to arrive at the floor numbered 180. For the second sample, he will arrive at 8. Note that *b* should be positive, so the answer for the third sample is 10, not 0.

```python n=int(input()) i=n+1 while True: d=str(i) if d.count('8')>=1: print(i-n) break else: i+=1 ```

3

768

B

Code For 1

PROGRAMMING

1,600

[ "constructive algorithms", "dfs and similar", "divide and conquer" ]

null

Jon fought bravely to rescue the wildlings who were attacked by the white-walkers at Hardhome. On his arrival, Sam tells him that he wants to go to Oldtown to train at the Citadel to become a maester, so he can return and take the deceased Aemon's place as maester of Castle Black. Jon agrees to Sam's proposal and Sam sets off his journey to the Citadel. However becoming a trainee at the Citadel is not a cakewalk and hence the maesters at the Citadel gave Sam a problem to test his eligibility. Initially Sam has a list with a single element *n*. Then he has to perform certain operations on this list. In each operation Sam must remove any element *x*, such that *x*<=><=1, from the list and insert at the same position , , sequentially. He must continue with these operations until all the elements in the list are either 0 or 1. Now the masters want the total number of 1s in the range *l* to *r* (1-indexed). Sam wants to become a maester but unfortunately he cannot solve this problem. Can you help Sam to pass the eligibility test?

The first line contains three integers *n*, *l*, *r* (0<=≤<=*n*<=<<=250, 0<=≤<=*r*<=-<=*l*<=≤<=105, *r*<=≥<=1, *l*<=≥<=1) – initial element and the range *l* to *r*. It is guaranteed that *r* is not greater than the length of the final list.

Output the total number of 1s in the range *l* to *r* in the final sequence.

[ "7 2 5\n", "10 3 10\n" ]

[ "4\n", "5\n" ]

Consider first example: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/288fbb682a6fa1934a47b763d6851f9d32a06150.png" style="max-width: 100.0%;max-height: 100.0%;"/> Elements on positions from 2-nd to 5-th in list is [1, 1, 1, 1]. The number of ones is 4. For the second example: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/52e9bc51ef858cacc27fc274c7ba9419d5c1ded9.png" style="max-width: 100.0%;max-height: 100.0%;"/> Elements on positions from 3-rd to 10-th in list is [1, 1, 1, 0, 1, 0, 1, 0]. The number of ones is 5.

1,000

[ { "input": "7 2 5", "output": "4" }, { "input": "10 3 10", "output": "5" }, { "input": "56 18 40", "output": "20" }, { "input": "203 40 124", "output": "67" }, { "input": "903316762502 354723010040 354723105411", "output": "78355" }, { "input": "33534354842198 32529564319236 32529564342569", "output": "22239" }, { "input": "62518534961045 50734311240112 50734311287877", "output": "42439" }, { "input": "95173251245550 106288351347530 106288351372022", "output": "16565" }, { "input": "542 321 956", "output": "336" }, { "input": "3621 237 2637", "output": "2124" }, { "input": "9056 336 896", "output": "311" }, { "input": "36007 368 24490", "output": "13253" }, { "input": "244269 149154 244246", "output": "88609" }, { "input": "880234 669493 757150", "output": "73585" }, { "input": "3740160 1031384 1104236", "output": "64965" }, { "input": "11586121 15337246 15397874", "output": "41868" }, { "input": "38658997 35923164 35985664", "output": "36004" }, { "input": "192308932 207804787 207866400", "output": "44142" }, { "input": "950099012 175922161 176000556", "output": "69369" }, { "input": "2787326787 3799676481 3799680514", "output": "2618" }, { "input": "14417262581 8527979363 8528075536", "output": "80707" }, { "input": "39889373539 7747197212 7747278363", "output": "47105" }, { "input": "251772781087 70597428577 70597479816", "output": "46933" }, { "input": "0 1 1", "output": "0" }, { "input": "1 1 1", "output": "1" }, { "input": "3 2 3", "output": "2" }, { "input": "14 7 12", "output": "5" }, { "input": "1125899906842623 1 100001", "output": "100001" }, { "input": "1125899906842623 1125899906742623 1125899906842623", "output": "100001" }, { "input": "1000 1 1023", "output": "1000" }, { "input": "281474976710656 17179869184 17179869186", "output": "1" }, { "input": "2 2 2", "output": "0" }, { "input": "3 2 2", "output": "1" } ]

1,679,976,967

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

4

124

5,939,200

import sys def count_ones(n, l, r): def split(list1): for i in range(len(list1)): if list1[i] > 1: list1 = list1[:i] + [list1[i] // 2, list1[i] % 2, list1[i] // 2] + list1[i + 1:] return split(list1) return list1 lst = [n] lst = split(lst) sum = 0 for i in range(l - 1, r): if lst[i] == 1: sum += 1 return sum n, l, r = map(int, input().split()) print(count_ones(n, l, r))

Title: Code For 1 Time Limit: None seconds Memory Limit: None megabytes Problem Description: Jon fought bravely to rescue the wildlings who were attacked by the white-walkers at Hardhome. On his arrival, Sam tells him that he wants to go to Oldtown to train at the Citadel to become a maester, so he can return and take the deceased Aemon's place as maester of Castle Black. Jon agrees to Sam's proposal and Sam sets off his journey to the Citadel. However becoming a trainee at the Citadel is not a cakewalk and hence the maesters at the Citadel gave Sam a problem to test his eligibility. Initially Sam has a list with a single element *n*. Then he has to perform certain operations on this list. In each operation Sam must remove any element *x*, such that *x*<=><=1, from the list and insert at the same position , , sequentially. He must continue with these operations until all the elements in the list are either 0 or 1. Now the masters want the total number of 1s in the range *l* to *r* (1-indexed). Sam wants to become a maester but unfortunately he cannot solve this problem. Can you help Sam to pass the eligibility test? Input Specification: The first line contains three integers *n*, *l*, *r* (0<=≤<=*n*<=<<=250, 0<=≤<=*r*<=-<=*l*<=≤<=105, *r*<=≥<=1, *l*<=≥<=1) – initial element and the range *l* to *r*. It is guaranteed that *r* is not greater than the length of the final list. Output Specification: Output the total number of 1s in the range *l* to *r* in the final sequence. Demo Input: ['7 2 5\n', '10 3 10\n'] Demo Output: ['4\n', '5\n'] Note: Consider first example: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/288fbb682a6fa1934a47b763d6851f9d32a06150.png" style="max-width: 100.0%;max-height: 100.0%;"/> Elements on positions from 2-nd to 5-th in list is [1, 1, 1, 1]. The number of ones is 4. For the second example: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/52e9bc51ef858cacc27fc274c7ba9419d5c1ded9.png" style="max-width: 100.0%;max-height: 100.0%;"/> Elements on positions from 3-rd to 10-th in list is [1, 1, 1, 0, 1, 0, 1, 0]. The number of ones is 5.

```python import sys def count_ones(n, l, r): def split(list1): for i in range(len(list1)): if list1[i] > 1: list1 = list1[:i] + [list1[i] // 2, list1[i] % 2, list1[i] // 2] + list1[i + 1:] return split(list1) return list1 lst = [n] lst = split(lst) sum = 0 for i in range(l - 1, r): if lst[i] == 1: sum += 1 return sum n, l, r = map(int, input().split()) print(count_ones(n, l, r)) ```

-1

981

A

Antipalindrome

PROGRAMMING

900

[ "brute force", "implementation", "strings" ]

null

A string is a palindrome if it reads the same from the left to the right and from the right to the left. For example, the strings "kek", "abacaba", "r" and "papicipap" are palindromes, while the strings "abb" and "iq" are not. A substring $s[l \ldots r]$ ($1<=\leq<=l<=\leq<=r<=\leq<=|s|$) of a string $s<==<=s_{1}s_{2} \ldots s_{|s|}$ is the string $s_{l}s_{l<=+<=1} \ldots s_{r}$. Anna does not like palindromes, so she makes her friends call her Ann. She also changes all the words she reads in a similar way. Namely, each word $s$ is changed into its longest substring that is not a palindrome. If all the substrings of $s$ are palindromes, she skips the word at all. Some time ago Ann read the word $s$. What is the word she changed it into?

The first line contains a non-empty string $s$ with length at most $50$ characters, containing lowercase English letters only.

If there is such a substring in $s$ that is not a palindrome, print the maximum length of such a substring. Otherwise print $0$. Note that there can be multiple longest substrings that are not palindromes, but their length is unique.

[ "mew\n", "wuffuw\n", "qqqqqqqq\n" ]

[ "3\n", "5\n", "0\n" ]

"mew" is not a palindrome, so the longest substring of it that is not a palindrome, is the string "mew" itself. Thus, the answer for the first example is $3$. The string "uffuw" is one of the longest non-palindrome substrings (of length $5$) of the string "wuffuw", so the answer for the second example is $5$. All substrings of the string "qqqqqqqq" consist of equal characters so they are palindromes. This way, there are no non-palindrome substrings. Thus, the answer for the third example is $0$.

500

[ { "input": "mew", "output": "3" }, { "input": "wuffuw", "output": "5" }, { "input": "qqqqqqqq", "output": "0" }, { "input": "ijvji", "output": "4" }, { "input": "iiiiiii", "output": "0" }, { "input": "wobervhvvkihcuyjtmqhaaigvvgiaahqmtjyuchikvvhvrebow", "output": "49" }, { "input": "wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww", "output": "0" }, { "input": "wobervhvvkihcuyjtmqhaaigvahheoqleromusrartldojsjvy", "output": "50" }, { "input": "ijvxljt", "output": "7" }, { "input": "fyhcncnchyf", "output": "10" }, { "input": "ffffffffffff", "output": "0" }, { "input": "fyhcncfsepqj", "output": "12" }, { "input": "ybejrrlbcinttnicblrrjeby", "output": "23" }, { "input": "yyyyyyyyyyyyyyyyyyyyyyyyy", "output": "0" }, { "input": "ybejrrlbcintahovgjddrqatv", "output": "25" }, { "input": "oftmhcmclgyqaojljoaqyglcmchmtfo", "output": "30" }, { "input": "oooooooooooooooooooooooooooooooo", "output": "0" }, { "input": "oftmhcmclgyqaojllbotztajglsmcilv", "output": "32" }, { "input": "gxandbtgpbknxvnkjaajknvxnkbpgtbdnaxg", "output": "35" }, { "input": "gggggggggggggggggggggggggggggggggggg", "output": "0" }, { "input": "gxandbtgpbknxvnkjaygommzqitqzjfalfkk", "output": "36" }, { "input": "fcliblymyqckxvieotjooojtoeivxkcqymylbilcf", "output": "40" }, { "input": "fffffffffffffffffffffffffffffffffffffffffff", "output": "0" }, { "input": "fcliblymyqckxvieotjootiqwtyznhhvuhbaixwqnsy", "output": "43" }, { "input": "rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr", "output": "0" }, { "input": "rajccqwqnqmshmerpvjyfepxwpxyldzpzhctqjnstxyfmlhiy", "output": "49" }, { "input": "a", "output": "0" }, { "input": "abca", "output": "4" }, { "input": "aaaaabaaaaa", "output": "10" }, { "input": "aba", "output": "2" }, { "input": "asaa", "output": "4" }, { "input": "aabaa", "output": "4" }, { "input": "aabbaa", "output": "5" }, { "input": "abcdaaa", "output": "7" }, { "input": "aaholaa", "output": "7" }, { "input": "abcdefghijka", "output": "12" }, { "input": "aaadcba", "output": "7" }, { "input": "aaaabaaaa", "output": "8" }, { "input": "abaa", "output": "4" }, { "input": "abcbaa", "output": "6" }, { "input": "ab", "output": "2" }, { "input": "l", "output": "0" }, { "input": "aaaabcaaaa", "output": "10" }, { "input": "abbaaaaaabba", "output": "11" }, { "input": "abaaa", "output": "5" }, { "input": "baa", "output": "3" }, { "input": "aaaaaaabbba", "output": "11" }, { "input": "ccbcc", "output": "4" }, { "input": "bbbaaab", "output": "7" }, { "input": "abaaaaaaaa", "output": "10" }, { "input": "abaaba", "output": "5" }, { "input": "aabsdfaaaa", "output": "10" }, { "input": "aaaba", "output": "5" }, { "input": "aaabaaa", "output": "6" }, { "input": "baaabbb", "output": "7" }, { "input": "ccbbabbcc", "output": "8" }, { "input": "cabc", "output": "4" }, { "input": "aabcd", "output": "5" }, { "input": "abcdea", "output": "6" }, { "input": "bbabb", "output": "4" }, { "input": "aaaaabababaaaaa", "output": "14" }, { "input": "bbabbb", "output": "6" }, { "input": "aababd", "output": "6" }, { "input": "abaaaa", "output": "6" }, { "input": "aaaaaaaabbba", "output": "12" }, { "input": "aabca", "output": "5" }, { "input": "aaabccbaaa", "output": "9" }, { "input": "aaaaaaaaaaaaaaaaaaaab", "output": "21" }, { "input": "babb", "output": "4" }, { "input": "abcaa", "output": "5" }, { "input": "qwqq", "output": "4" }, { "input": "aaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaa", "output": "48" }, { "input": "aaab", "output": "4" }, { "input": "aaaaaabaaaaa", "output": "12" }, { "input": "wwuww", "output": "4" }, { "input": "aaaaabcbaaaaa", "output": "12" }, { "input": "aaabbbaaa", "output": "8" }, { "input": "aabcbaa", "output": "6" }, { "input": "abccdefccba", "output": "11" }, { "input": "aabbcbbaa", "output": "8" }, { "input": "aaaabbaaaa", "output": "9" }, { "input": "aabcda", "output": "6" }, { "input": "abbca", "output": "5" }, { "input": "aaaaaabbaaa", "output": "11" }, { "input": "sssssspssssss", "output": "12" }, { "input": "sdnmsdcs", "output": "8" }, { "input": "aaabbbccbbbaaa", "output": "13" }, { "input": "cbdbdc", "output": "6" }, { "input": "abb", "output": "3" }, { "input": "abcdefaaaa", "output": "10" }, { "input": "abbbaaa", "output": "7" }, { "input": "v", "output": "0" }, { "input": "abccbba", "output": "7" }, { "input": "axyza", "output": "5" }, { "input": "abcdefgaaaa", "output": "11" }, { "input": "aaabcdaaa", "output": "9" }, { "input": "aaaacaaaa", "output": "8" }, { "input": "aaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaa", "output": "42" }, { "input": "abbbaa", "output": "6" }, { "input": "abcdee", "output": "6" }, { "input": "oom", "output": "3" }, { "input": "aabcaa", "output": "6" }, { "input": "abba", "output": "3" }, { "input": "aaca", "output": "4" }, { "input": "aacbca", "output": "6" }, { "input": "ababa", "output": "4" }, { "input": "abcda", "output": "5" }, { "input": "cccaaccc", "output": "7" }, { "input": "aaabcda", "output": "7" }, { "input": "aa", "output": "0" }, { "input": "aabaaaa", "output": "7" }, { "input": "abbaaaa", "output": "7" }, { "input": "aaabcbaaa", "output": "8" }, { "input": "aabba", "output": "5" }, { "input": "xyxx", "output": "4" }, { "input": "aaaaaaaaaaaabc", "output": "14" }, { "input": "bbaaaabb", "output": "7" }, { "input": "aaabaa", "output": "6" }, { "input": "sssssabsssss", "output": "12" }, { "input": "bbbaaaabbb", "output": "9" }, { "input": "abbbbaaaa", "output": "9" }, { "input": "wwufuww", "output": "6" }, { "input": "oowoo", "output": "4" }, { "input": "cccaccc", "output": "6" }, { "input": "aaa", "output": "0" }, { "input": "bbbcc", "output": "5" }, { "input": "abcdef", "output": "6" }, { "input": "abbba", "output": "4" }, { "input": "aab", "output": "3" }, { "input": "aaba", "output": "4" }, { "input": "azbyaaa", "output": "7" }, { "input": "oooooiooooo", "output": "10" }, { "input": "aabbbbbaaaaaa", "output": "13" } ]

1,527,436,104

3,504

Python 3

OK

TESTS

133

93

0

def is_palindrome(s): for i in range(len(s) // 2): if s[i] != s[~i]: return False return True def max_anti(s, visited): if len(s) <= 1: return 0 ts = tuple(s) if ts in visited: return 0 visited.add(ts) if is_palindrome(s): return max(max_anti(s[1:], visited), max_anti(s[:-1], visited)) return len(s) def solve(s): if len(set(s)) <= 1: return 0 visited = set() return max_anti([x for x in s], visited) def main(): s = input().strip() result = solve(s) print(result) if __name__ == '__main__': main()

Title: Antipalindrome Time Limit: None seconds Memory Limit: None megabytes Problem Description: A string is a palindrome if it reads the same from the left to the right and from the right to the left. For example, the strings "kek", "abacaba", "r" and "papicipap" are palindromes, while the strings "abb" and "iq" are not. A substring $s[l \ldots r]$ ($1<=\leq<=l<=\leq<=r<=\leq<=|s|$) of a string $s<==<=s_{1}s_{2} \ldots s_{|s|}$ is the string $s_{l}s_{l<=+<=1} \ldots s_{r}$. Anna does not like palindromes, so she makes her friends call her Ann. She also changes all the words she reads in a similar way. Namely, each word $s$ is changed into its longest substring that is not a palindrome. If all the substrings of $s$ are palindromes, she skips the word at all. Some time ago Ann read the word $s$. What is the word she changed it into? Input Specification: The first line contains a non-empty string $s$ with length at most $50$ characters, containing lowercase English letters only. Output Specification: If there is such a substring in $s$ that is not a palindrome, print the maximum length of such a substring. Otherwise print $0$. Note that there can be multiple longest substrings that are not palindromes, but their length is unique. Demo Input: ['mew\n', 'wuffuw\n', 'qqqqqqqq\n'] Demo Output: ['3\n', '5\n', '0\n'] Note: "mew" is not a palindrome, so the longest substring of it that is not a palindrome, is the string "mew" itself. Thus, the answer for the first example is $3$. The string "uffuw" is one of the longest non-palindrome substrings (of length $5$) of the string "wuffuw", so the answer for the second example is $5$. All substrings of the string "qqqqqqqq" consist of equal characters so they are palindromes. This way, there are no non-palindrome substrings. Thus, the answer for the third example is $0$.

```python def is_palindrome(s): for i in range(len(s) // 2): if s[i] != s[~i]: return False return True def max_anti(s, visited): if len(s) <= 1: return 0 ts = tuple(s) if ts in visited: return 0 visited.add(ts) if is_palindrome(s): return max(max_anti(s[1:], visited), max_anti(s[:-1], visited)) return len(s) def solve(s): if len(set(s)) <= 1: return 0 visited = set() return max_anti([x for x in s], visited) def main(): s = input().strip() result = solve(s) print(result) if __name__ == '__main__': main() ```

3

53

D

Physical Education

PROGRAMMING

1,500

[ "sortings" ]

D. Physical Education

2

256

Vasya is a school PE teacher. Unlike other PE teachers, Vasya doesn't like it when the students stand in line according to their height. Instead, he demands that the children stand in the following order: *a*1,<=*a*2,<=...,<=*a**n*, where *a**i* is the height of the *i*-th student in the line and *n* is the number of students in the line. The children find it hard to keep in mind this strange arrangement, and today they formed the line in the following order: *b*1,<=*b*2,<=...,<=*b**n*, which upset Vasya immensely. Now Vasya wants to rearrange the children so that the resulting order is like this: *a*1,<=*a*2,<=...,<=*a**n*. During each move Vasya can swap two people who stand next to each other in the line. Help Vasya, find the sequence of swaps leading to the arrangement Vasya needs. It is not required to minimize the number of moves.

The first line contains an integer *n* (1<=≤<=*n*<=≤<=300) which is the number of students. The second line contains *n* space-separated integers *a**i* (1<=≤<=*a**i*<=≤<=109) which represent the height of the student occupying the *i*-th place must possess. The third line contains *n* space-separated integers *b**i* (1<=≤<=*b**i*<=≤<=109) which represent the height of the student occupying the *i*-th place in the initial arrangement. It is possible that some students possess similar heights. It is guaranteed that it is possible to arrange the children in the required order, i.e. *a* and *b* coincide as multisets.

In the first line print an integer *k* (0<=≤<=*k*<=≤<=106) which is the number of moves. It is not required to minimize *k* but it must not exceed 106. Then print *k* lines each containing two space-separated integers. Line *p**i*, *p**i*<=+<=1 (1<=≤<=*p**i*<=≤<=*n*<=-<=1) means that Vasya should swap students occupying places *p**i* and *p**i*<=+<=1.

[ "4\n1 2 3 2\n3 2 1 2\n", "2\n1 100500\n1 100500\n" ]

[ "4\n2 3\n1 2\n3 4\n2 3\n", "0\n" ]

none

2,000

[ { "input": "4\n1 2 3 2\n3 2 1 2", "output": "4\n2 3\n1 2\n3 4\n2 3" }, { "input": "2\n1 100500\n1 100500", "output": "0" }, { "input": "3\n652586118 652586118 652586118\n652586118 652586118 652586118", "output": "3\n2 3\n1 2\n2 3" }, { "input": "4\n681106577 681106577 675077178 675077178\n675077178 681106577 681106577 675077178", "output": "4\n2 3\n1 2\n2 3\n3 4" }, { "input": "5\n470138369 747764103 729004864 491957578 874531368\n874531368 729004864 491957578 747764103 470138369", "output": "9\n4 5\n3 4\n2 3\n1 2\n4 5\n3 4\n2 3\n3 4\n4 5" }, { "input": "6\n590202194 293471749 259345095 293471749 18056518 293471749\n293471749 293471749 293471749 18056518 259345095 590202194", "output": "12\n5 6\n4 5\n3 4\n2 3\n1 2\n3 4\n2 3\n5 6\n4 5\n3 4\n4 5\n5 6" }, { "input": "1\n873725529\n873725529", "output": "0" }, { "input": "1\n800950546\n800950546", "output": "0" }, { "input": "2\n344379439 344379439\n344379439 344379439", "output": "1\n1 2" }, { "input": "2\n305292852 305292852\n305292852 305292852", "output": "1\n1 2" } ]

1,652,221,425

2,147,483,647

Python 3

OK

TESTS

30

186

102,400

n = int(input()) a = list(map(int, input().split())) b = list(map(int, input().split())) x = [] y = [] f = 0 for i in range(n): for j in range(i,n): if a[i] == b[j]: f = j break # print(f) for j in range(f, i, -1): temp = b[j] b[j] = b[j-1] b[j-1] = temp x.append(j-1) y.append(j) print(len(x)) for i in range(len(x)): print(x[i]+1, y[i]+1)

Title: Physical Education Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Vasya is a school PE teacher. Unlike other PE teachers, Vasya doesn't like it when the students stand in line according to their height. Instead, he demands that the children stand in the following order: *a*1,<=*a*2,<=...,<=*a**n*, where *a**i* is the height of the *i*-th student in the line and *n* is the number of students in the line. The children find it hard to keep in mind this strange arrangement, and today they formed the line in the following order: *b*1,<=*b*2,<=...,<=*b**n*, which upset Vasya immensely. Now Vasya wants to rearrange the children so that the resulting order is like this: *a*1,<=*a*2,<=...,<=*a**n*. During each move Vasya can swap two people who stand next to each other in the line. Help Vasya, find the sequence of swaps leading to the arrangement Vasya needs. It is not required to minimize the number of moves. Input Specification: The first line contains an integer *n* (1<=≤<=*n*<=≤<=300) which is the number of students. The second line contains *n* space-separated integers *a**i* (1<=≤<=*a**i*<=≤<=109) which represent the height of the student occupying the *i*-th place must possess. The third line contains *n* space-separated integers *b**i* (1<=≤<=*b**i*<=≤<=109) which represent the height of the student occupying the *i*-th place in the initial arrangement. It is possible that some students possess similar heights. It is guaranteed that it is possible to arrange the children in the required order, i.e. *a* and *b* coincide as multisets. Output Specification: In the first line print an integer *k* (0<=≤<=*k*<=≤<=106) which is the number of moves. It is not required to minimize *k* but it must not exceed 106. Then print *k* lines each containing two space-separated integers. Line *p**i*, *p**i*<=+<=1 (1<=≤<=*p**i*<=≤<=*n*<=-<=1) means that Vasya should swap students occupying places *p**i* and *p**i*<=+<=1. Demo Input: ['4\n1 2 3 2\n3 2 1 2\n', '2\n1 100500\n1 100500\n'] Demo Output: ['4\n2 3\n1 2\n3 4\n2 3\n', '0\n'] Note: none

```python n = int(input()) a = list(map(int, input().split())) b = list(map(int, input().split())) x = [] y = [] f = 0 for i in range(n): for j in range(i,n): if a[i] == b[j]: f = j break # print(f) for j in range(f, i, -1): temp = b[j] b[j] = b[j-1] b[j-1] = temp x.append(j-1) y.append(j) print(len(x)) for i in range(len(x)): print(x[i]+1, y[i]+1) ```

3.953309

706

B

Interesting drink

PROGRAMMING

1,100

[ "binary search", "dp", "implementation" ]

null

Vasiliy likes to rest after a hard work, so you may often meet him in some bar nearby. As all programmers do, he loves the famous drink "Beecola", which can be bought in *n* different shops in the city. It's known that the price of one bottle in the shop *i* is equal to *x**i* coins. Vasiliy plans to buy his favorite drink for *q* consecutive days. He knows, that on the *i*-th day he will be able to spent *m**i* coins. Now, for each of the days he want to know in how many different shops he can buy a bottle of "Beecola".

The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of shops in the city that sell Vasiliy's favourite drink. The second line contains *n* integers *x**i* (1<=≤<=*x**i*<=≤<=100<=000) — prices of the bottles of the drink in the *i*-th shop. The third line contains a single integer *q* (1<=≤<=*q*<=≤<=100<=000) — the number of days Vasiliy plans to buy the drink. Then follow *q* lines each containing one integer *m**i* (1<=≤<=*m**i*<=≤<=109) — the number of coins Vasiliy can spent on the *i*-th day.

Print *q* integers. The *i*-th of them should be equal to the number of shops where Vasiliy will be able to buy a bottle of the drink on the *i*-th day.

[ "5\n3 10 8 6 11\n4\n1\n10\n3\n11\n" ]

[ "0\n4\n1\n5\n" ]

On the first day, Vasiliy won't be able to buy a drink in any of the shops. On the second day, Vasiliy can buy a drink in the shops 1, 2, 3 and 4. On the third day, Vasiliy can buy a drink only in the shop number 1. Finally, on the last day Vasiliy can buy a drink in any shop.

1,000

[ { "input": "5\n3 10 8 6 11\n4\n1\n10\n3\n11", "output": "0\n4\n1\n5" }, { "input": "5\n868 987 714 168 123\n10\n424\n192\n795\n873\n117\n914\n735\n158\n631\n471", "output": "2\n2\n3\n4\n0\n4\n3\n1\n2\n2" }, { "input": "3\n435 482 309\n7\n245\n241\n909\n745\n980\n29\n521", "output": "0\n0\n3\n3\n3\n0\n3" }, { "input": "1\n653\n9\n903\n980\n80\n770\n965\n874\n381\n657\n969", "output": "1\n1\n0\n1\n1\n1\n0\n1\n1" }, { "input": "12\n35345 58181 32223 84621 35905 73863 99537 30666 67771 39229 36847 29038\n23\n55052824\n82504840\n35160556\n78141700\n73401989\n86305919\n39430705\n31939373\n23501765\n4406029\n61436920\n14295390\n34275309\n28028753\n85724689\n70158847\n2396455\n66994588\n84024224\n30175981\n65622319\n76517111\n76605341", "output": "12\n12\n12\n12\n12\n12\n12\n12\n12\n12\n12\n12\n12\n12\n12\n12\n12\n12\n12\n12\n12\n12\n12" }, { "input": "4\n698 193 1584 76192\n4\n553640\n310518\n274280\n429192", "output": "4\n4\n4\n4" }, { "input": "1\n1\n1\n1000000000", "output": "1" }, { "input": "1\n1\n1\n100005", "output": "1" }, { "input": "3\n1 2 3\n1\n100005", "output": "3" }, { "input": "2\n1 2\n3\n100004\n100005\n100006", "output": "2\n2\n2" }, { "input": "3\n1 1 1\n1\n1", "output": "3" }, { "input": "1\n1\n1\n1", "output": "1" }, { "input": "3\n1 2 3\n1\n100000", "output": "3" }, { "input": "5\n1 1 1 1 10\n2\n1\n10", "output": "4\n5" }, { "input": "5\n3 10 8 6 11\n1\n10000000", "output": "5" } ]

1,699,283,080

2,147,483,647

Python 3

TIME_LIMIT_EXCEEDED

TESTS

10

2,000

12,390,400

n=int(input()) xi=list(map(int,input().split())) xi.sort() q=int(input()) for i in range(q): copyn=n copyxi=xi[:] m=int(input()) position=0 while copyn>1: marker=copyn//2 if copyxi[marker]<=m: copyxi=copyxi[marker:] position+=marker else: copyxi=copyxi[:marker] copyn=len(copyxi) if m>=xi[0]: position+=1 print(position)

Title: Interesting drink Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vasiliy likes to rest after a hard work, so you may often meet him in some bar nearby. As all programmers do, he loves the famous drink "Beecola", which can be bought in *n* different shops in the city. It's known that the price of one bottle in the shop *i* is equal to *x**i* coins. Vasiliy plans to buy his favorite drink for *q* consecutive days. He knows, that on the *i*-th day he will be able to spent *m**i* coins. Now, for each of the days he want to know in how many different shops he can buy a bottle of "Beecola". Input Specification: The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of shops in the city that sell Vasiliy's favourite drink. The second line contains *n* integers *x**i* (1<=≤<=*x**i*<=≤<=100<=000) — prices of the bottles of the drink in the *i*-th shop. The third line contains a single integer *q* (1<=≤<=*q*<=≤<=100<=000) — the number of days Vasiliy plans to buy the drink. Then follow *q* lines each containing one integer *m**i* (1<=≤<=*m**i*<=≤<=109) — the number of coins Vasiliy can spent on the *i*-th day. Output Specification: Print *q* integers. The *i*-th of them should be equal to the number of shops where Vasiliy will be able to buy a bottle of the drink on the *i*-th day. Demo Input: ['5\n3 10 8 6 11\n4\n1\n10\n3\n11\n'] Demo Output: ['0\n4\n1\n5\n'] Note: On the first day, Vasiliy won't be able to buy a drink in any of the shops. On the second day, Vasiliy can buy a drink in the shops 1, 2, 3 and 4. On the third day, Vasiliy can buy a drink only in the shop number 1. Finally, on the last day Vasiliy can buy a drink in any shop.

```python n=int(input()) xi=list(map(int,input().split())) xi.sort() q=int(input()) for i in range(q): copyn=n copyxi=xi[:] m=int(input()) position=0 while copyn>1: marker=copyn//2 if copyxi[marker]<=m: copyxi=copyxi[marker:] position+=marker else: copyxi=copyxi[:marker] copyn=len(copyxi) if m>=xi[0]: position+=1 print(position) ```

0

803

C

Maximal GCD

PROGRAMMING

1,900

[ "constructive algorithms", "greedy", "math" ]

null

You are given positive integer number *n*. You should create such strictly increasing sequence of *k* positive numbers *a*1,<=*a*2,<=...,<=*a**k*, that their sum is equal to *n* and greatest common divisor is maximal. Greatest common divisor of sequence is maximum of such numbers that every element of sequence is divisible by them. If there is no possible sequence then output -1.

The first line consists of two numbers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=1010).

If the answer exists then output *k* numbers — resulting sequence. Otherwise output -1. If there are multiple answers, print any of them.

[ "6 3\n", "8 2\n", "5 3\n" ]

[ "1 2 3\n", "2 6\n", "-1\n" ]

none

0

[ { "input": "6 3", "output": "1 2 3" }, { "input": "8 2", "output": "2 6" }, { "input": "5 3", "output": "-1" }, { "input": "1 1", "output": "1" }, { "input": "1 2", "output": "-1" }, { "input": "2 1", "output": "2" }, { "input": "2 10000000000", "output": "-1" }, { "input": "5 1", "output": "5" }, { "input": "6 2", "output": "2 4" }, { "input": "24 2", "output": "8 16" }, { "input": "24 3", "output": "4 8 12" }, { "input": "24 4", "output": "2 4 6 12" }, { "input": "24 5", "output": "1 2 3 4 14" }, { "input": "479001600 2", "output": "159667200 319334400" }, { "input": "479001600 3", "output": "79833600 159667200 239500800" }, { "input": "479001600 4", "output": "47900160 95800320 143700480 191600640" }, { "input": "479001600 5", "output": "31933440 63866880 95800320 127733760 159667200" }, { "input": "479001600 6", "output": "22809600 45619200 68428800 91238400 114048000 136857600" }, { "input": "3000000021 1", "output": "3000000021" }, { "input": "3000000021 2", "output": "1000000007 2000000014" }, { "input": "3000000021 3", "output": "3 6 3000000012" }, { "input": "3000000021 4", "output": "3 6 9 3000000003" }, { "input": "3000000021 50000", "output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155..." }, { "input": "3000000021 100000", "output": "-1" }, { "input": "10000000000 100", "output": "1953125 3906250 5859375 7812500 9765625 11718750 13671875 15625000 17578125 19531250 21484375 23437500 25390625 27343750 29296875 31250000 33203125 35156250 37109375 39062500 41015625 42968750 44921875 46875000 48828125 50781250 52734375 54687500 56640625 58593750 60546875 62500000 64453125 66406250 68359375 70312500 72265625 74218750 76171875 78125000 80078125 82031250 83984375 85937500 87890625 89843750 91796875 93750000 95703125 97656250 99609375 101562500 103515625 105468750 107421875 109375000 1113281..." }, { "input": "10000000000 2000", "output": "4000 8000 12000 16000 20000 24000 28000 32000 36000 40000 44000 48000 52000 56000 60000 64000 68000 72000 76000 80000 84000 88000 92000 96000 100000 104000 108000 112000 116000 120000 124000 128000 132000 136000 140000 144000 148000 152000 156000 160000 164000 168000 172000 176000 180000 184000 188000 192000 196000 200000 204000 208000 212000 216000 220000 224000 228000 232000 236000 240000 244000 248000 252000 256000 260000 264000 268000 272000 276000 280000 284000 288000 292000 296000 300000 304000 30800..." }, { "input": "10000000000 5000", "output": "640 1280 1920 2560 3200 3840 4480 5120 5760 6400 7040 7680 8320 8960 9600 10240 10880 11520 12160 12800 13440 14080 14720 15360 16000 16640 17280 17920 18560 19200 19840 20480 21120 21760 22400 23040 23680 24320 24960 25600 26240 26880 27520 28160 28800 29440 30080 30720 31360 32000 32640 33280 33920 34560 35200 35840 36480 37120 37760 38400 39040 39680 40320 40960 41600 42240 42880 43520 44160 44800 45440 46080 46720 47360 48000 48640 49280 49920 50560 51200 51840 52480 53120 53760 54400 55040 55680 56320..." }, { "input": "10000000000 100000", "output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155..." }, { "input": "10000000000 100000000", "output": "-1" }, { "input": "10000000000 10000000000", "output": "-1" }, { "input": "10000000000 100001", "output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155..." }, { "input": "1 4000000000", "output": "-1" }, { "input": "4294967296 4294967296", "output": "-1" }, { "input": "71227122 9603838834", "output": "-1" }, { "input": "10000000000 9603838835", "output": "-1" }, { "input": "5 5999999999", "output": "-1" }, { "input": "2 9324327498", "output": "-1" }, { "input": "9 2", "output": "3 6" }, { "input": "10000000000 4294967296", "output": "-1" }, { "input": "1 3500000000", "output": "-1" }, { "input": "10000000000 4000000000", "output": "-1" }, { "input": "2000 9324327498", "output": "-1" }, { "input": "10000000000 8589934592", "output": "-1" }, { "input": "5000150001 100001", "output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155..." }, { "input": "10000000000 3037000500", "output": "-1" }, { "input": "9400000000 9324327498", "output": "-1" }, { "input": "10000000000 3307000500", "output": "-1" }, { "input": "2 4000000000", "output": "-1" }, { "input": "1000 4294967295", "output": "-1" }, { "input": "36 3", "output": "6 12 18" }, { "input": "2147483648 4294967296", "output": "-1" }, { "input": "999 4294967295", "output": "-1" }, { "input": "10000000000 130000", "output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155..." }, { "input": "10000000000 140000", "output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155..." }, { "input": "10000000000 6074001000", "output": "-1" }, { "input": "12344321 1", "output": "12344321" }, { "input": "2 2", "output": "-1" }, { "input": "28 7", "output": "1 2 3 4 5 6 7" }, { "input": "1 1", "output": "1" }, { "input": "1 2", "output": "-1" }, { "input": "1 3", "output": "-1" }, { "input": "1 4", "output": "-1" }, { "input": "1 5", "output": "-1" }, { "input": "1 6", "output": "-1" }, { "input": "1 7", "output": "-1" }, { "input": "1 8", "output": "-1" }, { "input": "1 9", "output": "-1" }, { "input": "1 10", "output": "-1" }, { "input": "2 1", "output": "2" }, { "input": "2 2", "output": "-1" }, { "input": "2 3", "output": "-1" }, { "input": "2 4", "output": "-1" }, { "input": "2 5", "output": "-1" }, { "input": "2 6", "output": "-1" }, { "input": "2 7", "output": "-1" }, { "input": "2 8", "output": "-1" }, { "input": "2 9", "output": "-1" }, { "input": "2 10", "output": "-1" }, { "input": "3 1", "output": "3" }, { "input": "3 2", "output": "1 2" }, { "input": "3 3", "output": "-1" }, { "input": "3 4", "output": "-1" }, { "input": "3 5", "output": "-1" }, { "input": "3 6", "output": "-1" }, { "input": "3 7", "output": "-1" }, { "input": "3 8", "output": "-1" }, { "input": "3 9", "output": "-1" }, { "input": "3 10", "output": "-1" }, { "input": "4 1", "output": "4" }, { "input": "4 2", "output": "1 3" }, { "input": "4 3", "output": "-1" }, { "input": "4 4", "output": "-1" }, { "input": "4 5", "output": "-1" }, { "input": "4 6", "output": "-1" }, { "input": "4 7", "output": "-1" }, { "input": "4 8", "output": "-1" }, { "input": "4 9", "output": "-1" }, { "input": "4 10", "output": "-1" }, { "input": "5 1", "output": "5" }, { "input": "5 2", "output": "1 4" }, { "input": "5 3", "output": "-1" }, { "input": "5 4", "output": "-1" }, { "input": "5 5", "output": "-1" }, { "input": "5 6", "output": "-1" }, { "input": "5 7", "output": "-1" }, { "input": "5 8", "output": "-1" }, { "input": "5 9", "output": "-1" }, { "input": "5 10", "output": "-1" }, { "input": "6 1", "output": "6" }, { "input": "6 2", "output": "2 4" }, { "input": "6 3", "output": "1 2 3" }, { "input": "6 4", "output": "-1" }, { "input": "6 5", "output": "-1" }, { "input": "6 6", "output": "-1" }, { "input": "6 7", "output": "-1" }, { "input": "6 8", "output": "-1" }, { "input": "6 9", "output": "-1" }, { "input": "6 10", "output": "-1" }, { "input": "7 1", "output": "7" }, { "input": "7 2", "output": "1 6" }, { "input": "7 3", "output": "1 2 4" }, { "input": "7 4", "output": "-1" }, { "input": "7 5", "output": "-1" }, { "input": "7 6", "output": "-1" }, { "input": "7 7", "output": "-1" }, { "input": "7 8", "output": "-1" }, { "input": "7 9", "output": "-1" }, { "input": "7 10", "output": "-1" }, { "input": "8 1", "output": "8" }, { "input": "8 2", "output": "2 6" }, { "input": "8 3", "output": "1 2 5" }, { "input": "8 4", "output": "-1" }, { "input": "8 5", "output": "-1" }, { "input": "8 6", "output": "-1" }, { "input": "8 7", "output": "-1" }, { "input": "8 8", "output": "-1" }, { "input": "8 9", "output": "-1" }, { "input": "8 10", "output": "-1" } ]

1,586,523,880

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

2

93

307,200

inp=input() sum_inp=int(inp.split(" ")[0]) k=int(inp.split(" ")[1]) def solve(): if (k*(k+1))/2>sum_inp: return -1 def divisors(n): div_list=[] for i in range(1, int(n/2)+1): if n%i==0: div_list.append(i) return div_list div_list=divisors(sum_inp) #print(primes) def get_gcd(): for num in div_list[::-1]: if sum([num*i for i in range(1, k+1)])<=sum_inp: return num return -1 gcd=get_gcd() if gcd==-1: print(-1) return if sum([gcd*i for i in range(1, k+1)])==sum_inp: print(" ".join(map(str, [gcd*i for i in range(1, k+1)]))) return cum=sum([gcd*i for i in range(1, k)]) print(" ".join(map(str, [gcd*i for i in range(1, k)])), sum_inp-cum) solve()

Title: Maximal GCD Time Limit: None seconds Memory Limit: None megabytes Problem Description: You are given positive integer number *n*. You should create such strictly increasing sequence of *k* positive numbers *a*1,<=*a*2,<=...,<=*a**k*, that their sum is equal to *n* and greatest common divisor is maximal. Greatest common divisor of sequence is maximum of such numbers that every element of sequence is divisible by them. If there is no possible sequence then output -1. Input Specification: The first line consists of two numbers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=1010). Output Specification: If the answer exists then output *k* numbers — resulting sequence. Otherwise output -1. If there are multiple answers, print any of them. Demo Input: ['6 3\n', '8 2\n', '5 3\n'] Demo Output: ['1 2 3\n', '2 6\n', '-1\n'] Note: none

```python inp=input() sum_inp=int(inp.split(" ")[0]) k=int(inp.split(" ")[1]) def solve(): if (k*(k+1))/2>sum_inp: return -1 def divisors(n): div_list=[] for i in range(1, int(n/2)+1): if n%i==0: div_list.append(i) return div_list div_list=divisors(sum_inp) #print(primes) def get_gcd(): for num in div_list[::-1]: if sum([num*i for i in range(1, k+1)])<=sum_inp: return num return -1 gcd=get_gcd() if gcd==-1: print(-1) return if sum([gcd*i for i in range(1, k+1)])==sum_inp: print(" ".join(map(str, [gcd*i for i in range(1, k+1)]))) return cum=sum([gcd*i for i in range(1, k)]) print(" ".join(map(str, [gcd*i for i in range(1, k)])), sum_inp-cum) solve() ```

0

68

A

Irrational problem

PROGRAMMING

1,100

[ "implementation", "number theory" ]

A. Irrational problem

2

256

Little Petya was given this problem for homework: You are given function (here represents the operation of taking the remainder). His task is to count the number of integers *x* in range [*a*;*b*] with property *f*(*x*)<==<=*x*. It is a pity that Petya forgot the order in which the remainders should be taken and wrote down only 4 numbers. Each of 24 possible orders of taking the remainder has equal probability of being chosen. For example, if Petya has numbers 1, 2, 3, 4 then he can take remainders in that order or first take remainder modulo 4, then modulo 2, 3, 1. There also are 22 other permutations of these numbers that represent orders in which remainder can be taken. In this problem 4 numbers wrote down by Petya will be pairwise distinct. Now it is impossible for Petya to complete the task given by teacher but just for fun he decided to find the number of integers with property that probability that *f*(*x*)<==<=*x* is not less than 31.4159265352718281828459045%. In other words, Petya will pick up the number *x* if there exist at least 7 permutations of numbers *p*1,<=*p*2,<=*p*3,<=*p*4, for which *f*(*x*)<==<=*x*.

First line of the input will contain 6 integers, separated by spaces: *p*1,<=*p*2,<=*p*3,<=*p*4,<=*a*,<=*b* (1<=≤<=*p*1,<=*p*2,<=*p*3,<=*p*4<=≤<=1000,<=0<=≤<=*a*<=≤<=*b*<=≤<=31415). It is guaranteed that numbers *p*1,<=*p*2,<=*p*3,<=*p*4 will be pairwise distinct.

Output the number of integers in the given range that have the given property.

[ "2 7 1 8 2 8\n", "20 30 40 50 0 100\n", "31 41 59 26 17 43\n" ]

[ "0\n", "20\n", "9\n" ]

none

500

[ { "input": "2 7 1 8 2 8", "output": "0" }, { "input": "20 30 40 50 0 100", "output": "20" }, { "input": "31 41 59 26 17 43", "output": "9" }, { "input": "1 2 3 4 0 0", "output": "1" }, { "input": "1 2 3 4 1 1", "output": "0" }, { "input": "1 2 999 1000 30 40", "output": "0" }, { "input": "17 18 19 20 17 20", "output": "0" }, { "input": "17 18 19 20 16 20", "output": "1" }, { "input": "41 449 328 474 150 709", "output": "0" }, { "input": "467 329 936 440 117 700", "output": "212" }, { "input": "258 811 952 491 931 993", "output": "0" }, { "input": "823 431 359 590 153 899", "output": "206" }, { "input": "292 370 404 698 699 876", "output": "0" }, { "input": "442 705 757 527 868 893", "output": "0" }, { "input": "642 273 18 885 675 788", "output": "0" }, { "input": "291 303 656 660 126 704", "output": "165" }, { "input": "225 862 522 617 630 725", "output": "0" }, { "input": "17 847 715 732 502 778", "output": "0" }, { "input": "41 449 328 474 15724 19169", "output": "0" }, { "input": "467 329 936 440 5705 28145", "output": "0" }, { "input": "258 811 952 491 2995 11942", "output": "0" }, { "input": "823 431 359 590 153 3902", "output": "206" }, { "input": "292 370 404 698 19718 19895", "output": "0" }, { "input": "442 705 757 527 1869 19912", "output": "0" }, { "input": "642 273 18 885 23811 28703", "output": "0" }, { "input": "291 303 656 660 7711 15141", "output": "0" }, { "input": "225 862 522 617 1246 1341", "output": "0" }, { "input": "17 847 715 732 778 27529", "output": "0" }, { "input": "997 998 999 1000 0 31415", "output": "997" }, { "input": "1 2 3 4 0 31415", "output": "1" }, { "input": "541 931 822 948 131 193", "output": "63" }, { "input": "956 800 909 916 89 194", "output": "106" }, { "input": "735 794 942 991 419 490", "output": "72" }, { "input": "818 926 827 575 153 395", "output": "243" }, { "input": "792 858 887 679 179 356", "output": "178" }, { "input": "937 683 742 515 366 373", "output": "8" }, { "input": "616 747 501 875 146 264", "output": "119" }, { "input": "760 773 638 655 111 196", "output": "86" }, { "input": "697 855 997 589 97 192", "output": "96" }, { "input": "998 834 706 722 277 475", "output": "199" }, { "input": "100 101 102 103 10 20", "output": "11" } ]

1,570,519,215

2,147,483,647

Python 3

OK

TESTS

41

248

0

q=input() p1,p2,p3,p4,a,b=map(int,q.split()) p=min(p1,p2,p3,p4) c=0 if p>b: c=b-a+1 elif p>a: c=p-a else: c=0 print(c)

Title: Irrational problem Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Little Petya was given this problem for homework: You are given function (here represents the operation of taking the remainder). His task is to count the number of integers *x* in range [*a*;*b*] with property *f*(*x*)<==<=*x*. It is a pity that Petya forgot the order in which the remainders should be taken and wrote down only 4 numbers. Each of 24 possible orders of taking the remainder has equal probability of being chosen. For example, if Petya has numbers 1, 2, 3, 4 then he can take remainders in that order or first take remainder modulo 4, then modulo 2, 3, 1. There also are 22 other permutations of these numbers that represent orders in which remainder can be taken. In this problem 4 numbers wrote down by Petya will be pairwise distinct. Now it is impossible for Petya to complete the task given by teacher but just for fun he decided to find the number of integers with property that probability that *f*(*x*)<==<=*x* is not less than 31.4159265352718281828459045%. In other words, Petya will pick up the number *x* if there exist at least 7 permutations of numbers *p*1,<=*p*2,<=*p*3,<=*p*4, for which *f*(*x*)<==<=*x*. Input Specification: First line of the input will contain 6 integers, separated by spaces: *p*1,<=*p*2,<=*p*3,<=*p*4,<=*a*,<=*b* (1<=≤<=*p*1,<=*p*2,<=*p*3,<=*p*4<=≤<=1000,<=0<=≤<=*a*<=≤<=*b*<=≤<=31415). It is guaranteed that numbers *p*1,<=*p*2,<=*p*3,<=*p*4 will be pairwise distinct. Output Specification: Output the number of integers in the given range that have the given property. Demo Input: ['2 7 1 8 2 8\n', '20 30 40 50 0 100\n', '31 41 59 26 17 43\n'] Demo Output: ['0\n', '20\n', '9\n'] Note: none

```python q=input() p1,p2,p3,p4,a,b=map(int,q.split()) p=min(p1,p2,p3,p4) c=0 if p>b: c=b-a+1 elif p>a: c=p-a else: c=0 print(c) ```

3.938

118

A

String Task

PROGRAMMING

1,000

[ "implementation", "strings" ]

null

Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it: - deletes all the vowels, - inserts a character "." before each consonant, - replaces all uppercase consonants with corresponding lowercase ones. Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string. Help Petya cope with this easy task.

The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.

Print the resulting string. It is guaranteed that this string is not empty.

[ "tour\n", "Codeforces\n", "aBAcAba\n" ]

[ ".t.r\n", ".c.d.f.r.c.s\n", ".b.c.b\n" ]

none

500

[ { "input": "tour", "output": ".t.r" }, { "input": "Codeforces", "output": ".c.d.f.r.c.s" }, { "input": "aBAcAba", "output": ".b.c.b" }, { "input": "obn", "output": ".b.n" }, { "input": "wpwl", "output": ".w.p.w.l" }, { "input": "ggdvq", "output": ".g.g.d.v.q" }, { "input": "pumesz", "output": ".p.m.s.z" }, { "input": "g", "output": ".g" }, { "input": "zjuotps", "output": ".z.j.t.p.s" }, { "input": "jzbwuehe", "output": ".j.z.b.w.h" }, { "input": "tnkgwuugu", "output": ".t.n.k.g.w.g" }, { "input": "kincenvizh", "output": ".k.n.c.n.v.z.h" }, { "input": "xattxjenual", "output": ".x.t.t.x.j.n.l" }, { "input": "ktajqhpqsvhw", "output": ".k.t.j.q.h.p.q.s.v.h.w" }, { "input": "xnhcigytnqcmy", "output": ".x.n.h.c.g.t.n.q.c.m" }, { "input": "jfmtbejyilxcec", "output": ".j.f.m.t.b.j.l.x.c.c" }, { "input": "D", "output": ".d" }, { "input": "ab", "output": ".b" }, { "input": "Ab", "output": ".b" }, { "input": "aB", "output": ".b" }, { "input": "AB", "output": ".b" }, { "input": "ba", "output": ".b" }, { "input": "bA", "output": ".b" }, { "input": "Ba", "output": ".b" }, { "input": "BA", "output": ".b" }, { "input": "aab", "output": ".b" }, { "input": "baa", "output": ".b" }, { "input": "femOZeCArKCpUiHYnbBPTIOFmsHmcpObtPYcLCdjFrUMIyqYzAokKUiiKZRouZiNMoiOuGVoQzaaCAOkquRjmmKKElLNqCnhGdQM", "output": ".f.m.z.c.r.k.c.p.h.n.b.b.p.t.f.m.s.h.m.c.p.b.t.p.c.l.c.d.j.f.r.m.q.z.k.k.k.z.r.z.n.m.g.v.q.z.c.k.q.r.j.m.m.k.k.l.l.n.q.c.n.h.g.d.q.m" }, { "input": "VMBPMCmMDCLFELLIISUJDWQRXYRDGKMXJXJHXVZADRZWVWJRKFRRNSAWKKDPZZLFLNSGUNIVJFBEQsMDHSBJVDTOCSCgZWWKvZZN", "output": ".v.m.b.p.m.c.m.m.d.c.l.f.l.l.s.j.d.w.q.r.x.r.d.g.k.m.x.j.x.j.h.x.v.z.d.r.z.w.v.w.j.r.k.f.r.r.n.s.w.k.k.d.p.z.z.l.f.l.n.s.g.n.v.j.f.b.q.s.m.d.h.s.b.j.v.d.t.c.s.c.g.z.w.w.k.v.z.z.n" }, { "input": "MCGFQQJNUKuAEXrLXibVjClSHjSxmlkQGTKZrRaDNDomIPOmtSgjJAjNVIVLeUGUAOHNkCBwNObVCHOWvNkLFQQbFnugYVMkJruJ", "output": ".m.c.g.f.q.q.j.n.k.x.r.l.x.b.v.j.c.l.s.h.j.s.x.m.l.k.q.g.t.k.z.r.r.d.n.d.m.p.m.t.s.g.j.j.j.n.v.v.l.g.h.n.k.c.b.w.n.b.v.c.h.w.v.n.k.l.f.q.q.b.f.n.g.v.m.k.j.r.j" }, { "input": "iyaiuiwioOyzUaOtAeuEYcevvUyveuyioeeueoeiaoeiavizeeoeyYYaaAOuouueaUioueauayoiuuyiuovyOyiyoyioaoyuoyea", "output": ".w.z.t.c.v.v.v.v.z.v" }, { "input": "yjnckpfyLtzwjsgpcrgCfpljnjwqzgVcufnOvhxplvflxJzqxnhrwgfJmPzifgubvspffmqrwbzivatlmdiBaddiaktdsfPwsevl", "output": ".j.n.c.k.p.f.l.t.z.w.j.s.g.p.c.r.g.c.f.p.l.j.n.j.w.q.z.g.v.c.f.n.v.h.x.p.l.v.f.l.x.j.z.q.x.n.h.r.w.g.f.j.m.p.z.f.g.b.v.s.p.f.f.m.q.r.w.b.z.v.t.l.m.d.b.d.d.k.t.d.s.f.p.w.s.v.l" }, { "input": "RIIIUaAIYJOiuYIUWFPOOAIuaUEZeIooyUEUEAoIyIHYOEAlVAAIiLUAUAeiUIEiUMuuOiAgEUOIAoOUYYEYFEoOIIVeOOAOIIEg", "output": ".r.j.w.f.p.z.h.l.v.l.m.g.f.v.g" }, { "input": "VBKQCFBMQHDMGNSGBQVJTGQCNHHRJMNKGKDPPSQRRVQTZNKBZGSXBPBRXPMVFTXCHZMSJVBRNFNTHBHGJLMDZJSVPZZBCCZNVLMQ", "output": ".v.b.k.q.c.f.b.m.q.h.d.m.g.n.s.g.b.q.v.j.t.g.q.c.n.h.h.r.j.m.n.k.g.k.d.p.p.s.q.r.r.v.q.t.z.n.k.b.z.g.s.x.b.p.b.r.x.p.m.v.f.t.x.c.h.z.m.s.j.v.b.r.n.f.n.t.h.b.h.g.j.l.m.d.z.j.s.v.p.z.z.b.c.c.z.n.v.l.m.q" }, { "input": "iioyoaayeuyoolyiyoeuouiayiiuyTueyiaoiueyioiouyuauouayyiaeoeiiigmioiououeieeeyuyyaYyioiiooaiuouyoeoeg", "output": ".l.t.g.m.g" }, { "input": "ueyiuiauuyyeueykeioouiiauzoyoeyeuyiaoaiiaaoaueyaeydaoauexuueafouiyioueeaaeyoeuaueiyiuiaeeayaioeouiuy", "output": ".k.z.d.x.f" }, { "input": "FSNRBXLFQHZXGVMKLQDVHWLDSLKGKFMDRQWMWSSKPKKQBNDZRSCBLRSKCKKFFKRDMZFZGCNSMXNPMZVDLKXGNXGZQCLRTTDXLMXQ", "output": ".f.s.n.r.b.x.l.f.q.h.z.x.g.v.m.k.l.q.d.v.h.w.l.d.s.l.k.g.k.f.m.d.r.q.w.m.w.s.s.k.p.k.k.q.b.n.d.z.r.s.c.b.l.r.s.k.c.k.k.f.f.k.r.d.m.z.f.z.g.c.n.s.m.x.n.p.m.z.v.d.l.k.x.g.n.x.g.z.q.c.l.r.t.t.d.x.l.m.x.q" }, { "input": "EYAYAYIOIOYOOAUOEUEUOUUYIYUUMOEOIIIAOIUOAAOIYOIOEUIERCEYYAOIOIGYUIAOYUEOEUAEAYPOYEYUUAUOAOEIYIEYUEEY", "output": ".m.r.c.g.p" }, { "input": "jvvzcdcxjstbbksmqjsngxkgtttdxrljjxtwptgwwqzpvqchvgrkqlzxmptzblxhhsmrkmzzmgdfskhtmmnqzzflpmqdctvrfgtx", "output": ".j.v.v.z.c.d.c.x.j.s.t.b.b.k.s.m.q.j.s.n.g.x.k.g.t.t.t.d.x.r.l.j.j.x.t.w.p.t.g.w.w.q.z.p.v.q.c.h.v.g.r.k.q.l.z.x.m.p.t.z.b.l.x.h.h.s.m.r.k.m.z.z.m.g.d.f.s.k.h.t.m.m.n.q.z.z.f.l.p.m.q.d.c.t.v.r.f.g.t.x" }, { "input": "YB", "output": ".b" }, { "input": "fly", "output": ".f.l" }, { "input": "YyyYYYyyYxdwdawdDAWDdaddYYYY", "output": ".x.d.w.d.w.d.d.w.d.d.d.d" } ]

1,693,194,412

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

30

0

a = list(input().lower()) for i in a: if i not in ['a', 'e','i', 'o','u','y']: print('·'+ i, end='')

Title: String Task Time Limit: None seconds Memory Limit: None megabytes Problem Description: Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it: - deletes all the vowels, - inserts a character "." before each consonant, - replaces all uppercase consonants with corresponding lowercase ones. Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string. Help Petya cope with this easy task. Input Specification: The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive. Output Specification: Print the resulting string. It is guaranteed that this string is not empty. Demo Input: ['tour\n', 'Codeforces\n', 'aBAcAba\n'] Demo Output: ['.t.r\n', '.c.d.f.r.c.s\n', '.b.c.b\n'] Note: none

```python a = list(input().lower()) for i in a: if i not in ['a', 'e','i', 'o','u','y']: print('·'+ i, end='') ```

0

812

C

Sagheer and Nubian Market

PROGRAMMING

1,500

[ "binary search", "sortings" ]

null

On his trip to Luxor and Aswan, Sagheer went to a Nubian market to buy some souvenirs for his friends and relatives. The market has some strange rules. It contains *n* different items numbered from 1 to *n*. The *i*-th item has base cost *a**i* Egyptian pounds. If Sagheer buys *k* items with indices *x*1,<=*x*2,<=...,<=*x**k*, then the cost of item *x**j* is *a**x**j*<=+<=*x**j*·*k* for 1<=≤<=*j*<=≤<=*k*. In other words, the cost of an item is equal to its base cost in addition to its index multiplied by the factor *k*. Sagheer wants to buy as many souvenirs as possible without paying more than *S* Egyptian pounds. Note that he cannot buy a souvenir more than once. If there are many ways to maximize the number of souvenirs, he will choose the way that will minimize the total cost. Can you help him with this task?

The first line contains two integers *n* and *S* (1<=≤<=*n*<=≤<=105 and 1<=≤<=*S*<=≤<=109) — the number of souvenirs in the market and Sagheer's budget. The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=105) — the base costs of the souvenirs.

On a single line, print two integers *k*, *T* — the maximum number of souvenirs Sagheer can buy and the minimum total cost to buy these *k* souvenirs.

[ "3 11\n2 3 5\n", "4 100\n1 2 5 6\n", "1 7\n7\n" ]

[ "2 11\n", "4 54\n", "0 0\n" ]

In the first example, he cannot take the three items because they will cost him [5, 9, 14] with total cost 28. If he decides to take only two items, then the costs will be [4, 7, 11]. So he can afford the first and second items. In the second example, he can buy all items as they will cost him [5, 10, 17, 22]. In the third example, there is only one souvenir in the market which will cost him 8 pounds, so he cannot buy it.

1,500

[ { "input": "3 11\n2 3 5", "output": "2 11" }, { "input": "4 100\n1 2 5 6", "output": "4 54" }, { "input": "1 7\n7", "output": "0 0" }, { "input": "1 7\n5", "output": "1 6" }, { "input": "1 1\n1", "output": "0 0" }, { "input": "4 33\n4 3 2 1", "output": "3 27" }, { "input": "86 96\n89 48 14 55 5 35 7 79 49 70 74 18 64 63 35 93 63 97 90 77 33 11 100 75 60 99 54 38 3 6 55 1 7 64 56 90 21 76 35 16 61 78 38 78 93 21 89 1 58 53 34 77 56 37 46 59 30 5 85 1 52 87 84 99 97 9 15 66 29 60 17 16 59 23 88 93 32 2 98 89 63 42 9 86 70 80", "output": "3 71" }, { "input": "9 2727\n73 41 68 90 51 7 20 48 69", "output": "9 872" }, { "input": "35 792600\n61 11 82 29 3 50 65 60 62 86 83 78 15 82 7 77 38 87 100 12 93 86 96 79 14 58 60 47 94 39 36 23 69 93 18", "output": "35 24043" }, { "input": "63 47677090\n53 4 59 68 6 12 47 63 28 93 9 53 61 63 53 70 77 63 49 76 70 23 4 40 4 34 24 70 42 83 84 95 11 46 38 83 26 85 34 29 67 96 3 62 97 7 42 65 49 45 50 54 81 74 83 59 10 87 95 87 89 27 3", "output": "63 130272" }, { "input": "88 631662736\n93 75 25 7 6 55 92 23 22 32 4 48 61 29 91 79 16 18 18 9 66 9 57 62 3 81 48 16 21 90 93 58 30 8 31 47 44 70 34 85 52 71 58 42 99 53 43 54 96 26 6 13 38 4 13 60 1 48 32 100 52 8 27 99 66 34 98 45 19 50 37 59 31 56 58 70 61 14 100 66 74 85 64 57 92 89 7 92", "output": "88 348883" }, { "input": "12 12\n1232 1848 2048 4694 5121 3735 9968 4687 2040 6033 5839 2507", "output": "0 0" }, { "input": "37 5271\n368 6194 4856 8534 944 4953 2085 5350 788 7772 9786 1321 4310 4453 7078 9912 5799 4066 5471 5079 5161 9773 1300 5474 1202 1353 9499 9694 9020 6332 595 7619 1271 7430 1199 3127 8867", "output": "5 4252" }, { "input": "65 958484\n9597 1867 5346 637 6115 5833 3318 6059 4430 9169 8155 7895 3534 7962 9900 9495 5694 3461 5370 1945 1724 9264 3475 618 3421 551 8359 6889 1843 6716 9216 2356 1592 6265 2945 6496 4947 2840 9057 6141 887 4823 4004 8027 1993 1391 796 7059 5500 4369 4012 4983 6495 8990 3633 5439 421 1129 6970 8796 7826 1200 8741 6555 5037", "output": "65 468998" }, { "input": "90 61394040\n2480 6212 4506 829 8191 797 5336 6722 3178 1007 5849 3061 3588 6684 5983 5452 7654 5321 660 2569 2809 2179 679 4858 6887 2580 6880 6120 4159 5542 4999 8703 2386 8221 7046 1229 1662 4542 7089 3548 4298 1973 1854 2473 5507 241 359 5248 7907 5201 9624 4596 1723 2622 4800 4716 693 961 7402 9004 7994 8048 6590 5866 7502 3304 4331 5218 6906 1016 5342 6644 2205 5823 8525 4839 1914 2651 3940 7751 3489 4178 7234 6640 7602 9765 8559 7819 5827 163", "output": "90 795634" }, { "input": "14 891190480\n1424 3077 9632 6506 4568 9650 5534 1085 6934 9340 2867 367 7075 618", "output": "14 70147" }, { "input": "39 43\n22166 81842 15513 80979 39645 60168 96994 13493 12904 79871 49910 45356 93691 51829 18226 34288 11525 41944 40433 67295 30123 1081 55623 22279 75814 82316 2963 39329 38223 8445 43202 61912 15122 86367 37200 68113 57194 38541 49641", "output": "0 0" }, { "input": "67 8824\n75515 67590 86373 34191 3446 27408 31581 24727 40005 23718 39738 30960 4786 51040 32590 80454 14335 47173 20079 41204 67289 58347 88969 88396 37681 43963 13886 85690 12259 14732 42036 62620 15011 41890 20150 59469 62104 30136 47163 19790 25699 27453 36151 52914 52684 20503 78622 81082 94500 55756 94030 54764 72763 37830 13210 64559 53600 87998 80472 19001 83769 79700 88794 10161 99980 95184 74439", "output": "2 8268" }, { "input": "16 56532535\n84567 85265 99012 62115 58908 10120 27355 90226 17191 35588 43807 6327 89157 71156 16253 22387", "output": "16 821610" }, { "input": "42 818723640\n57019 99450 43192 25131 80678 41786 52490 34454 51620 56132 41773 94622 23949 11597 96944 51420 44164 85727 72959 26622 1838 36302 99335 35572 92734 10651 22293 97601 38634 24066 81870 10904 5825 71968 2377 61198 3104 4191 97851 99920 65295 1385", "output": "42 2094569" } ]

1,673,878,934

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

5

46

0

n,s=map(int,input().split()) a=list(map(int,input().split())) a.sort() l=0 r=n+1 while r-l>1: d=(l+r)//2 su=0 for i in range(d): su+=a[i]+(i+1)*d if su<=s: l=d else: r=d su=0 for i in range(l): su+=a[i]+(i+1)*l print(l,su)

Title: Sagheer and Nubian Market Time Limit: None seconds Memory Limit: None megabytes Problem Description: On his trip to Luxor and Aswan, Sagheer went to a Nubian market to buy some souvenirs for his friends and relatives. The market has some strange rules. It contains *n* different items numbered from 1 to *n*. The *i*-th item has base cost *a**i* Egyptian pounds. If Sagheer buys *k* items with indices *x*1,<=*x*2,<=...,<=*x**k*, then the cost of item *x**j* is *a**x**j*<=+<=*x**j*·*k* for 1<=≤<=*j*<=≤<=*k*. In other words, the cost of an item is equal to its base cost in addition to its index multiplied by the factor *k*. Sagheer wants to buy as many souvenirs as possible without paying more than *S* Egyptian pounds. Note that he cannot buy a souvenir more than once. If there are many ways to maximize the number of souvenirs, he will choose the way that will minimize the total cost. Can you help him with this task? Input Specification: The first line contains two integers *n* and *S* (1<=≤<=*n*<=≤<=105 and 1<=≤<=*S*<=≤<=109) — the number of souvenirs in the market and Sagheer's budget. The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=105) — the base costs of the souvenirs. Output Specification: On a single line, print two integers *k*, *T* — the maximum number of souvenirs Sagheer can buy and the minimum total cost to buy these *k* souvenirs. Demo Input: ['3 11\n2 3 5\n', '4 100\n1 2 5 6\n', '1 7\n7\n'] Demo Output: ['2 11\n', '4 54\n', '0 0\n'] Note: In the first example, he cannot take the three items because they will cost him [5, 9, 14] with total cost 28. If he decides to take only two items, then the costs will be [4, 7, 11]. So he can afford the first and second items. In the second example, he can buy all items as they will cost him [5, 10, 17, 22]. In the third example, there is only one souvenir in the market which will cost him 8 pounds, so he cannot buy it.

```python n,s=map(int,input().split()) a=list(map(int,input().split())) a.sort() l=0 r=n+1 while r-l>1: d=(l+r)//2 su=0 for i in range(d): su+=a[i]+(i+1)*d if su<=s: l=d else: r=d su=0 for i in range(l): su+=a[i]+(i+1)*l print(l,su) ```

0

994

B

Knights of a Polygonal Table

PROGRAMMING

1,400

[ "greedy", "implementation", "sortings" ]

null

Unlike Knights of a Round Table, Knights of a Polygonal Table deprived of nobility and happy to kill each other. But each knight has some power and a knight can kill another knight if and only if his power is greater than the power of victim. However, even such a knight will torment his conscience, so he can kill no more than $k$ other knights. Also, each knight has some number of coins. After a kill, a knight can pick up all victim's coins. Now each knight ponders: how many coins he can have if only he kills other knights? You should answer this question for each knight.

The first line contains two integers $n$ and $k$ $(1 \le n \le 10^5, 0 \le k \le \min(n-1,10))$ — the number of knights and the number $k$ from the statement. The second line contains $n$ integers $p_1, p_2 ,\ldots,p_n$ $(1 \le p_i \le 10^9)$ — powers of the knights. All $p_i$ are distinct. The third line contains $n$ integers $c_1, c_2 ,\ldots,c_n$ $(0 \le c_i \le 10^9)$ — the number of coins each knight has.

Print $n$ integers — the maximum number of coins each knight can have it only he kills other knights.

[ "4 2\n4 5 9 7\n1 2 11 33\n", "5 1\n1 2 3 4 5\n1 2 3 4 5\n", "1 0\n2\n3\n" ]

[ "1 3 46 36 ", "1 3 5 7 9 ", "3 " ]

Consider the first example. - The first knight is the weakest, so he can't kill anyone. That leaves him with the only coin he initially has. - The second knight can kill the first knight and add his coin to his own two. - The third knight is the strongest, but he can't kill more than $k = 2$ other knights. It is optimal to kill the second and the fourth knights: $2+11+33 = 46$. - The fourth knight should kill the first and the second knights: $33+1+2 = 36$. In the second example the first knight can't kill anyone, while all the others should kill the one with the index less by one than their own. In the third example there is only one knight, so he can't kill anyone.

1,000

[ { "input": "4 2\n4 5 9 7\n1 2 11 33", "output": "1 3 46 36 " }, { "input": "5 1\n1 2 3 4 5\n1 2 3 4 5", "output": "1 3 5 7 9 " }, { "input": "1 0\n2\n3", "output": "3 " }, { "input": "7 1\n2 3 4 5 7 8 9\n0 3 7 9 5 8 9", "output": "0 3 10 16 14 17 18 " }, { "input": "7 2\n2 4 6 7 8 9 10\n10 8 4 8 4 5 9", "output": "10 18 22 26 22 23 27 " }, { "input": "11 10\n1 2 3 4 5 6 7 8 9 10 11\n1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000", "output": "1000000000 2000000000 3000000000 4000000000 5000000000 6000000000 7000000000 8000000000 9000000000 10000000000 11000000000 " }, { "input": "2 0\n2 3\n3 3", "output": "3 3 " }, { "input": "7 3\n1 2 3 4 5 6 7\n3 3 3 4 5 6 7", "output": "3 6 9 13 15 18 22 " }, { "input": "3 0\n3 2 1\n1 2 3", "output": "1 2 3 " }, { "input": "5 3\n4 5 7 9 11\n10 10 10 10 10", "output": "10 20 30 40 40 " }, { "input": "4 0\n4 5 9 7\n1 2 11 33", "output": "1 2 11 33 " }, { "input": "7 3\n1 2 3 4 5 6 7\n3 3 3 8 8 8 8", "output": "3 6 9 17 22 27 32 " }, { "input": "3 0\n1 2 3\n5 5 5", "output": "5 5 5 " }, { "input": "4 2\n4 5 9 7\n2 2 11 33", "output": "2 4 46 37 " }, { "input": "6 3\n1 2 3 4 5 6\n1 1 1 1 1 1", "output": "1 2 3 4 4 4 " }, { "input": "10 5\n1 2 3 4 5 6 7 8 9 10\n1 1 1 1 1 1 1 1 1 1", "output": "1 2 3 4 5 6 6 6 6 6 " }, { "input": "3 2\n1 2 3\n1 1 1", "output": "1 2 3 " }, { "input": "3 0\n1 2 3\n10 20 30", "output": "10 20 30 " }, { "input": "4 0\n4 5 9 7\n1 2 3 4", "output": "1 2 3 4 " }, { "input": "5 4\n1 2 3 4 5\n1 1 1 1 1", "output": "1 2 3 4 5 " }, { "input": "4 3\n1 2 3 4\n5 5 5 5", "output": "5 10 15 20 " }, { "input": "5 3\n1 2 3 4 5\n7 7 7 7 7", "output": "7 14 21 28 28 " } ]

1,529,243,725

2,147,483,647

PyPy 3

RUNTIME_ERROR

TESTS

0

202

1,126,400

def find(arr1,elem,i): if(arr1[i][0] == elem): return i else: return find(arr1,elem,arr1[i][0]) [n,k] = map(int,input().split()) p = list(map(int,input().split())) c = list(map(int,input().split())) arr = [] arr1 = [] for i in range(n): arr.append((i,-1*p[i],c[i])) arr1.append((i,-1*c[i])) fin = [] arr.sort(key = lambda x: x[1]) arr1.sort(key = lambda x : x[1]) for i in range(n): fin.append([arr[i][0],arr[i][2]]) p = find(arr1,arr[i][0],arr[i][0]) del arr1[p] for j in range(k): if(j + i + 1< n): fin[i][1] += -1*arr1[j][1] else: break fin.sort() for i in range(n): print(fin[i][1],end = " ")

Title: Knights of a Polygonal Table Time Limit: None seconds Memory Limit: None megabytes Problem Description: Unlike Knights of a Round Table, Knights of a Polygonal Table deprived of nobility and happy to kill each other. But each knight has some power and a knight can kill another knight if and only if his power is greater than the power of victim. However, even such a knight will torment his conscience, so he can kill no more than $k$ other knights. Also, each knight has some number of coins. After a kill, a knight can pick up all victim's coins. Now each knight ponders: how many coins he can have if only he kills other knights? You should answer this question for each knight. Input Specification: The first line contains two integers $n$ and $k$ $(1 \le n \le 10^5, 0 \le k \le \min(n-1,10))$ — the number of knights and the number $k$ from the statement. The second line contains $n$ integers $p_1, p_2 ,\ldots,p_n$ $(1 \le p_i \le 10^9)$ — powers of the knights. All $p_i$ are distinct. The third line contains $n$ integers $c_1, c_2 ,\ldots,c_n$ $(0 \le c_i \le 10^9)$ — the number of coins each knight has. Output Specification: Print $n$ integers — the maximum number of coins each knight can have it only he kills other knights. Demo Input: ['4 2\n4 5 9 7\n1 2 11 33\n', '5 1\n1 2 3 4 5\n1 2 3 4 5\n', '1 0\n2\n3\n'] Demo Output: ['1 3 46 36 ', '1 3 5 7 9 ', '3 '] Note: Consider the first example. - The first knight is the weakest, so he can't kill anyone. That leaves him with the only coin he initially has. - The second knight can kill the first knight and add his coin to his own two. - The third knight is the strongest, but he can't kill more than $k = 2$ other knights. It is optimal to kill the second and the fourth knights: $2+11+33 = 46$. - The fourth knight should kill the first and the second knights: $33+1+2 = 36$. In the second example the first knight can't kill anyone, while all the others should kill the one with the index less by one than their own. In the third example there is only one knight, so he can't kill anyone.

```python def find(arr1,elem,i): if(arr1[i][0] == elem): return i else: return find(arr1,elem,arr1[i][0]) [n,k] = map(int,input().split()) p = list(map(int,input().split())) c = list(map(int,input().split())) arr = [] arr1 = [] for i in range(n): arr.append((i,-1*p[i],c[i])) arr1.append((i,-1*c[i])) fin = [] arr.sort(key = lambda x: x[1]) arr1.sort(key = lambda x : x[1]) for i in range(n): fin.append([arr[i][0],arr[i][2]]) p = find(arr1,arr[i][0],arr[i][0]) del arr1[p] for j in range(k): if(j + i + 1< n): fin[i][1] += -1*arr1[j][1] else: break fin.sort() for i in range(n): print(fin[i][1],end = " ") ```

-1

946

C

String Transformation

PROGRAMMING

1,300

[ "greedy", "strings" ]

null

You are given a string *s* consisting of |*s*| small english letters. In one move you can replace any character of this string to the next character in alphabetical order (a will be replaced with b, s will be replaced with t, etc.). You cannot replace letter z with any other letter. Your target is to make some number of moves (not necessary minimal) to get string abcdefghijklmnopqrstuvwxyz (english alphabet) as a subsequence. Subsequence of the string is the string that is obtained by deleting characters at some positions. You need to print the string that will be obtained from the given string and will be contain english alphabet as a subsequence or say that it is impossible.

The only one line of the input consisting of the string *s* consisting of |*s*| (1<=≤<=|*s*|<=≤<=105) small english letters.

If you can get a string that can be obtained from the given string and will contain english alphabet as a subsequence, print it. Otherwise print «-1» (without quotes).

[ "aacceeggiikkmmooqqssuuwwyy\n", "thereisnoanswer\n" ]

[ "abcdefghijklmnopqrstuvwxyz\n", "-1\n" ]

none

0

[ { "input": "aacceeggiikkmmooqqssuuwwyy", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "thereisnoanswer", "output": "-1" }, { "input": "jqcfvsaveaixhioaaeephbmsmfcgdyawscpyioybkgxlcrhaxs", "output": "-1" }, { "input": "rtdacjpsjjmjdhcoprjhaenlwuvpfqzurnrswngmpnkdnunaendlpbfuylqgxtndhmhqgbsknsy", "output": "-1" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaa" }, { "input": "abcdefghijklmnopqrstuvwxxx", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "abcdefghijklmnopqrstuvwxya", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "cdaaaaaaaaabcdjklmnopqrstuvwxyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", "output": "cdabcdefghijklmnopqrstuvwxyzxyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz" }, { "input": "zazaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "zazbcdefghijklmnopqrstuvwxyz" }, { "input": "abcdefghijklmnopqrstuvwxyz", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "abbbefghijklmnopqrstuvwxyz", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaa" }, { "input": "abcdefghijklmaopqrstuvwxyz", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "abcdefghijklmnopqrstuvwxyx", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaz" }, { "input": "zaaaazaaaaaaaaaaaaaaaaaaaaaaaa", "output": "zabcdzefghijklmnopqrstuvwxyzaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaa" }, { "input": "aaaaaafghijklmnopqrstuvwxyz", "output": "abcdefghijklmnopqrstuvwxyzz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz", "output": "abcdefghijklmnopqrstuvwxyzaaaaaz" }, { "input": "abcdefghijklmnopqrstuvwaxy", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaa" }, { "input": "abcdefghijklmnapqrstuvwxyz", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "abcdefghijklmnopqrstuvnxyz", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaa" }, { "input": "abcdefghijklmnopqrstuvwxyzzzz", "output": "abcdefghijklmnopqrstuvwxyzzzz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aacceeggiikkmmooqqssuuwwya", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aacdefghijklmnopqrstuvwxyyy", "output": "abcdefghijklmnopqrstuvwxyzy" }, { "input": "abcaefghijklmnopqrstuvwxyz", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "zaaacaaaaaaaaaaaaaaaaaaaayy", "output": "zabcdefghijklmnopqrstuvwxyz" }, { "input": "abcdedccdcdccdcdcdcdcdcddccdcdcdc", "output": "abcdefghijklmnopqrstuvwxyzcdcdcdc" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "abcdecdcdcddcdcdcdcdcdcdcd", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "abaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "a", "output": "-1" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaa" }, { "input": "aaadefghijklmnopqrstuvwxyz", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaa" }, { "input": "abbbbbbbbbbbbbbbbbbbbbbbbz", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "aacceeggiikkmmaacceeggiikkmmooaacceeggiikkmmaacceeggiikkmmooqqssuuwwzy", "output": "abcdefghijklmnopqrstuvwxyzmmooaacceeggiikkmmaacceeggiikkmmooqqssuuwwzy" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "phqghumeaylnlfdxfircvscxggbwkfnqduxwfnfozvsrtkjprepggxrpnrvystmwcysyycqpevikeffmznimkkasvwsrenzkycxf", "output": "-1" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaap", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "zabcdefghijklmnopqrstuvwxyz", "output": "zabcdefghijklmnopqrstuvwxyz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyza" }, { "input": "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzabcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "rveviaomdienfygifatviahordebxazoxflfgzslhyzowhxbhqzpsgellkoimnwkvhpbijorhpggwfjexivpqbcbmqjyghkbq", "output": "rveviaomdienfygifbtvichordefxgzoxhlijzslkyzowlxmnqzpsopqrstuvwxyzhpbijorhpggwfjexivpqbcbmqjyghkbq" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "xtlsgypsfadpooefxzbcoejuvpvaboygpoeylfpbnpljvrvipyamyehwqnqrqpmxujjloovaowuxwhmsncbxcoksfzkvatxdknly", "output": "xtlsgypsfadpooefxzbcoejuvpvdeoygpofylgphnpljvrvipyjmyklwqnqrqpmxunopqrvstwuxwvwxyzbxcoksfzkvatxdknly" }, { "input": "jqcfvsaveaixhioaaeephbmsmfcgdyawscpyioybkgxlcrhaxsa", "output": "jqcfvsavebixhiocdefphgmsmhijkylwsmpynoypqrxstuvwxyz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "wlrbbmqbhcdarzowkkyhiddqscdxrjmowfrxsjybldbefsarcbynecdyggxxpklorellnmpapqfwkhopkmcoqh", "output": "wlrbbmqbhcdarzowkkyhiddqscdxrjmowfrxsjybldcefsdrefynghiyjkxxplmornopqrstuvwxyzopkmcoqh" }, { "input": "abadefghijklmnopqrstuvwxyz", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }, { "input": "zazsazcbbbbbbbbbbbbbbbbbbbbbbb", "output": "zazsbzcdefghijklmnopqrstuvwxyz" }, { "input": "zazsazcbbbbbbbbbbbbbbbbbbbbbyb", "output": "zazsbzcdefghijklmnopqrstuvwxyz" }, { "input": "bbcdefghijklmnopqrstuvwxyzzz", "output": "-1" }, { "input": "zaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "zabcdefghijklmnopqrstuvwxyz" }, { "input": "zzzzzaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "zzzzzabcdefghijklmnopqrstuvwxyza" }, { "input": "kkimnfjbbgggicykcciwtoazomcvisigagkjwhyrmojmoebnqoadpmockfjxibdtvrbedrsdoundbcpkfdqdidqdmxdltink", "output": "kkimnfjbbgggicykcciwtoazomcvisigbgkjwhyrmojmoecnqodepmofkgjxihitvrjklrsmounopqrstuvwxyzdmxdltink" }, { "input": "cawgathqceccscakbazmhwbefvygjbcfyihcbgga", "output": "-1" }, { "input": "acrsbyszsbfslzbqzzamcmrypictkcheddehvxdipaxaannjodzyfxgtfnwababzjraapqbqbfzhbiewlzz", "output": "acrsbyszscfslzdqzzemfmrypigtkhijklmnvxopqrxstuvwxyzyfxgtfnwababzjraapqbqbfzhbiewlzz" }, { "input": "ggcebbheeblbioxdvtlrtkxeuilonazpebcbqpzz", "output": "-1" }, { "input": "zzzzabcdefghijklmnopqrstuvwxy", "output": "-1" }, { "input": "zabcdefghijklmnopqrstuvwxy", "output": "-1" }, { "input": "babcdefghijklmnopqrstuvwxyz", "output": "babcdefghijklmnopqrstuvwxyz" }, { "input": "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", "output": "-1" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaz", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "output": "abcdefghijklmnopqrstuvwxyzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" } ]

1,576,460,537

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

3

155

2,252,800

s = input().strip() n = len(s) tail = [0] * 26 f = [0] * n for i in range(n): if s[i] == 'a': f[i] = 1 else: f[i] = -int(1e9) for i in range(n): x = ord(s[i]) - ord('a') for j in range(x, 26): f[i] = max(f[i], f[tail[j]] + 1) tail[x] = i for i in range(n): if f[i] >= 26: print('abcdefghijklmnopqrstuvwxyz') exit(0) print('-1')

Title: String Transformation Time Limit: None seconds Memory Limit: None megabytes Problem Description: You are given a string *s* consisting of |*s*| small english letters. In one move you can replace any character of this string to the next character in alphabetical order (a will be replaced with b, s will be replaced with t, etc.). You cannot replace letter z with any other letter. Your target is to make some number of moves (not necessary minimal) to get string abcdefghijklmnopqrstuvwxyz (english alphabet) as a subsequence. Subsequence of the string is the string that is obtained by deleting characters at some positions. You need to print the string that will be obtained from the given string and will be contain english alphabet as a subsequence or say that it is impossible. Input Specification: The only one line of the input consisting of the string *s* consisting of |*s*| (1<=≤<=|*s*|<=≤<=105) small english letters. Output Specification: If you can get a string that can be obtained from the given string and will contain english alphabet as a subsequence, print it. Otherwise print «-1» (without quotes). Demo Input: ['aacceeggiikkmmooqqssuuwwyy\n', 'thereisnoanswer\n'] Demo Output: ['abcdefghijklmnopqrstuvwxyz\n', '-1\n'] Note: none

```python s = input().strip() n = len(s) tail = [0] * 26 f = [0] * n for i in range(n): if s[i] == 'a': f[i] = 1 else: f[i] = -int(1e9) for i in range(n): x = ord(s[i]) - ord('a') for j in range(x, 26): f[i] = max(f[i], f[tail[j]] + 1) tail[x] = i for i in range(n): if f[i] >= 26: print('abcdefghijklmnopqrstuvwxyz') exit(0) print('-1') ```

0

405

A

Gravity Flip

PROGRAMMING

900

[ "greedy", "implementation", "sortings" ]

null

Little Chris is bored during his physics lessons (too easy), so he has built a toy box to keep himself occupied. The box is special, since it has the ability to change gravity. There are *n* columns of toy cubes in the box arranged in a line. The *i*-th column contains *a**i* cubes. At first, the gravity in the box is pulling the cubes downwards. When Chris switches the gravity, it begins to pull all the cubes to the right side of the box. The figure shows the initial and final configurations of the cubes in the box: the cubes that have changed their position are highlighted with orange. Given the initial configuration of the toy cubes in the box, find the amounts of cubes in each of the *n* columns after the gravity switch!

The first line of input contains an integer *n* (1<=≤<=*n*<=≤<=100), the number of the columns in the box. The next line contains *n* space-separated integer numbers. The *i*-th number *a**i* (1<=≤<=*a**i*<=≤<=100) denotes the number of cubes in the *i*-th column.

Output *n* integer numbers separated by spaces, where the *i*-th number is the amount of cubes in the *i*-th column after the gravity switch.

[ "4\n3 2 1 2\n", "3\n2 3 8\n" ]

[ "1 2 2 3 \n", "2 3 8 \n" ]

The first example case is shown on the figure. The top cube of the first column falls to the top of the last column; the top cube of the second column falls to the top of the third column; the middle cube of the first column falls to the top of the second column. In the second example case the gravity switch does not change the heights of the columns.

500

[ { "input": "4\n3 2 1 2", "output": "1 2 2 3 " }, { "input": "3\n2 3 8", "output": "2 3 8 " }, { "input": "5\n2 1 2 1 2", "output": "1 1 2 2 2 " }, { "input": "1\n1", "output": "1 " }, { "input": "2\n4 3", "output": "3 4 " }, { "input": "6\n100 40 60 20 1 80", "output": "1 20 40 60 80 100 " }, { "input": "10\n10 8 6 7 5 3 4 2 9 1", "output": "1 2 3 4 5 6 7 8 9 10 " }, { "input": "10\n1 2 3 4 5 6 7 8 9 10", "output": "1 2 3 4 5 6 7 8 9 10 " }, { "input": "100\n82 51 81 14 37 17 78 92 64 15 8 86 89 8 87 77 66 10 15 12 100 25 92 47 21 78 20 63 13 49 41 36 41 79 16 87 87 69 3 76 80 60 100 49 70 59 72 8 38 71 45 97 71 14 76 54 81 4 59 46 39 29 92 3 49 22 53 99 59 52 74 31 92 43 42 23 44 9 82 47 7 40 12 9 3 55 37 85 46 22 84 52 98 41 21 77 63 17 62 91", "output": "3 3 3 4 7 8 8 8 9 9 10 12 12 13 14 14 15 15 16 17 17 20 21 21 22 22 23 25 29 31 36 37 37 38 39 40 41 41 41 42 43 44 45 46 46 47 47 49 49 49 51 52 52 53 54 55 59 59 59 60 62 63 63 64 66 69 70 71 71 72 74 76 76 77 77 78 78 79 80 81 81 82 82 84 85 86 87 87 87 89 91 92 92 92 92 97 98 99 100 100 " }, { "input": "100\n100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100", "output": "100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 100 " }, { "input": "10\n1 9 7 6 2 4 7 8 1 3", "output": "1 1 2 3 4 6 7 7 8 9 " }, { "input": "20\n53 32 64 20 41 97 50 20 66 68 22 60 74 61 97 54 80 30 72 59", "output": "20 20 22 30 32 41 50 53 54 59 60 61 64 66 68 72 74 80 97 97 " }, { "input": "30\n7 17 4 18 16 12 14 10 1 13 2 16 13 17 8 16 13 14 9 17 17 5 13 5 1 7 6 20 18 12", "output": "1 1 2 4 5 5 6 7 7 8 9 10 12 12 13 13 13 13 14 14 16 16 16 17 17 17 17 18 18 20 " }, { "input": "40\n22 58 68 58 48 53 52 1 16 78 75 17 63 15 36 32 78 75 49 14 42 46 66 54 49 82 40 43 46 55 12 73 5 45 61 60 1 11 31 84", "output": "1 1 5 11 12 14 15 16 17 22 31 32 36 40 42 43 45 46 46 48 49 49 52 53 54 55 58 58 60 61 63 66 68 73 75 75 78 78 82 84 " }, { "input": "70\n1 3 3 1 3 3 1 1 1 3 3 2 3 3 1 1 1 2 3 1 3 2 3 3 3 2 2 3 1 3 3 2 1 1 2 1 2 1 2 2 1 1 1 3 3 2 3 2 3 2 3 3 2 2 2 3 2 3 3 3 1 1 3 3 1 1 1 1 3 1", "output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 " }, { "input": "90\n17 75 51 30 100 5 50 95 51 73 66 5 7 76 43 49 23 55 3 24 95 79 10 11 44 93 17 99 53 66 82 66 63 76 19 4 51 71 75 43 27 5 24 19 48 7 91 15 55 21 7 6 27 10 2 91 64 58 18 21 16 71 90 88 21 20 6 6 95 85 11 7 40 65 52 49 92 98 46 88 17 48 85 96 77 46 100 34 67 52", "output": "2 3 4 5 5 5 6 6 6 7 7 7 7 10 10 11 11 15 16 17 17 17 18 19 19 20 21 21 21 23 24 24 27 27 30 34 40 43 43 44 46 46 48 48 49 49 50 51 51 51 52 52 53 55 55 58 63 64 65 66 66 66 67 71 71 73 75 75 76 76 77 79 82 85 85 88 88 90 91 91 92 93 95 95 95 96 98 99 100 100 " }, { "input": "100\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 " }, { "input": "100\n1 1 1 1 2 1 1 1 1 1 2 2 1 1 2 1 2 1 1 1 2 1 1 2 1 2 1 1 2 2 2 1 1 2 1 1 1 2 2 2 1 1 1 2 1 2 2 1 2 1 1 2 2 1 2 1 2 1 2 2 1 1 1 2 1 1 2 1 2 1 2 2 2 1 2 1 2 2 2 1 2 2 1 1 1 1 2 2 2 2 2 2 2 1 1 1 2 1 2 1", "output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 " }, { "input": "100\n2 1 1 1 3 2 3 3 2 3 3 1 3 3 1 3 3 1 1 1 2 3 1 2 3 1 2 3 3 1 3 1 1 2 3 2 3 3 2 3 3 1 2 2 1 2 3 2 3 2 2 1 1 3 1 3 2 1 3 1 3 1 3 1 1 3 3 3 2 3 2 2 2 2 1 3 3 3 1 2 1 2 3 2 1 3 1 3 2 1 3 1 2 1 2 3 1 3 2 3", "output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 " }, { "input": "100\n7 4 5 5 10 10 5 8 5 7 4 5 4 6 8 8 2 6 3 3 10 7 10 8 6 2 7 3 9 7 7 2 4 5 2 4 9 5 10 1 10 5 10 4 1 3 4 2 6 9 9 9 10 6 2 5 6 1 8 10 4 10 3 4 10 5 5 4 10 4 5 3 7 10 2 7 3 6 9 6 1 6 5 5 4 6 6 4 4 1 5 1 6 6 6 8 8 6 2 6", "output": "1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 9 9 9 9 9 9 10 10 10 10 10 10 10 10 10 10 10 10 10 " }, { "input": "100\n12 10 5 11 13 12 14 13 7 15 15 12 13 19 12 18 14 10 10 3 1 10 16 11 19 8 10 15 5 10 12 16 11 13 11 15 14 12 16 8 11 8 15 2 18 2 14 13 15 20 8 8 4 12 14 7 10 3 9 1 7 19 6 7 2 14 8 20 7 17 18 20 3 18 18 9 6 10 4 1 4 19 9 13 3 3 12 11 11 20 8 2 13 6 7 12 1 4 17 3", "output": "1 1 1 1 2 2 2 2 3 3 3 3 3 3 4 4 4 4 5 5 6 6 6 7 7 7 7 7 7 8 8 8 8 8 8 8 9 9 9 10 10 10 10 10 10 10 10 11 11 11 11 11 11 11 12 12 12 12 12 12 12 12 12 13 13 13 13 13 13 13 14 14 14 14 14 14 15 15 15 15 15 15 16 16 16 17 17 18 18 18 18 18 19 19 19 19 20 20 20 20 " }, { "input": "100\n5 13 1 40 30 10 23 32 33 12 6 4 15 29 31 17 23 5 36 31 32 38 24 11 34 39 19 21 6 19 31 35 1 15 6 29 22 15 17 15 1 17 2 34 20 8 27 2 29 26 13 9 22 27 27 3 20 40 4 40 33 29 36 30 35 16 19 28 26 11 36 24 29 5 40 10 38 34 33 23 34 39 31 7 10 31 22 6 36 24 14 31 34 23 2 4 26 16 2 32", "output": "1 1 1 2 2 2 2 3 4 4 4 5 5 5 6 6 6 6 7 8 9 10 10 10 11 11 12 13 13 14 15 15 15 15 16 16 17 17 17 19 19 19 20 20 21 22 22 22 23 23 23 23 24 24 24 26 26 26 27 27 27 28 29 29 29 29 29 30 30 31 31 31 31 31 31 32 32 32 33 33 33 34 34 34 34 34 35 35 36 36 36 36 38 38 39 39 40 40 40 40 " }, { "input": "100\n72 44 34 74 9 60 26 37 55 77 74 69 28 66 54 55 8 36 57 31 31 48 32 66 40 70 77 43 64 28 37 10 21 58 51 32 60 28 51 52 28 35 7 33 1 68 38 70 57 71 8 20 42 57 59 4 58 10 17 47 22 48 16 3 76 67 32 37 64 47 33 41 75 69 2 76 39 9 27 75 20 21 52 25 71 21 11 29 38 10 3 1 45 55 63 36 27 7 59 41", "output": "1 1 2 3 3 4 7 7 8 8 9 9 10 10 10 11 16 17 20 20 21 21 21 22 25 26 27 27 28 28 28 28 29 31 31 32 32 32 33 33 34 35 36 36 37 37 37 38 38 39 40 41 41 42 43 44 45 47 47 48 48 51 51 52 52 54 55 55 55 57 57 57 58 58 59 59 60 60 63 64 64 66 66 67 68 69 69 70 70 71 71 72 74 74 75 75 76 76 77 77 " }, { "input": "100\n75 18 61 10 56 53 42 57 79 80 31 2 50 45 54 99 84 52 71 21 86 3 19 98 14 37 40 62 63 68 5 10 87 8 81 85 52 52 57 94 2 7 56 96 19 76 1 13 81 6 80 47 22 59 99 32 9 5 36 88 98 91 70 70 12 93 12 22 85 1 97 48 94 16 84 84 51 34 62 7 68 51 30 2 37 82 4 7 27 1 80 9 61 16 59 55 12 96 94 82", "output": "1 1 1 2 2 2 3 4 5 5 6 7 7 7 8 9 9 10 10 12 12 12 13 14 16 16 18 19 19 21 22 22 27 30 31 32 34 36 37 37 40 42 45 47 48 50 51 51 52 52 52 53 54 55 56 56 57 57 59 59 61 61 62 62 63 68 68 70 70 71 75 76 79 80 80 80 81 81 82 82 84 84 84 85 85 86 87 88 91 93 94 94 94 96 96 97 98 98 99 99 " }, { "input": "100\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100", "output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 " }, { "input": "100\n100 99 98 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1", "output": "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 " }, { "input": "100\n50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50", "output": "50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 " }, { "input": "49\n1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97", "output": "1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 " }, { "input": "30\n1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70 73 76 79 82 85 88", "output": "1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64 67 70 73 76 79 82 85 88 " }, { "input": "100\n100 51 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 51 100 " }, { "input": "10\n100 90 80 70 60 50 40 30 20 10", "output": "10 20 30 40 50 60 70 80 90 100 " }, { "input": "1\n10", "output": "10 " } ]

1,694,940,971

2,147,483,647

PyPy 3-64

OK

TESTS

32

62

0

k = int(input()) n = list(map(int, input().split())) n.sort() g = '' for i in range(k): g += str(n[i])+ ' ' print(g)

Title: Gravity Flip Time Limit: None seconds Memory Limit: None megabytes Problem Description: Little Chris is bored during his physics lessons (too easy), so he has built a toy box to keep himself occupied. The box is special, since it has the ability to change gravity. There are *n* columns of toy cubes in the box arranged in a line. The *i*-th column contains *a**i* cubes. At first, the gravity in the box is pulling the cubes downwards. When Chris switches the gravity, it begins to pull all the cubes to the right side of the box. The figure shows the initial and final configurations of the cubes in the box: the cubes that have changed their position are highlighted with orange. Given the initial configuration of the toy cubes in the box, find the amounts of cubes in each of the *n* columns after the gravity switch! Input Specification: The first line of input contains an integer *n* (1<=≤<=*n*<=≤<=100), the number of the columns in the box. The next line contains *n* space-separated integer numbers. The *i*-th number *a**i* (1<=≤<=*a**i*<=≤<=100) denotes the number of cubes in the *i*-th column. Output Specification: Output *n* integer numbers separated by spaces, where the *i*-th number is the amount of cubes in the *i*-th column after the gravity switch. Demo Input: ['4\n3 2 1 2\n', '3\n2 3 8\n'] Demo Output: ['1 2 2 3 \n', '2 3 8 \n'] Note: The first example case is shown on the figure. The top cube of the first column falls to the top of the last column; the top cube of the second column falls to the top of the third column; the middle cube of the first column falls to the top of the second column. In the second example case the gravity switch does not change the heights of the columns.

```python k = int(input()) n = list(map(int, input().split())) n.sort() g = '' for i in range(k): g += str(n[i])+ ' ' print(g) ```

3

770

A

New Password

PROGRAMMING

800

[ "*special", "implementation" ]

null

Innokentiy decides to change the password in the social net "Contact!", but he is too lazy to invent a new password by himself. That is why he needs your help. Innokentiy decides that new password should satisfy the following conditions: - the length of the password must be equal to *n*, - the password should consist only of lowercase Latin letters, - the number of distinct symbols in the password must be equal to *k*, - any two consecutive symbols in the password must be distinct. Your task is to help Innokentiy and to invent a new password which will satisfy all given conditions.

The first line contains two positive integers *n* and *k* (2<=≤<=*n*<=≤<=100, 2<=≤<=*k*<=≤<=*min*(*n*,<=26)) — the length of the password and the number of distinct symbols in it. Pay attention that a desired new password always exists.

Print any password which satisfies all conditions given by Innokentiy.

[ "4 3\n", "6 6\n", "5 2\n" ]

[ "java\n", "python\n", "phphp\n" ]

In the first test there is one of the appropriate new passwords — java, because its length is equal to 4 and 3 distinct lowercase letters a, j and v are used in it. In the second test there is one of the appropriate new passwords — python, because its length is equal to 6 and it consists of 6 distinct lowercase letters. In the third test there is one of the appropriate new passwords — phphp, because its length is equal to 5 and 2 distinct lowercase letters p and h are used in it. Pay attention the condition that no two identical symbols are consecutive is correct for all appropriate passwords in tests.

500

[ { "input": "4 3", "output": "abca" }, { "input": "6 6", "output": "abcdef" }, { "input": "5 2", "output": "ababa" }, { "input": "3 2", "output": "aba" }, { "input": "10 2", "output": "ababababab" }, { "input": "26 13", "output": "abcdefghijklmabcdefghijklm" }, { "input": "100 2", "output": "abababababababababababababababababababababababababababababababababababababababababababababababababab" }, { "input": "100 10", "output": "abcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij" }, { "input": "3 3", "output": "abc" }, { "input": "6 3", "output": "abcabc" }, { "input": "10 3", "output": "abcabcabca" }, { "input": "50 3", "output": "abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcab" }, { "input": "90 2", "output": "ababababababababababababababababababababababababababababababababababababababababababababab" }, { "input": "6 2", "output": "ababab" }, { "input": "99 3", "output": "abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc" }, { "input": "4 2", "output": "abab" }, { "input": "100 3", "output": "abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabca" }, { "input": "40 22", "output": "abcdefghijklmnopqrstuvabcdefghijklmnopqr" }, { "input": "13 8", "output": "abcdefghabcde" }, { "input": "16 15", "output": "abcdefghijklmnoa" }, { "input": "17 17", "output": "abcdefghijklmnopq" }, { "input": "19 4", "output": "abcdabcdabcdabcdabc" }, { "input": "100 26", "output": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuv" }, { "input": "100 25", "output": "abcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxy" }, { "input": "26 26", "output": "abcdefghijklmnopqrstuvwxyz" }, { "input": "27 26", "output": "abcdefghijklmnopqrstuvwxyza" }, { "input": "2 2", "output": "ab" }, { "input": "26 25", "output": "abcdefghijklmnopqrstuvwxya" }, { "input": "99 2", "output": "abababababababababababababababababababababababababababababababababababababababababababababababababa" }, { "input": "99 26", "output": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstu" }, { "input": "4 4", "output": "abcd" }, { "input": "5 3", "output": "abcab" }, { "input": "5 4", "output": "abcda" }, { "input": "5 5", "output": "abcde" }, { "input": "24 22", "output": "abcdefghijklmnopqrstuvab" }, { "input": "26 14", "output": "abcdefghijklmnabcdefghijkl" }, { "input": "26 15", "output": "abcdefghijklmnoabcdefghijk" }, { "input": "30 12", "output": "abcdefghijklabcdefghijklabcdef" }, { "input": "35 4", "output": "abcdabcdabcdabcdabcdabcdabcdabcdabc" }, { "input": "79 3", "output": "abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabca" }, { "input": "79 14", "output": "abcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghijklmnabcdefghi" }, { "input": "85 13", "output": "abcdefghijklmabcdefghijklmabcdefghijklmabcdefghijklmabcdefghijklmabcdefghijklmabcdefg" }, { "input": "90 25", "output": "abcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyabcdefghijklmno" }, { "input": "90 19", "output": "abcdefghijklmnopqrsabcdefghijklmnopqrsabcdefghijklmnopqrsabcdefghijklmnopqrsabcdefghijklmn" }, { "input": "26 24", "output": "abcdefghijklmnopqrstuvwxab" }, { "input": "100 17", "output": "abcdefghijklmnopqabcdefghijklmnopqabcdefghijklmnopqabcdefghijklmnopqabcdefghijklmnopqabcdefghijklmno" }, { "input": "26 2", "output": "ababababababababababababab" } ]

1,657,071,301

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

1

46

409,600

import string n,k=list(map(int,input().split())) alph=string.ascii_letters seq=alph[:k] print(seq*int((n/k)),seq[:int(n//k)],sep='')

Title: New Password Time Limit: None seconds Memory Limit: None megabytes Problem Description: Innokentiy decides to change the password in the social net "Contact!", but he is too lazy to invent a new password by himself. That is why he needs your help. Innokentiy decides that new password should satisfy the following conditions: - the length of the password must be equal to *n*, - the password should consist only of lowercase Latin letters, - the number of distinct symbols in the password must be equal to *k*, - any two consecutive symbols in the password must be distinct. Your task is to help Innokentiy and to invent a new password which will satisfy all given conditions. Input Specification: The first line contains two positive integers *n* and *k* (2<=≤<=*n*<=≤<=100, 2<=≤<=*k*<=≤<=*min*(*n*,<=26)) — the length of the password and the number of distinct symbols in it. Pay attention that a desired new password always exists. Output Specification: Print any password which satisfies all conditions given by Innokentiy. Demo Input: ['4 3\n', '6 6\n', '5 2\n'] Demo Output: ['java\n', 'python\n', 'phphp\n'] Note: In the first test there is one of the appropriate new passwords — java, because its length is equal to 4 and 3 distinct lowercase letters a, j and v are used in it. In the second test there is one of the appropriate new passwords — python, because its length is equal to 6 and it consists of 6 distinct lowercase letters. In the third test there is one of the appropriate new passwords — phphp, because its length is equal to 5 and 2 distinct lowercase letters p and h are used in it. Pay attention the condition that no two identical symbols are consecutive is correct for all appropriate passwords in tests.

```python import string n,k=list(map(int,input().split())) alph=string.ascii_letters seq=alph[:k] print(seq*int((n/k)),seq[:int(n//k)],sep='') ```

0

6

A

Triangle

PROGRAMMING

900

[ "brute force", "geometry" ]

A. Triangle

2

64

Johnny has a younger sister Anne, who is very clever and smart. As she came home from the kindergarten, she told his brother about the task that her kindergartener asked her to solve. The task was just to construct a triangle out of four sticks of different colours. Naturally, one of the sticks is extra. It is not allowed to break the sticks or use their partial length. Anne has perfectly solved this task, now she is asking Johnny to do the same. The boy answered that he would cope with it without any difficulty. However, after a while he found out that different tricky things can occur. It can happen that it is impossible to construct a triangle of a positive area, but it is possible to construct a degenerate triangle. It can be so, that it is impossible to construct a degenerate triangle even. As Johnny is very lazy, he does not want to consider such a big amount of cases, he asks you to help him.

The first line of the input contains four space-separated positive integer numbers not exceeding 100 — lengthes of the sticks.

Output TRIANGLE if it is possible to construct a non-degenerate triangle. Output SEGMENT if the first case cannot take place and it is possible to construct a degenerate triangle. Output IMPOSSIBLE if it is impossible to construct any triangle. Remember that you are to use three sticks. It is not allowed to break the sticks or use their partial length.

[ "4 2 1 3\n", "7 2 2 4\n", "3 5 9 1\n" ]

[ "TRIANGLE\n", "SEGMENT\n", "IMPOSSIBLE\n" ]

none

0

[ { "input": "4 2 1 3", "output": "TRIANGLE" }, { "input": "7 2 2 4", "output": "SEGMENT" }, { "input": "3 5 9 1", "output": "IMPOSSIBLE" }, { "input": "3 1 5 1", "output": "IMPOSSIBLE" }, { "input": "10 10 10 10", "output": "TRIANGLE" }, { "input": "11 5 6 11", "output": "TRIANGLE" }, { "input": "1 1 1 1", "output": "TRIANGLE" }, { "input": "10 20 30 40", "output": "TRIANGLE" }, { "input": "45 25 5 15", "output": "IMPOSSIBLE" }, { "input": "20 5 8 13", "output": "TRIANGLE" }, { "input": "10 30 7 20", "output": "SEGMENT" }, { "input": "3 2 3 2", "output": "TRIANGLE" }, { "input": "70 10 100 30", "output": "SEGMENT" }, { "input": "4 8 16 2", "output": "IMPOSSIBLE" }, { "input": "3 3 3 10", "output": "TRIANGLE" }, { "input": "1 5 5 5", "output": "TRIANGLE" }, { "input": "13 25 12 1", "output": "SEGMENT" }, { "input": "10 100 7 3", "output": "SEGMENT" }, { "input": "50 1 50 100", "output": "TRIANGLE" }, { "input": "50 1 100 49", "output": "SEGMENT" }, { "input": "49 51 100 1", "output": "SEGMENT" }, { "input": "5 11 2 25", "output": "IMPOSSIBLE" }, { "input": "91 50 9 40", "output": "IMPOSSIBLE" }, { "input": "27 53 7 97", "output": "IMPOSSIBLE" }, { "input": "51 90 24 8", "output": "IMPOSSIBLE" }, { "input": "3 5 1 1", "output": "IMPOSSIBLE" }, { "input": "13 49 69 15", "output": "IMPOSSIBLE" }, { "input": "16 99 9 35", "output": "IMPOSSIBLE" }, { "input": "27 6 18 53", "output": "IMPOSSIBLE" }, { "input": "57 88 17 8", "output": "IMPOSSIBLE" }, { "input": "95 20 21 43", "output": "IMPOSSIBLE" }, { "input": "6 19 32 61", "output": "IMPOSSIBLE" }, { "input": "100 21 30 65", "output": "IMPOSSIBLE" }, { "input": "85 16 61 9", "output": "IMPOSSIBLE" }, { "input": "5 6 19 82", "output": "IMPOSSIBLE" }, { "input": "1 5 1 3", "output": "IMPOSSIBLE" }, { "input": "65 10 36 17", "output": "IMPOSSIBLE" }, { "input": "81 64 9 7", "output": "IMPOSSIBLE" }, { "input": "11 30 79 43", "output": "IMPOSSIBLE" }, { "input": "1 1 5 3", "output": "IMPOSSIBLE" }, { "input": "21 94 61 31", "output": "IMPOSSIBLE" }, { "input": "49 24 9 74", "output": "IMPOSSIBLE" }, { "input": "11 19 5 77", "output": "IMPOSSIBLE" }, { "input": "52 10 19 71", "output": "SEGMENT" }, { "input": "2 3 7 10", "output": "SEGMENT" }, { "input": "1 2 6 3", "output": "SEGMENT" }, { "input": "2 6 1 8", "output": "SEGMENT" }, { "input": "1 2 4 1", "output": "SEGMENT" }, { "input": "4 10 6 2", "output": "SEGMENT" }, { "input": "2 10 7 3", "output": "SEGMENT" }, { "input": "5 2 3 9", "output": "SEGMENT" }, { "input": "6 1 4 10", "output": "SEGMENT" }, { "input": "10 6 4 1", "output": "SEGMENT" }, { "input": "3 2 9 1", "output": "SEGMENT" }, { "input": "22 80 29 7", "output": "SEGMENT" }, { "input": "2 6 3 9", "output": "SEGMENT" }, { "input": "3 1 2 1", "output": "SEGMENT" }, { "input": "3 4 7 1", "output": "SEGMENT" }, { "input": "8 4 3 1", "output": "SEGMENT" }, { "input": "2 8 3 5", "output": "SEGMENT" }, { "input": "4 1 2 1", "output": "SEGMENT" }, { "input": "8 1 3 2", "output": "SEGMENT" }, { "input": "6 2 1 8", "output": "SEGMENT" }, { "input": "3 3 3 6", "output": "TRIANGLE" }, { "input": "3 6 3 3", "output": "TRIANGLE" }, { "input": "4 10 4 4", "output": "TRIANGLE" }, { "input": "1 1 2 1", "output": "TRIANGLE" }, { "input": "3 3 3 6", "output": "TRIANGLE" }, { "input": "5 4 5 5", "output": "TRIANGLE" }, { "input": "8 7 8 8", "output": "TRIANGLE" }, { "input": "3 3 3 1", "output": "TRIANGLE" }, { "input": "1 1 6 6", "output": "TRIANGLE" }, { "input": "1 9 1 9", "output": "TRIANGLE" }, { "input": "7 2 2 7", "output": "TRIANGLE" }, { "input": "7 2 3 2", "output": "TRIANGLE" }, { "input": "4 4 10 10", "output": "TRIANGLE" }, { "input": "7 7 10 7", "output": "TRIANGLE" }, { "input": "4 4 4 5", "output": "TRIANGLE" }, { "input": "1 10 9 2", "output": "TRIANGLE" }, { "input": "1 8 2 7", "output": "TRIANGLE" }, { "input": "4 3 2 8", "output": "TRIANGLE" }, { "input": "5 9 5 3", "output": "TRIANGLE" }, { "input": "4 10 3 5", "output": "TRIANGLE" } ]

1,683,029,582

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

30

0

a, b, c, d = int(input()).split() if ((a+b>c and b+c>a and c+a>b) or (a+c>d and c+d>a and a+d>c) or (b+c>d and c+d>b and b+d>c)): print("Triangle") elif (a+b==c or a+b==d or a+c==d or a+c==b or b+c==a or b+c==d or c+d==a or c+d==b): print("Segment") else: print("Impossible")

Title: Triangle Time Limit: 2 seconds Memory Limit: 64 megabytes Problem Description: Johnny has a younger sister Anne, who is very clever and smart. As she came home from the kindergarten, she told his brother about the task that her kindergartener asked her to solve. The task was just to construct a triangle out of four sticks of different colours. Naturally, one of the sticks is extra. It is not allowed to break the sticks or use their partial length. Anne has perfectly solved this task, now she is asking Johnny to do the same. The boy answered that he would cope with it without any difficulty. However, after a while he found out that different tricky things can occur. It can happen that it is impossible to construct a triangle of a positive area, but it is possible to construct a degenerate triangle. It can be so, that it is impossible to construct a degenerate triangle even. As Johnny is very lazy, he does not want to consider such a big amount of cases, he asks you to help him. Input Specification: The first line of the input contains four space-separated positive integer numbers not exceeding 100 — lengthes of the sticks. Output Specification: Output TRIANGLE if it is possible to construct a non-degenerate triangle. Output SEGMENT if the first case cannot take place and it is possible to construct a degenerate triangle. Output IMPOSSIBLE if it is impossible to construct any triangle. Remember that you are to use three sticks. It is not allowed to break the sticks or use their partial length. Demo Input: ['4 2 1 3\n', '7 2 2 4\n', '3 5 9 1\n'] Demo Output: ['TRIANGLE\n', 'SEGMENT\n', 'IMPOSSIBLE\n'] Note: none

```python a, b, c, d = int(input()).split() if ((a+b>c and b+c>a and c+a>b) or (a+c>d and c+d>a and a+d>c) or (b+c>d and c+d>b and b+d>c)): print("Triangle") elif (a+b==c or a+b==d or a+c==d or a+c==b or b+c==a or b+c==d or c+d==a or c+d==b): print("Segment") else: print("Impossible") ```

-1

471

D

MUH and Cube Walls

PROGRAMMING

1,800

[ "string suffix structures", "strings" ]

null

Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev got hold of lots of wooden cubes somewhere. They started making cube towers by placing the cubes one on top of the other. They defined multiple towers standing in a line as a wall. A wall can consist of towers of different heights. Horace was the first to finish making his wall. He called his wall an elephant. The wall consists of *w* towers. The bears also finished making their wall but they didn't give it a name. Their wall consists of *n* towers. Horace looked at the bears' tower and wondered: in how many parts of the wall can he "see an elephant"? He can "see an elephant" on a segment of *w* contiguous towers if the heights of the towers on the segment match as a sequence the heights of the towers in Horace's wall. In order to see as many elephants as possible, Horace can raise and lower his wall. He even can lower the wall below the ground level (see the pictures to the samples for clarification). Your task is to count the number of segments where Horace can "see an elephant".

The first line contains two integers *n* and *w* (1<=≤<=*n*,<=*w*<=≤<=2·105) — the number of towers in the bears' and the elephant's walls correspondingly. The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=109) — the heights of the towers in the bears' wall. The third line contains *w* integers *b**i* (1<=≤<=*b**i*<=≤<=109) — the heights of the towers in the elephant's wall.

Print the number of segments in the bears' wall where Horace can "see an elephant".

[ "13 5\n2 4 5 5 4 3 2 2 2 3 3 2 1\n3 4 4 3 2\n" ]

[ "2" ]

The picture to the left shows Horace's wall from the sample, the picture to the right shows the bears' wall. The segments where Horace can "see an elephant" are in gray.

2,000

[ { "input": "13 5\n2 4 5 5 4 3 2 2 2 3 3 2 1\n3 4 4 3 2", "output": "2" }, { "input": "5 1\n8 71 1 24 2\n31", "output": "5" }, { "input": "6 3\n2 2 2 2 2 2\n5 5 5", "output": "4" }, { "input": "1 1\n576560149\n691846236", "output": "1" }, { "input": "10 5\n5 10 8 10 11 9 11 12 10 15\n4 2 4 5 3", "output": "2" }, { "input": "10 10\n6 8 1 2 5 1 4 24 2 4\n6 8 1 2 5 1 4 24 2 4", "output": "1" }, { "input": "10 10\n6 8 1 2 5 1 14 24 12 4\n7 9 2 3 6 2 15 25 13 5", "output": "1" }, { "input": "8 4\n1 2 3 4 5 6 7 8\n10 11 12 13", "output": "5" }, { "input": "10 5\n172960147 951061917 502625539 319177159 720665763 402410416 880790711 734191412 452846733 449904402\n640219326 792464591 173792179 691347674 125427306", "output": "0" }, { "input": "10 3\n2 3 3 2 1 1 3 1 3 1\n2 1 2", "output": "0" }, { "input": "10 5\n260725416 260725506 260725422 260725512 260725428 260725518 260725434 260725524 260725440 260725530\n925033135 925033225 925033141 925033231 925033147", "output": "3" }, { "input": "2 2\n1000000000 10\n1 20", "output": "0" }, { "input": "7 3\n1 1 1 1 1 1 1\n1000 1256 1512", "output": "0" }, { "input": "3 3\n1 132 3\n2 1 3", "output": "0" }, { "input": "53 3\n1 3 4 4 5 7 10 14 19 25 32 40 49 59 70 82 95 109 124 140 157 175 194 214 235 257 280 304 329 355 382 410 439 469 500 532 565 599 634 670 707 745 784 824 865 907 950 994 1039 1085 1132 1180 1229\n1 2 40", "output": "0" } ]

1,617,361,778

2,147,483,647

PyPy 3

RUNTIME_ERROR

TESTS

1

108

2,150,400

def computeLPS(): m = len(pat) i, j = 1, 0 lps = [0 for i in range(m)] while i < m: if pat[i] == pat[j]: j += 1 lps[i] = j i += 1 else: if j == 0: i += 1 else: j = lps(j - 1) return lps n, w = [int(x) for x in input().split()] wall = [int(x) for x in input().split()] ele = [int(x) for x in input().split()] txt = [wall[i] - wall[i - 1] for i in range(1, n)] pat = [ele[i] - ele[i - 1] for i in range(1, w)] lps = computeLPS() n = len(txt) m = len(pat) i, j = 0, 0 ans = 0 while i < n: if pat[j] == txt[i]: i += 1 j += 1 if j == len(pat): ans += 1 j = lps[j - 1] elif i < n and pat[j] != txt[i]: if j == 0: i += 1 else: j = lps[j - 1] print(ans)

Title: MUH and Cube Walls Time Limit: None seconds Memory Limit: None megabytes Problem Description: Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev got hold of lots of wooden cubes somewhere. They started making cube towers by placing the cubes one on top of the other. They defined multiple towers standing in a line as a wall. A wall can consist of towers of different heights. Horace was the first to finish making his wall. He called his wall an elephant. The wall consists of *w* towers. The bears also finished making their wall but they didn't give it a name. Their wall consists of *n* towers. Horace looked at the bears' tower and wondered: in how many parts of the wall can he "see an elephant"? He can "see an elephant" on a segment of *w* contiguous towers if the heights of the towers on the segment match as a sequence the heights of the towers in Horace's wall. In order to see as many elephants as possible, Horace can raise and lower his wall. He even can lower the wall below the ground level (see the pictures to the samples for clarification). Your task is to count the number of segments where Horace can "see an elephant". Input Specification: The first line contains two integers *n* and *w* (1<=≤<=*n*,<=*w*<=≤<=2·105) — the number of towers in the bears' and the elephant's walls correspondingly. The second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=109) — the heights of the towers in the bears' wall. The third line contains *w* integers *b**i* (1<=≤<=*b**i*<=≤<=109) — the heights of the towers in the elephant's wall. Output Specification: Print the number of segments in the bears' wall where Horace can "see an elephant". Demo Input: ['13 5\n2 4 5 5 4 3 2 2 2 3 3 2 1\n3 4 4 3 2\n'] Demo Output: ['2'] Note: The picture to the left shows Horace's wall from the sample, the picture to the right shows the bears' wall. The segments where Horace can "see an elephant" are in gray.

```python def computeLPS(): m = len(pat) i, j = 1, 0 lps = [0 for i in range(m)] while i < m: if pat[i] == pat[j]: j += 1 lps[i] = j i += 1 else: if j == 0: i += 1 else: j = lps(j - 1) return lps n, w = [int(x) for x in input().split()] wall = [int(x) for x in input().split()] ele = [int(x) for x in input().split()] txt = [wall[i] - wall[i - 1] for i in range(1, n)] pat = [ele[i] - ele[i - 1] for i in range(1, w)] lps = computeLPS() n = len(txt) m = len(pat) i, j = 0, 0 ans = 0 while i < n: if pat[j] == txt[i]: i += 1 j += 1 if j == len(pat): ans += 1 j = lps[j - 1] elif i < n and pat[j] != txt[i]: if j == 0: i += 1 else: j = lps[j - 1] print(ans) ```

-1

465

A

inc ARG

PROGRAMMING

900

[ "implementation" ]

null

Sergey is testing a next-generation processor. Instead of bytes the processor works with memory cells consisting of *n* bits. These bits are numbered from 1 to *n*. An integer is stored in the cell in the following way: the least significant bit is stored in the first bit of the cell, the next significant bit is stored in the second bit, and so on; the most significant bit is stored in the *n*-th bit. Now Sergey wants to test the following instruction: "add 1 to the value of the cell". As a result of the instruction, the integer that is written in the cell must be increased by one; if some of the most significant bits of the resulting number do not fit into the cell, they must be discarded. Sergey wrote certain values of the bits in the cell and is going to add one to its value. How many bits of the cell will change after the operation?

The first line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of bits in the cell. The second line contains a string consisting of *n* characters — the initial state of the cell. The first character denotes the state of the first bit of the cell. The second character denotes the second least significant bit and so on. The last character denotes the state of the most significant bit.

Print a single integer — the number of bits in the cell which change their state after we add 1 to the cell.

[ "4\n1100\n", "4\n1111\n" ]

[ "3\n", "4\n" ]

In the first sample the cell ends up with value 0010, in the second sample — with 0000.

500

[ { "input": "4\n1100", "output": "3" }, { "input": "4\n1111", "output": "4" }, { "input": "1\n0", "output": "1" }, { "input": "1\n1", "output": "1" }, { "input": "2\n00", "output": "1" }, { "input": "2\n01", "output": "1" }, { "input": "2\n10", "output": "2" }, { "input": "2\n11", "output": "2" }, { "input": "10\n0000000000", "output": "1" }, { "input": "20\n11111111110110001100", "output": "11" }, { "input": "50\n01011110100010000001010000100001001101001101101011", "output": "1" }, { "input": "60\n111111111101111111111111111111111111111111111111111111111111", "output": "11" }, { "input": "60\n111111111111111111111111111111111111111111111111111111111111", "output": "60" }, { "input": "66\n111111010010011001110011000111000100011110011001111110011111111101", "output": "7" }, { "input": "90\n000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "1" }, { "input": "91\n1011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", "output": "2" }, { "input": "92\n11111111101011111011111111111111111111111011101111111111011111111111111101111111101011111101", "output": "10" }, { "input": "100\n0001011110100011001100100010111001000001111101101001001001001011110100101101010000000110100101110010", "output": "1" }, { "input": "100\n0111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", "output": "1" }, { "input": "100\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "1" }, { "input": "100\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "output": "1" }, { "input": "100\n1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", "output": "100" }, { "input": "100\n1011001110001000011111110011000100001110010110111101110110011011011000010100110001111100000010110010", "output": "2" }, { "input": "100\n1101111011001111111111110011110111101110111111111111111111111111111111011111111111110111111111111111", "output": "3" }, { "input": "100\n1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", "output": "100" }, { "input": "100\n1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110", "output": "100" }, { "input": "100\n1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101", "output": "99" }, { "input": "100\n1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000", "output": "96" }, { "input": "100\n1111111111111111111111111111111110011000110110001010101100100100001000010010010010000100110000010101", "output": "34" } ]

1,619,081,664

2,147,483,647

Python 3

OK

TESTS

29

62

0

n = int(input()) string = input() x = 1 for i in range(n): if string[i] == '1': x += 1 else: print(x) exit() print(x - 1)

Title: inc ARG Time Limit: None seconds Memory Limit: None megabytes Problem Description: Sergey is testing a next-generation processor. Instead of bytes the processor works with memory cells consisting of *n* bits. These bits are numbered from 1 to *n*. An integer is stored in the cell in the following way: the least significant bit is stored in the first bit of the cell, the next significant bit is stored in the second bit, and so on; the most significant bit is stored in the *n*-th bit. Now Sergey wants to test the following instruction: "add 1 to the value of the cell". As a result of the instruction, the integer that is written in the cell must be increased by one; if some of the most significant bits of the resulting number do not fit into the cell, they must be discarded. Sergey wrote certain values of the bits in the cell and is going to add one to its value. How many bits of the cell will change after the operation? Input Specification: The first line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of bits in the cell. The second line contains a string consisting of *n* characters — the initial state of the cell. The first character denotes the state of the first bit of the cell. The second character denotes the second least significant bit and so on. The last character denotes the state of the most significant bit. Output Specification: Print a single integer — the number of bits in the cell which change their state after we add 1 to the cell. Demo Input: ['4\n1100\n', '4\n1111\n'] Demo Output: ['3\n', '4\n'] Note: In the first sample the cell ends up with value 0010, in the second sample — with 0000.

```python n = int(input()) string = input() x = 1 for i in range(n): if string[i] == '1': x += 1 else: print(x) exit() print(x - 1) ```

3

A

Shortest path of the king

PROGRAMMING

1,000

[ "greedy", "shortest paths" ]

A. Shortest path of the king

1

64

The king is left alone on the chessboard. In spite of this loneliness, he doesn't lose heart, because he has business of national importance. For example, he has to pay an official visit to square *t*. As the king is not in habit of wasting his time, he wants to get from his current position *s* to square *t* in the least number of moves. Help him to do this. In one move the king can get to the square that has a common side or a common vertex with the square the king is currently in (generally there are 8 different squares he can move to).

The first line contains the chessboard coordinates of square *s*, the second line — of square *t*. Chessboard coordinates consist of two characters, the first one is a lowercase Latin letter (from a to h), the second one is a digit from 1 to 8.

In the first line print *n* — minimum number of the king's moves. Then in *n* lines print the moves themselves. Each move is described with one of the 8: L, R, U, D, LU, LD, RU or RD. L, R, U, D stand respectively for moves left, right, up and down (according to the picture), and 2-letter combinations stand for diagonal moves. If the answer is not unique, print any of them.

[ "a8\nh1\n" ]

[ "7\nRD\nRD\nRD\nRD\nRD\nRD\nRD\n" ]

none

0

[ { "input": "a8\nh1", "output": "7\nRD\nRD\nRD\nRD\nRD\nRD\nRD" }, { "input": "b2\nb4", "output": "2\nU\nU" }, { "input": "a5\na5", "output": "0" }, { "input": "h1\nb2", "output": "6\nLU\nL\nL\nL\nL\nL" }, { "input": "c5\nh2", "output": "5\nRD\nRD\nRD\nR\nR" }, { "input": "e1\nf2", "output": "1\nRU" }, { "input": "g4\nd2", "output": "3\nLD\nLD\nL" }, { "input": "a8\nb2", "output": "6\nRD\nD\nD\nD\nD\nD" }, { "input": "d4\nh2", "output": "4\nRD\nRD\nR\nR" }, { "input": "c5\na2", "output": "3\nLD\nLD\nD" }, { "input": "h5\nf8", "output": "3\nLU\nLU\nU" }, { "input": "e6\nb6", "output": "3\nL\nL\nL" }, { "input": "a6\ng4", "output": "6\nRD\nRD\nR\nR\nR\nR" }, { "input": "f7\nc2", "output": "5\nLD\nLD\nLD\nD\nD" }, { "input": "b7\nh8", "output": "6\nRU\nR\nR\nR\nR\nR" }, { "input": "g7\nd6", "output": "3\nLD\nL\nL" }, { "input": "c8\na3", "output": "5\nLD\nLD\nD\nD\nD" }, { "input": "h8\nf1", "output": "7\nLD\nLD\nD\nD\nD\nD\nD" }, { "input": "d1\nb7", "output": "6\nLU\nLU\nU\nU\nU\nU" }, { "input": "a7\ne5", "output": "4\nRD\nRD\nR\nR" }, { "input": "d6\nb1", "output": "5\nLD\nLD\nD\nD\nD" }, { "input": "f5\ng5", "output": "1\nR" }, { "input": "h4\nd1", "output": "4\nLD\nLD\nLD\nL" }, { "input": "b3\na5", "output": "2\nLU\nU" }, { "input": "d2\nf1", "output": "2\nRD\nR" }, { "input": "f1\nc5", "output": "4\nLU\nLU\nLU\nU" }, { "input": "a8\nh1", "output": "7\nRD\nRD\nRD\nRD\nRD\nRD\nRD" }, { "input": "c7\ne5", "output": "2\nRD\nRD" }, { "input": "e7\nb1", "output": "6\nLD\nLD\nLD\nD\nD\nD" }, { "input": "g8\na8", "output": "6\nL\nL\nL\nL\nL\nL" }, { "input": "g6\nf2", "output": "4\nLD\nD\nD\nD" }, { "input": "g4\nc4", "output": "4\nL\nL\nL\nL" }, { "input": "g2\na6", "output": "6\nLU\nLU\nLU\nLU\nL\nL" }, { "input": "f8\nf8", "output": "0" }, { "input": "f5\nd2", "output": "3\nLD\nLD\nD" } ]

1,653,928,517

2,147,483,647

Python 3

OK

TESTS

35

92

0

s, t = input(), input() s = [ord(s[0]) - ord('a') + 1, int(s[1])] t = [ord(t[0]) - ord('a') + 1, int(t[1])] count = 0 p = [] while (s != t): if (s[0] != t[0] and s[1] != t[1]): if (s[0] < t[0]): if (s[1] < t[1]): s[0] += 1 s[1] += 1 p.append("RU") else: s[0] += 1 s[1] -= 1 p.append("RD") else: if (s[1] < t[1]): s[0] -= 1 s[1] += 1 p.append("LU") else: s[0] -= 1 s[1] -= 1 p.append("LD") else: if (s[1] < t[1]): s[1] += 1 p.append("U") elif (s[1] > t[1]): s[1] -= 1 p.append("D") elif (s[0] < t[0]): s[0] += 1 p.append("R") else: s[0] -= 1 p.append("L") count += 1 print(count) print(*p, sep="\n")

Title: Shortest path of the king Time Limit: 1 seconds Memory Limit: 64 megabytes Problem Description: The king is left alone on the chessboard. In spite of this loneliness, he doesn't lose heart, because he has business of national importance. For example, he has to pay an official visit to square *t*. As the king is not in habit of wasting his time, he wants to get from his current position *s* to square *t* in the least number of moves. Help him to do this. In one move the king can get to the square that has a common side or a common vertex with the square the king is currently in (generally there are 8 different squares he can move to). Input Specification: The first line contains the chessboard coordinates of square *s*, the second line — of square *t*. Chessboard coordinates consist of two characters, the first one is a lowercase Latin letter (from a to h), the second one is a digit from 1 to 8. Output Specification: In the first line print *n* — minimum number of the king's moves. Then in *n* lines print the moves themselves. Each move is described with one of the 8: L, R, U, D, LU, LD, RU or RD. L, R, U, D stand respectively for moves left, right, up and down (according to the picture), and 2-letter combinations stand for diagonal moves. If the answer is not unique, print any of them. Demo Input: ['a8\nh1\n'] Demo Output: ['7\nRD\nRD\nRD\nRD\nRD\nRD\nRD\n'] Note: none

```python s, t = input(), input() s = [ord(s[0]) - ord('a') + 1, int(s[1])] t = [ord(t[0]) - ord('a') + 1, int(t[1])] count = 0 p = [] while (s != t): if (s[0] != t[0] and s[1] != t[1]): if (s[0] < t[0]): if (s[1] < t[1]): s[0] += 1 s[1] += 1 p.append("RU") else: s[0] += 1 s[1] -= 1 p.append("RD") else: if (s[1] < t[1]): s[0] -= 1 s[1] += 1 p.append("LU") else: s[0] -= 1 s[1] -= 1 p.append("LD") else: if (s[1] < t[1]): s[1] += 1 p.append("U") elif (s[1] > t[1]): s[1] -= 1 p.append("D") elif (s[0] < t[0]): s[0] += 1 p.append("R") else: s[0] -= 1 p.append("L") count += 1 print(count) print(*p, sep="\n") ```

3.954

207

D4

The Beaver's Problem - 3

PROGRAMMING

2,100

[]

null

The Smart Beaver from ABBYY came up with another splendid problem for the ABBYY Cup participants! This time the Beaver invites the contest participants to check out a problem on sorting documents by their subjects. Let's describe the problem: You've got some training set of documents. For each document you know its subject. The subject in this problem is an integer from 1 to 3. Each of these numbers has a physical meaning. For instance, all documents with subject 3 are about trade. You can download the training set of documents at the following link: http://download4.abbyy.com/a2/X2RZ2ZWXBG5VYWAL61H76ZQM/train.zip. The archive contains three directories with names "1", "2", "3". Directory named "1" contains documents on the 1-st subject, directory "2" contains documents on the 2-nd subject, and directory "3" contains documents on the 3-rd subject. Each document corresponds to exactly one file from some directory. All documents have the following format: the first line contains the document identifier, the second line contains the name of the document, all subsequent lines contain the text of the document. The document identifier is used to make installing the problem more convenient and has no useful information for the participants. You need to write a program that should indicate the subject for a given document. It is guaranteed that all documents given as input to your program correspond to one of the three subjects of the training set.

The first line contains integer *id* (0<=≤<=*id*<=≤<=106) — the document identifier. The second line contains the name of the document. The third and the subsequent lines contain the text of the document. It is guaranteed that the size of any given document will not exceed 10 kilobytes. The tests for this problem are divided into 10 groups. Documents of groups 1 and 2 are taken from the training set, but their identifiers will not match the identifiers specified in the training set. Groups from the 3-rd to the 10-th are roughly sorted by the author in ascending order of difficulty (these groups contain documents which aren't present in the training set).

Print an integer from 1 to 3, inclusive — the number of the subject the given document corresponds to.

[]

none

10

[ { "input": "19000\nGROUP OF FIVE MEETING ENDS\nWASHINGTON, April 8 - A meeting of finance ministers and\ncentral bankers of the Group of Five ended after nearly three\nand a half hours.\nWest German Finance Minister Gerhard Stoltenberg and\nBritish Chancellor of the Exchequer Nigel Lawson declined to\ncomment on the meeting as they emerged from the U.S. Treasury.\nA European monetary official said the ministers of the\nGroup of Seven countries would gather at about three p.m. local\n(1900 GMT) at the Treasury.", "output": "1" }, { "input": "21000\nSWISS TO LAUNCH NEW SERIES OF MONEY MARKET PAPER\nZURICH, April 9 - The Swiss Federal Government will launch\na new series of three month money market certificates totalling\naround 150 mln Swiss francs, the National Bank said.\nSubscriptions close April 14 and payment date is April 16.\nThe last series of three month paper issued in March raised\n147.3 mln francs at an issue price of 99.142 pct, giving an\naverage annual yield of 3.501 pct.", "output": "1" } ]

1,673,005,805

2,147,483,647

Python 3

OK

TESTS4

5

46

0

# LUOGU_RID: 98853652 print(1)########

Title: The Beaver's Problem - 3 Time Limit: None seconds Memory Limit: None megabytes Problem Description: The Smart Beaver from ABBYY came up with another splendid problem for the ABBYY Cup participants! This time the Beaver invites the contest participants to check out a problem on sorting documents by their subjects. Let's describe the problem: You've got some training set of documents. For each document you know its subject. The subject in this problem is an integer from 1 to 3. Each of these numbers has a physical meaning. For instance, all documents with subject 3 are about trade. You can download the training set of documents at the following link: http://download4.abbyy.com/a2/X2RZ2ZWXBG5VYWAL61H76ZQM/train.zip. The archive contains three directories with names "1", "2", "3". Directory named "1" contains documents on the 1-st subject, directory "2" contains documents on the 2-nd subject, and directory "3" contains documents on the 3-rd subject. Each document corresponds to exactly one file from some directory. All documents have the following format: the first line contains the document identifier, the second line contains the name of the document, all subsequent lines contain the text of the document. The document identifier is used to make installing the problem more convenient and has no useful information for the participants. You need to write a program that should indicate the subject for a given document. It is guaranteed that all documents given as input to your program correspond to one of the three subjects of the training set. Input Specification: The first line contains integer *id* (0<=≤<=*id*<=≤<=106) — the document identifier. The second line contains the name of the document. The third and the subsequent lines contain the text of the document. It is guaranteed that the size of any given document will not exceed 10 kilobytes. The tests for this problem are divided into 10 groups. Documents of groups 1 and 2 are taken from the training set, but their identifiers will not match the identifiers specified in the training set. Groups from the 3-rd to the 10-th are roughly sorted by the author in ascending order of difficulty (these groups contain documents which aren't present in the training set). Output Specification: Print an integer from 1 to 3, inclusive — the number of the subject the given document corresponds to. Note: none

```python # LUOGU_RID: 98853652 print(1)######## ```

3

225

A

Dice Tower

PROGRAMMING

1,100

[ "constructive algorithms", "greedy" ]

null

A dice is a cube, its faces contain distinct integers from 1 to 6 as black points. The sum of numbers at the opposite dice faces always equals 7. Please note that there are only two dice (these dices are mirror of each other) that satisfy the given constraints (both of them are shown on the picture on the left). Alice and Bob play dice. Alice has built a tower from *n* dice. We know that in this tower the adjacent dice contact with faces with distinct numbers. Bob wants to uniquely identify the numbers written on the faces of all dice, from which the tower is built. Unfortunately, Bob is looking at the tower from the face, and so he does not see all the numbers on the faces. Bob sees the number on the top of the tower and the numbers on the two adjacent sides (on the right side of the picture shown what Bob sees). Help Bob, tell whether it is possible to uniquely identify the numbers on the faces of all the dice in the tower, or not.

The first line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of dice in the tower. The second line contains an integer *x* (1<=≤<=*x*<=≤<=6) — the number Bob sees at the top of the tower. Next *n* lines contain two space-separated integers each: the *i*-th line contains numbers *a**i*,<=*b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=6; *a**i*<=≠<=*b**i*) — the numbers Bob sees on the two sidelong faces of the *i*-th dice in the tower. Consider the dice in the tower indexed from top to bottom from 1 to *n*. That is, the topmost dice has index 1 (the dice whose top face Bob can see). It is guaranteed that it is possible to make a dice tower that will look as described in the input.

Print "YES" (without the quotes), if it is possible to to uniquely identify the numbers on the faces of all the dice in the tower. If it is impossible, print "NO" (without the quotes).

[ "3\n6\n3 2\n5 4\n2 4\n", "3\n3\n2 6\n4 1\n5 3\n" ]

[ "YES", "NO" ]

none

500

[ { "input": "3\n6\n3 2\n5 4\n2 4", "output": "YES" }, { "input": "3\n3\n2 6\n4 1\n5 3", "output": "NO" }, { "input": "1\n3\n2 1", "output": "YES" }, { "input": "2\n2\n3 1\n1 5", "output": "NO" }, { "input": "3\n2\n1 4\n5 3\n6 4", "output": "NO" }, { "input": "4\n3\n5 6\n1 3\n1 5\n4 1", "output": "NO" }, { "input": "2\n2\n3 1\n1 3", "output": "YES" }, { "input": "3\n2\n1 4\n3 1\n4 6", "output": "YES" }, { "input": "4\n3\n5 6\n1 5\n5 1\n1 5", "output": "YES" }, { "input": "5\n1\n2 3\n5 3\n5 4\n5 1\n3 5", "output": "NO" }, { "input": "10\n5\n1 3\n2 3\n6 5\n6 5\n4 5\n1 3\n1 2\n3 2\n4 2\n1 2", "output": "NO" }, { "input": "15\n4\n2 1\n2 4\n6 4\n5 3\n4 1\n4 2\n6 3\n4 5\n3 5\n2 6\n5 6\n1 5\n3 5\n6 4\n3 2", "output": "NO" }, { "input": "20\n6\n3 2\n4 6\n3 6\n6 4\n5 1\n1 5\n2 6\n1 2\n1 4\n5 3\n2 3\n6 2\n5 4\n2 6\n1 3\n4 6\n4 5\n6 3\n3 1\n6 2", "output": "NO" }, { "input": "25\n4\n1 2\n4 1\n3 5\n2 1\n3 5\n6 5\n3 5\n5 6\n1 2\n2 4\n6 2\n2 3\n2 4\n6 5\n2 3\n6 3\n2 3\n1 3\n2 1\n3 1\n5 6\n3 1\n6 4\n3 6\n2 3", "output": "NO" }, { "input": "100\n3\n6 5\n5 1\n3 2\n1 5\n3 6\n5 4\n2 6\n4 1\n6 3\n4 5\n1 5\n1 4\n4 2\n2 6\n5 4\n4 1\n1 3\n6 5\n5 1\n2 1\n2 4\n2 1\n3 6\n4 1\n6 3\n2 3\n5 1\n2 6\n6 4\n3 5\n4 1\n6 5\n1 5\n1 5\n2 3\n4 1\n5 3\n6 4\n1 3\n5 3\n4 1\n1 4\n2 1\n6 2\n1 5\n6 2\n6 2\n4 5\n4 2\n5 6\n6 3\n1 3\n2 3\n5 4\n6 5\n3 1\n1 2\n4 1\n1 3\n1 3\n6 5\n4 6\n3 1\n2 1\n2 3\n3 2\n4 1\n1 5\n4 1\n6 3\n1 5\n4 5\n4 2\n4 5\n2 6\n2 1\n3 5\n4 6\n4 2\n4 5\n2 4\n3 1\n6 4\n5 6\n3 1\n1 4\n4 5\n6 3\n6 3\n2 1\n5 1\n3 6\n3 5\n2 1\n4 6\n4 2\n5 6\n3 1\n3 5\n3 6", "output": "NO" }, { "input": "99\n3\n2 1\n6 2\n3 6\n1 3\n5 1\n2 6\n4 6\n6 4\n6 4\n6 5\n3 6\n2 6\n1 5\n2 3\n4 6\n1 4\n4 1\n2 3\n4 5\n4 1\n5 1\n1 2\n6 5\n4 6\n6 5\n6 2\n3 6\n6 4\n2 1\n3 1\n2 1\n6 2\n3 5\n4 1\n5 3\n3 1\n1 5\n3 6\n6 2\n1 5\n2 1\n5 1\n4 1\n2 6\n5 4\n4 2\n2 1\n1 5\n1 3\n4 6\n4 6\n4 5\n2 3\n6 2\n3 2\n2 1\n4 6\n6 2\n3 5\n3 6\n3 1\n2 3\n2 1\n3 6\n6 5\n6 3\n1 2\n5 1\n1 4\n6 2\n5 3\n1 3\n5 4\n2 3\n6 3\n1 5\n1 2\n2 6\n5 6\n5 6\n3 5\n3 1\n4 6\n3 1\n4 5\n4 2\n3 5\n6 2\n2 4\n4 6\n6 2\n4 2\n2 3\n2 4\n1 5\n1 4\n3 5\n1 2\n4 5", "output": "NO" }, { "input": "98\n6\n4 2\n1 2\n3 2\n2 1\n2 1\n3 2\n2 3\n6 5\n4 6\n1 5\n4 5\n5 1\n6 5\n1 4\n1 2\n2 4\n6 5\n4 5\n4 6\n3 1\n2 3\n4 1\n4 2\n6 5\n3 2\n4 2\n5 1\n2 4\n1 3\n4 5\n3 2\n1 2\n3 1\n3 2\n3 6\n6 4\n3 6\n3 5\n4 6\n6 5\n3 5\n3 2\n4 2\n6 4\n1 3\n2 4\n5 3\n2 3\n1 3\n5 6\n5 3\n5 3\n4 6\n4 6\n3 6\n4 1\n6 5\n6 2\n1 5\n2 1\n6 2\n5 4\n6 3\n1 5\n2 3\n2 6\n5 6\n2 6\n5 1\n3 2\n6 2\n6 2\n1 2\n2 1\n3 5\n2 1\n4 6\n1 4\n4 5\n3 2\n3 2\n5 4\n1 3\n5 1\n2 3\n6 2\n2 6\n1 5\n5 1\n5 4\n5 1\n5 4\n2 1\n6 5\n1 4\n6 5\n1 2\n3 5", "output": "NO" }, { "input": "97\n3\n2 1\n6 5\n4 1\n6 5\n3 2\n1 2\n6 3\n6 4\n6 3\n1 3\n1 3\n3 1\n3 6\n3 2\n5 6\n4 2\n3 6\n1 5\n2 6\n3 2\n6 2\n2 1\n2 4\n1 3\n3 1\n2 6\n3 6\n4 6\n6 2\n5 1\n6 3\n2 6\n3 6\n2 4\n4 5\n6 5\n4 1\n5 6\n6 2\n5 4\n5 1\n6 5\n1 4\n2 1\n4 5\n4 5\n4 1\n5 4\n1 4\n2 6\n2 6\n1 5\n5 6\n3 2\n2 3\n1 4\n4 1\n3 6\n6 2\n5 3\n6 2\n4 5\n6 2\n2 6\n6 5\n1 4\n2 6\n3 5\n2 6\n4 1\n4 5\n1 3\n4 2\n3 2\n1 2\n5 6\n1 5\n3 5\n2 1\n1 2\n1 2\n6 4\n5 1\n1 2\n2 4\n6 3\n4 5\n1 5\n4 2\n5 1\n3 1\n6 4\n4 2\n1 5\n4 6\n2 1\n2 6", "output": "NO" }, { "input": "96\n4\n1 5\n1 5\n4 6\n1 2\n4 2\n3 2\n4 6\n6 4\n6 3\n6 2\n4 1\n6 4\n5 1\n2 4\n5 6\n6 5\n3 2\n6 2\n3 1\n1 4\n3 2\n6 2\n2 4\n1 3\n5 4\n1 3\n6 2\n6 2\n5 6\n1 4\n4 2\n6 2\n3 1\n6 5\n3 1\n4 2\n6 3\n3 2\n3 6\n1 3\n5 6\n6 4\n1 4\n5 4\n2 6\n3 5\n5 4\n5 1\n2 4\n1 5\n1 3\n1 2\n1 3\n6 4\n6 3\n4 5\n4 1\n3 6\n1 2\n6 4\n1 2\n2 3\n2 1\n4 6\n1 3\n5 1\n4 5\n5 4\n6 3\n2 6\n5 1\n6 2\n3 1\n3 1\n5 4\n3 1\n5 6\n2 6\n5 6\n4 2\n6 5\n3 2\n6 5\n2 3\n6 4\n6 2\n1 2\n4 1\n1 2\n6 3\n2 1\n5 1\n6 5\n5 4\n4 5\n1 2", "output": "NO" }, { "input": "5\n1\n2 3\n3 5\n4 5\n5 4\n5 3", "output": "YES" }, { "input": "10\n5\n1 3\n3 1\n6 3\n6 3\n4 6\n3 1\n1 4\n3 1\n4 6\n1 3", "output": "YES" }, { "input": "15\n4\n2 1\n2 6\n6 5\n5 1\n1 5\n2 1\n6 5\n5 1\n5 1\n6 2\n6 5\n5 1\n5 1\n6 5\n2 6", "output": "YES" }, { "input": "20\n6\n3 2\n4 2\n3 5\n4 2\n5 3\n5 4\n2 3\n2 3\n4 5\n3 5\n3 2\n2 4\n4 5\n2 4\n3 2\n4 2\n5 4\n3 2\n3 5\n2 4", "output": "YES" }, { "input": "25\n4\n1 2\n1 5\n5 6\n1 2\n5 1\n5 6\n5 1\n6 5\n2 1\n2 6\n2 6\n2 6\n2 6\n5 6\n2 6\n6 5\n2 1\n1 5\n1 2\n1 2\n6 5\n1 2\n6 5\n6 2\n2 6", "output": "YES" }, { "input": "100\n3\n6 5\n1 5\n2 1\n5 1\n6 5\n5 1\n6 2\n1 2\n6 5\n5 1\n5 1\n1 5\n2 6\n6 2\n5 6\n1 2\n1 5\n5 6\n1 5\n1 2\n2 6\n1 2\n6 2\n1 5\n6 2\n2 6\n1 5\n6 2\n6 5\n5 6\n1 5\n5 6\n5 1\n5 1\n2 1\n1 2\n5 6\n6 5\n1 5\n5 1\n1 2\n1 5\n1 2\n2 6\n5 1\n2 6\n2 6\n5 6\n2 6\n6 5\n6 5\n1 5\n2 1\n5 6\n5 6\n1 2\n2 1\n1 2\n1 2\n1 2\n5 6\n6 2\n1 5\n1 2\n2 1\n2 6\n1 2\n5 1\n1 5\n6 5\n5 1\n5 1\n2 6\n5 6\n6 2\n1 2\n5 1\n6 2\n2 1\n5 6\n2 1\n1 5\n6 5\n6 5\n1 2\n1 2\n5 1\n6 2\n6 2\n1 2\n1 5\n6 5\n5 6\n1 2\n6 5\n2 1\n6 5\n1 5\n5 6\n6 5", "output": "YES" }, { "input": "99\n3\n2 1\n2 6\n6 2\n1 5\n1 5\n6 2\n6 5\n6 5\n6 2\n5 6\n6 5\n6 2\n5 1\n2 6\n6 5\n1 5\n1 5\n2 6\n5 1\n1 5\n1 5\n2 1\n5 6\n6 5\n5 6\n2 6\n6 2\n6 5\n1 2\n1 2\n1 2\n2 6\n5 6\n1 2\n5 6\n1 2\n5 1\n6 5\n2 6\n5 1\n1 2\n1 5\n1 5\n6 2\n5 1\n2 6\n1 2\n5 1\n1 5\n6 5\n6 5\n5 6\n2 1\n2 6\n2 6\n1 2\n6 2\n2 6\n5 6\n6 5\n1 5\n2 1\n1 2\n6 2\n5 6\n6 5\n2 1\n1 5\n1 5\n2 6\n5 1\n1 2\n5 6\n2 1\n6 5\n5 1\n2 1\n6 2\n6 5\n6 5\n5 6\n1 2\n6 5\n1 2\n5 1\n2 1\n5 1\n2 6\n2 1\n6 2\n2 6\n2 6\n2 1\n2 1\n5 1\n1 5\n5 6\n2 1\n5 6", "output": "YES" }, { "input": "98\n6\n4 2\n2 3\n2 3\n2 3\n2 3\n2 3\n3 2\n5 4\n4 2\n5 4\n5 4\n5 4\n5 3\n4 5\n2 3\n4 2\n5 3\n5 4\n4 5\n3 5\n3 2\n4 2\n2 4\n5 4\n2 3\n2 4\n5 4\n4 2\n3 5\n5 4\n2 3\n2 4\n3 5\n2 3\n3 5\n4 2\n3 5\n5 3\n4 2\n5 3\n5 3\n2 3\n2 4\n4 5\n3 2\n4 2\n3 5\n3 2\n3 5\n5 4\n3 5\n3 5\n4 2\n4 2\n3 2\n4 5\n5 4\n2 3\n5 4\n2 4\n2 3\n4 5\n3 5\n5 4\n3 2\n2 3\n5 3\n2 3\n5 3\n2 3\n2 3\n2 4\n2 3\n2 3\n5 3\n2 3\n4 2\n4 2\n5 4\n2 3\n2 3\n4 5\n3 2\n5 3\n3 2\n2 4\n2 4\n5 3\n5 4\n4 5\n5 3\n4 5\n2 4\n5 3\n4 2\n5 4\n2 4\n5 3", "output": "YES" }, { "input": "97\n3\n2 1\n5 6\n1 2\n5 6\n2 6\n2 1\n6 2\n6 5\n6 2\n1 5\n1 2\n1 2\n6 2\n2 6\n6 5\n2 6\n6 5\n5 1\n6 2\n2 6\n2 6\n1 2\n2 6\n1 2\n1 5\n6 2\n6 5\n6 5\n2 6\n1 5\n6 5\n6 2\n6 2\n2 6\n5 6\n5 6\n1 5\n6 5\n2 6\n5 6\n1 5\n5 6\n1 5\n1 2\n5 1\n5 1\n1 5\n5 1\n1 5\n6 2\n6 2\n5 1\n6 5\n2 1\n2 6\n1 5\n1 5\n6 2\n2 6\n5 6\n2 6\n5 6\n2 6\n6 2\n5 6\n1 2\n6 2\n5 6\n6 2\n1 5\n5 6\n1 5\n2 6\n2 6\n2 1\n6 5\n5 1\n5 1\n1 2\n2 1\n2 1\n6 2\n1 5\n2 1\n2 1\n6 2\n5 1\n5 1\n2 6\n1 5\n1 2\n6 2\n2 6\n5 1\n6 5\n1 2\n6 2", "output": "YES" }, { "input": "96\n4\n1 5\n5 1\n6 5\n2 1\n2 1\n2 6\n6 5\n6 5\n6 2\n2 6\n1 5\n6 5\n1 5\n2 6\n6 5\n5 6\n2 1\n2 6\n1 2\n1 5\n2 6\n2 6\n2 1\n1 5\n5 1\n1 2\n2 6\n2 6\n6 5\n1 5\n2 1\n2 6\n1 2\n5 6\n1 5\n2 6\n6 2\n2 6\n6 5\n1 5\n6 5\n6 5\n1 5\n5 1\n6 2\n5 1\n5 1\n1 5\n2 6\n5 1\n1 5\n2 1\n1 2\n6 2\n6 2\n5 6\n1 5\n6 5\n2 1\n6 5\n2 1\n2 1\n1 2\n6 2\n1 2\n1 5\n5 1\n5 6\n6 5\n6 2\n1 5\n2 6\n1 2\n1 2\n5 1\n1 5\n6 5\n6 2\n6 5\n2 6\n5 6\n2 1\n5 6\n2 1\n6 5\n2 6\n2 1\n1 5\n2 1\n6 2\n1 2\n1 5\n5 6\n5 1\n5 6\n2 1", "output": "YES" }, { "input": "3\n6\n3 2\n5 4\n2 6", "output": "NO" }, { "input": "4\n1\n2 3\n2 3\n2 3\n1 3", "output": "NO" }, { "input": "2\n6\n3 2\n6 4", "output": "NO" }, { "input": "3\n6\n3 2\n5 6\n2 4", "output": "NO" }, { "input": "2\n5\n6 3\n4 5", "output": "NO" }, { "input": "2\n6\n3 2\n6 5", "output": "NO" }, { "input": "2\n1\n3 2\n1 2", "output": "NO" }, { "input": "2\n3\n5 1\n3 5", "output": "NO" }, { "input": "2\n1\n2 3\n1 2", "output": "NO" }, { "input": "2\n1\n2 3\n2 1", "output": "NO" }, { "input": "3\n1\n4 5\n4 1\n4 5", "output": "NO" }, { "input": "2\n4\n2 6\n5 4", "output": "NO" }, { "input": "2\n6\n3 2\n6 2", "output": "NO" }, { "input": "2\n3\n2 1\n3 5", "output": "NO" }, { "input": "2\n3\n1 2\n3 1", "output": "NO" }, { "input": "2\n3\n2 6\n5 3", "output": "NO" }, { "input": "3\n3\n1 2\n3 2\n3 1", "output": "NO" }, { "input": "3\n5\n3 1\n1 3\n2 3", "output": "NO" }, { "input": "2\n6\n2 4\n6 5", "output": "NO" }, { "input": "2\n6\n4 5\n6 5", "output": "NO" }, { "input": "2\n6\n3 5\n3 6", "output": "NO" }, { "input": "2\n4\n1 2\n4 5", "output": "NO" }, { "input": "2\n3\n2 6\n3 1", "output": "NO" } ]

1,415,541,413

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

3

124

0

import sys import math n = int(sys.stdin.readline()) k = [0] * 7 k[int(sys.stdin.readline())] += 1 res = 1 for i in range(n): a, b = [int(x) for x in (sys.stdin.readline()).split()] if(k[a] > 0 and k[b] > 0): res += 1 k[a] += 1 k[b] += 1 if(res >= n - 1): print("YES") else: print("NO")

Title: Dice Tower Time Limit: None seconds Memory Limit: None megabytes Problem Description: A dice is a cube, its faces contain distinct integers from 1 to 6 as black points. The sum of numbers at the opposite dice faces always equals 7. Please note that there are only two dice (these dices are mirror of each other) that satisfy the given constraints (both of them are shown on the picture on the left). Alice and Bob play dice. Alice has built a tower from *n* dice. We know that in this tower the adjacent dice contact with faces with distinct numbers. Bob wants to uniquely identify the numbers written on the faces of all dice, from which the tower is built. Unfortunately, Bob is looking at the tower from the face, and so he does not see all the numbers on the faces. Bob sees the number on the top of the tower and the numbers on the two adjacent sides (on the right side of the picture shown what Bob sees). Help Bob, tell whether it is possible to uniquely identify the numbers on the faces of all the dice in the tower, or not. Input Specification: The first line contains a single integer *n* (1<=≤<=*n*<=≤<=100) — the number of dice in the tower. The second line contains an integer *x* (1<=≤<=*x*<=≤<=6) — the number Bob sees at the top of the tower. Next *n* lines contain two space-separated integers each: the *i*-th line contains numbers *a**i*,<=*b**i* (1<=≤<=*a**i*,<=*b**i*<=≤<=6; *a**i*<=≠<=*b**i*) — the numbers Bob sees on the two sidelong faces of the *i*-th dice in the tower. Consider the dice in the tower indexed from top to bottom from 1 to *n*. That is, the topmost dice has index 1 (the dice whose top face Bob can see). It is guaranteed that it is possible to make a dice tower that will look as described in the input. Output Specification: Print "YES" (without the quotes), if it is possible to to uniquely identify the numbers on the faces of all the dice in the tower. If it is impossible, print "NO" (without the quotes). Demo Input: ['3\n6\n3 2\n5 4\n2 4\n', '3\n3\n2 6\n4 1\n5 3\n'] Demo Output: ['YES', 'NO'] Note: none

```python import sys import math n = int(sys.stdin.readline()) k = [0] * 7 k[int(sys.stdin.readline())] += 1 res = 1 for i in range(n): a, b = [int(x) for x in (sys.stdin.readline()).split()] if(k[a] > 0 and k[b] > 0): res += 1 k[a] += 1 k[b] += 1 if(res >= n - 1): print("YES") else: print("NO") ```

0

94

A

Restoring Password

PROGRAMMING

900

[ "implementation", "strings" ]

A. Restoring Password

2

256

Igor K. always used to trust his favorite Kashpirovsky Antivirus. That is why he didn't hesitate to download the link one of his groupmates sent him via QIP Infinium. The link was said to contain "some real funny stuff about swine influenza". The antivirus had no objections and Igor K. run the flash application he had downloaded. Immediately his QIP Infinium said: "invalid login/password". Igor K. entered the ISQ from his additional account and looked at the info of his main one. His name and surname changed to "H1N1" and "Infected" correspondingly, and the "Additional Information" field contained a strange-looking binary code 80 characters in length, consisting of zeroes and ones. "I've been hacked" — thought Igor K. and run the Internet Exploiter browser to quickly type his favourite search engine's address. Soon he learned that it really was a virus that changed ISQ users' passwords. Fortunately, he soon found out that the binary code was actually the encrypted password where each group of 10 characters stood for one decimal digit. Accordingly, the original password consisted of 8 decimal digits. Help Igor K. restore his ISQ account by the encrypted password and encryption specification.

The input data contains 11 lines. The first line represents the binary code 80 characters in length. That is the code written in Igor K.'s ISQ account's info. Next 10 lines contain pairwise distinct binary codes 10 characters in length, corresponding to numbers 0, 1, ..., 9.

Print one line containing 8 characters — The password to Igor K.'s ISQ account. It is guaranteed that the solution exists.

[ "01001100100101100000010110001001011001000101100110010110100001011010100101101100\n0100110000\n0100110010\n0101100000\n0101100010\n0101100100\n0101100110\n0101101000\n0101101010\n0101101100\n0101101110\n", "10101101111001000010100100011010101101110010110111011000100011011110010110001000\n1001000010\n1101111001\n1001000110\n1010110111\n0010110111\n1101001101\n1011000001\n1110010101\n1011011000\n0110001000\n" ]

[ "12345678\n", "30234919\n" ]

none

500

[ { "input": "01001100100101100000010110001001011001000101100110010110100001011010100101101100\n0100110000\n0100110010\n0101100000\n0101100010\n0101100100\n0101100110\n0101101000\n0101101010\n0101101100\n0101101110", "output": "12345678" }, { "input": "10101101111001000010100100011010101101110010110111011000100011011110010110001000\n1001000010\n1101111001\n1001000110\n1010110111\n0010110111\n1101001101\n1011000001\n1110010101\n1011011000\n0110001000", "output": "30234919" }, { "input": "00010101101110110101100110101100010101100010101111000101011010011010110010000011\n0101010110\n0001001101\n1001101011\n0000100011\n0010101111\n1110110101\n0001010110\n0110111000\n0000111110\n0010000011", "output": "65264629" }, { "input": "10100100010010010011011001101000100100110110011010011001101011000100110110011010\n1111110011\n1001000111\n1001000100\n1100010011\n0110011010\n0010000001\n1110101110\n0010000110\n0010010011\n1010010001", "output": "98484434" }, { "input": "00101100011111010001001000000110110000000110010011001111111010110010001011000000\n0010000001\n0110010011\n0010000010\n1011001000\n0011111110\n0110001000\n1111010001\n1011000000\n0000100110\n0010110001", "output": "96071437" }, { "input": "10001110111110000001000010001010001110110000100010100010111101101101010000100010\n0000010110\n1101010111\n1000101111\n0001011110\n0011110101\n0101100100\n0110110101\n0000100010\n1000111011\n1110000001", "output": "89787267" }, { "input": "10010100011001010001010101001101010100110100111011001010111100011001000010100000\n0011100000\n1001100100\n0001100100\n0010100000\n0101010011\n0010101110\n0010101111\n0100111011\n1001010001\n1111111110", "output": "88447623" }, { "input": "01101100111000000101011011001110000001011111111000111111100001011010001001011001\n1000000101\n0101101000\n0101110101\n1101011110\n0000101100\n1111111000\n0001001101\n0110111011\n0110110011\n1001011001", "output": "80805519" }, { "input": "11100011000100010110010011101010101010011110001100011010111110011000011010110111\n1110001100\n0110101111\n0100111010\n0101000000\n1001100001\n1010101001\n0000100010\n1010110111\n1100011100\n0100010110", "output": "09250147" }, { "input": "10000110110000010100000010001000111101110110101011110111000100001101000000100010\n0000010100\n0000110001\n0110101011\n1101110001\n1000011011\n0000110100\n0011110111\n1000110010\n0000100010\n0000011011", "output": "40862358" }, { "input": "01000000010000000110100101000110110000100100000001101100001000011111111001010001\n1011000010\n1111101010\n0111110011\n0000000110\n0000001001\n0001111111\n0110010010\n0100000001\n1011001000\n1001010001", "output": "73907059" }, { "input": "01111000111110011001110101110011110000111110010001101100110110100111101011001101\n1110010001\n1001100000\n1100001000\n1010011110\n1011001101\n0111100011\n1101011100\n1110011001\n1111000011\n0010000101", "output": "57680434" }, { "input": "01001100101000100010001011110001000101001001100010010000001001001100101001011111\n1001011111\n1110010111\n0111101011\n1000100010\n0011100101\n0100000010\n0010111100\n0100010100\n1001100010\n0100110010", "output": "93678590" }, { "input": "01110111110000111011101010110110101011010100110111000011101101110101011101001000\n0110000101\n1010101101\n1101010111\n1101011100\n0100110111\n0111011111\n1100011001\n0111010101\n0000111011\n1101001000", "output": "58114879" }, { "input": "11101001111100110101110011010100110011011110100111010110110011000111000011001101\n1100011100\n1100110101\n1011101000\n0011011110\n0011001101\n0100010001\n1110100111\n1010101100\n1110110100\n0101101100", "output": "61146904" }, { "input": "10101010001011010001001001011000100101100001011011101010101110101010001010101000\n0010110101\n1010011010\n1010101000\n1011010001\n1010101011\n0010010110\n0110100010\n1010100101\n0001011011\n0110100001", "output": "23558422" }, { "input": "11110101001100010000110100001110101011011111010100110001000001001010001001101111\n0101101100\n1001101111\n1010101101\n0100101000\n1111110000\n0101010010\n1100010000\n1111010100\n1101000011\n1011111111", "output": "76827631" }, { "input": "10001100110000110111100011001101111110110011110101000011011100001101110000110111\n0011110101\n0101100011\n1000110011\n1011011001\n0111111011\n0101111011\n0000110111\n0100001110\n1000000111\n0110110111", "output": "26240666" }, { "input": "10000100010000111101100100111101111011101000001001100001000110000010010000111101\n1001001111\n0000111101\n1000010001\n0110011101\n0110101000\n1011111001\n0111101110\n1000001001\n1101011111\n0001010100", "output": "21067271" }, { "input": "01101111000110111100011011110001101111001010001100101000110001010101100100000010\n1010001100\n0011010011\n0101010110\n1111001100\n1100011000\n0100101100\n1001100101\n0110111100\n0011001101\n0100000010", "output": "77770029" }, { "input": "10100111011010001011111000000111100000010101000011000010111101010000111010011101\n1010011101\n1010111111\n0110100110\n1111000100\n1110000001\n0000101111\n0011111000\n1000110001\n0101000011\n1010001011", "output": "09448580" }, { "input": "10000111111000011111001010101010010011111001001111000010010100100011000010001100\n1101101110\n1001001111\n0000100101\n1100111010\n0010101010\n1110000110\n1100111101\n0010001100\n1110000001\n1000011111", "output": "99411277" }, { "input": "10110110111011001111101100111100111111011011011011001111110110010011100010000111\n0111010011\n0111101100\n1001101010\n0101000101\n0010000111\n0011111101\n1011001111\n1101111000\n1011011011\n1001001110", "output": "86658594" }, { "input": "01001001100101100011110110111100000110001111001000100000110111110010000000011000\n0100100110\n1000001011\n1000111110\n0000011000\n0101100011\n1101101111\n1111001000\n1011011001\n1000001101\n0010101000", "output": "04536863" }, { "input": "10010100011101000011100100001100101111000010111100000010010000001001001101011101\n1001000011\n1101000011\n1001010001\n1101011101\n1000010110\n0011111101\n0010111100\n0000100100\n1010001000\n0101000110", "output": "21066773" }, { "input": "01111111110101111111011111111111010010000001100000101000100100111001011010001001\n0111111111\n0101111111\n0100101101\n0001100000\n0011000101\n0011100101\n1101001000\n0010111110\n1010001001\n1111000111", "output": "01063858" }, { "input": "00100011111001001010001111000011101000001110100000000100101011101000001001001010\n0010001111\n1001001010\n1010011001\n0011100111\n1000111000\n0011110000\n0000100010\n0001001010\n1111110111\n1110100000", "output": "01599791" }, { "input": "11011101000100110100110011010101100011111010011010010011010010010010100110101111\n0100110100\n1001001010\n0001111101\n1101011010\n1101110100\n1100110101\n0110101111\n0110001111\n0001101000\n1010011010", "output": "40579016" }, { "input": "10000010111101110110011000111110000011100110001111100100000111000011011000001011\n0111010100\n1010110110\n1000001110\n1110000100\n0110001111\n1101110110\n1100001101\n1000001011\n0000000101\n1001000001", "output": "75424967" }, { "input": "11101100101110111110111011111010001111111111000001001001000010001111111110110010\n0101100001\n1111010011\n1110111110\n0100110100\n1110011111\n1000111111\n0010010000\n1110110010\n0011000010\n1111000001", "output": "72259657" }, { "input": "01011110100101111010011000001001100000101001110011010111101011010000110110010101\n0100111100\n0101110011\n0101111010\n0110000010\n0101001111\n1101000011\n0110010101\n0111011010\n0001101110\n1001110011", "output": "22339256" }, { "input": "01100000100101111000100001100010000110000010100100100001100000110011101001110000\n0101111000\n1001110000\n0001000101\n0110110111\n0010100100\n1000011000\n1101110110\n0110000010\n0001011010\n0011001110", "output": "70554591" }, { "input": "11110011011000001001111100110101001000010100100000110011001110011111100100100001\n1010011000\n1111001101\n0100100001\n1111010011\n0100100000\n1001111110\n1010100111\n1000100111\n1000001001\n1100110011", "output": "18124952" }, { "input": "10001001011000100101010110011101011001110010000001010110000101000100101111101010\n0101100001\n1100001100\n1111101010\n1000100101\n0010000001\n0100010010\n0010110110\n0101100111\n0000001110\n1101001110", "output": "33774052" }, { "input": "00110010000111001001001100100010010111101011011110001011111100000101000100000001\n0100000001\n1011011110\n0010111111\n0111100111\n0100111001\n0000010100\n1001011110\n0111001001\n0100010011\n0011001000", "output": "97961250" }, { "input": "01101100001000110101101100101111101110010011010111100011010100010001101000110101\n1001101001\n1000110101\n0110110000\n0111100100\n0011010111\n1110111001\n0001000110\n0000000100\n0001101001\n1011001011", "output": "21954161" }, { "input": "10101110000011010110101011100000101101000110100000101101101101110101000011110010\n0110100000\n1011011011\n0011110010\n0001110110\n0010110100\n1100010010\n0001101011\n1010111000\n0011010110\n0111010100", "output": "78740192" }, { "input": "11000101011100100111010000010001000001001100101100000011000000001100000101011010\n1100010101\n1111101011\n0101011010\n0100000100\n1000110111\n1100100111\n1100101100\n0111001000\n0000110000\n0110011111", "output": "05336882" }, { "input": "11110100010000101110010110001000001011100101100010110011011011111110001100110110\n0101100010\n0100010001\n0000101110\n1100110110\n0101000101\n0011001011\n1111010001\n1000110010\n1111111000\n1010011111", "output": "62020383" }, { "input": "00011001111110000011101011010001010111100110100101000110011111011001100000001100\n0111001101\n0101011110\n0001100111\n1101011111\n1110000011\n0000001100\n0111010001\n1101100110\n1010110100\n0110100101", "output": "24819275" }, { "input": "10111110010011111001001111100101010111010011111001001110101000111110011001111101\n0011111001\n0101011101\n0100001010\n0001110010\n1001111101\n0011101010\n1111001001\n1100100001\n1001101000\n1011111001", "output": "90010504" }, { "input": "01111101111100101010001001011110111001110111110111011111011110110111111011011111\n1111110111\n0010000101\n0110000100\n0111111011\n1011100111\n1100101010\n1011011111\n1100010001\n0111110111\n0010010111", "output": "85948866" }, { "input": "01111100000111110000110010111001111100001001101010110010111010001000101001101010\n0100010101\n1011110101\n1010100100\n1010000001\n1001101010\n0101100110\n1000100010\n0111110000\n1100101110\n0110010110", "output": "77874864" }, { "input": "11100011010000000010011110010111001011111001000111000000001000000000100111100101\n0000000010\n1110001101\n0011010101\n0111100101\n1001000111\n1101001111\n0111010110\n1100101111\n0110000000\n1101101011", "output": "10374003" }, { "input": "01111011100111101110011001000110001111101000111110100100100001011111001011100010\n0110010100\n1100010001\n0111101110\n1001001000\n1010011011\n1000111110\n0010110101\n1011100010\n0101111100\n0110010001", "output": "22955387" }, { "input": "11011010001100000011000100110011010101000110011110110000001100111100001000011111\n0000100010\n1000011111\n1101101000\n0110011110\n0011110000\n1100000011\n0010001100\n0101101000\n0001001100\n1101010100", "output": "25893541" }, { "input": "01011001011111010010101111011001000011001100011101101111011011010011101011110110\n0100001100\n0101100101\n1111111011\n1111010010\n1111101100\n1100011101\n1011000011\n1101001110\n1011110110\n0110001010", "output": "13805878" }, { "input": "11110011011000111111001100111110001111111100000010111100110100110011111111001101\n1111001101\n1001101010\n1100110010\n0011001111\n0001011110\n1000110011\n1000111111\n0110001010\n1001011101\n1100000010", "output": "06369030" }, { "input": "01110011110010000011011001011000001000010110010110011001100001100110001100101000\n0000100001\n0110011000\n1010000010\n1110011101\n0111001111\n1100101000\n0010000011\n0110010000\n1100100101\n0110010110", "output": "46909115" }, { "input": "00001011001111110111111111011111111101110101110100010111010010100101100001010110\n1111110111\n0001010110\n0111011011\n0111000001\n1010010110\n0101110100\n0001000101\n0000111000\n0110100001\n0000101100", "output": "90005541" } ]

1,623,707,300

2,147,483,647

Python 3

OK

TESTS

50

154

0

import sys def get_ints(): return [int(x) for x in sys.stdin.readline().strip().split()] def get_string(): return sys.stdin.readline().strip() s=get_string() sar=[get_string() for i in range(10)] for i in range(8): str=s[i*10:i*10+10] for j in range(len(sar)): if(str==sar[j]): print(j,end="") break

Title: Restoring Password Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Igor K. always used to trust his favorite Kashpirovsky Antivirus. That is why he didn't hesitate to download the link one of his groupmates sent him via QIP Infinium. The link was said to contain "some real funny stuff about swine influenza". The antivirus had no objections and Igor K. run the flash application he had downloaded. Immediately his QIP Infinium said: "invalid login/password". Igor K. entered the ISQ from his additional account and looked at the info of his main one. His name and surname changed to "H1N1" and "Infected" correspondingly, and the "Additional Information" field contained a strange-looking binary code 80 characters in length, consisting of zeroes and ones. "I've been hacked" — thought Igor K. and run the Internet Exploiter browser to quickly type his favourite search engine's address. Soon he learned that it really was a virus that changed ISQ users' passwords. Fortunately, he soon found out that the binary code was actually the encrypted password where each group of 10 characters stood for one decimal digit. Accordingly, the original password consisted of 8 decimal digits. Help Igor K. restore his ISQ account by the encrypted password and encryption specification. Input Specification: The input data contains 11 lines. The first line represents the binary code 80 characters in length. That is the code written in Igor K.'s ISQ account's info. Next 10 lines contain pairwise distinct binary codes 10 characters in length, corresponding to numbers 0, 1, ..., 9. Output Specification: Print one line containing 8 characters — The password to Igor K.'s ISQ account. It is guaranteed that the solution exists. Demo Input: ['01001100100101100000010110001001011001000101100110010110100001011010100101101100\n0100110000\n0100110010\n0101100000\n0101100010\n0101100100\n0101100110\n0101101000\n0101101010\n0101101100\n0101101110\n', '10101101111001000010100100011010101101110010110111011000100011011110010110001000\n1001000010\n1101111001\n1001000110\n1010110111\n0010110111\n1101001101\n1011000001\n1110010101\n1011011000\n0110001000\n'] Demo Output: ['12345678\n', '30234919\n'] Note: none

```python import sys def get_ints(): return [int(x) for x in sys.stdin.readline().strip().split()] def get_string(): return sys.stdin.readline().strip() s=get_string() sar=[get_string() for i in range(10)] for i in range(8): str=s[i*10:i*10+10] for j in range(len(sar)): if(str==sar[j]): print(j,end="") break ```

3.9615

300

A

Array

PROGRAMMING

1,100

[ "brute force", "constructive algorithms", "implementation" ]

null

Vitaly has an array of *n* distinct integers. Vitaly wants to divide this array into three non-empty sets so as the following conditions hold: 1. The product of all numbers in the first set is less than zero (<=<<=0). 1. The product of all numbers in the second set is greater than zero (<=><=0). 1. The product of all numbers in the third set is equal to zero. 1. Each number from the initial array must occur in exactly one set. Help Vitaly. Divide the given array.

The first line of the input contains integer *n* (3<=≤<=*n*<=≤<=100). The second line contains *n* space-separated distinct integers *a*1,<=*a*2,<=...,<=*a**n* (|*a**i*|<=≤<=103) — the array elements.

In the first line print integer *n*1 (*n*1<=><=0) — the number of elements in the first set. Then print *n*1 numbers — the elements that got to the first set. In the next line print integer *n*2 (*n*2<=><=0) — the number of elements in the second set. Then print *n*2 numbers — the elements that got to the second set. In the next line print integer *n*3 (*n*3<=><=0) — the number of elements in the third set. Then print *n*3 numbers — the elements that got to the third set. The printed sets must meet the described conditions. It is guaranteed that the solution exists. If there are several solutions, you are allowed to print any of them.

[ "3\n-1 2 0\n", "4\n-1 -2 -3 0\n" ]

[ "1 -1\n1 2\n1 0\n", "1 -1\n2 -3 -2\n1 0\n" ]

none

500

[ { "input": "3\n-1 2 0", "output": "1 -1\n1 2\n1 0" }, { "input": "4\n-1 -2 -3 0", "output": "1 -1\n2 -3 -2\n1 0" }, { "input": "5\n-1 -2 1 2 0", "output": "1 -1\n2 1 2\n2 0 -2" }, { "input": "100\n-64 -51 -75 -98 74 -26 -1 -8 -99 -76 -53 -80 -43 -22 -100 -62 -34 -5 -65 -81 -18 -91 -92 -16 -23 -95 -9 -19 -44 -46 -79 52 -35 4 -87 -7 -90 -20 -71 -61 -67 -50 -66 -68 -49 -27 -32 -57 -85 -59 -30 -36 -3 -77 86 -25 -94 -56 60 -24 -37 -72 -41 -31 11 -48 28 -38 -42 -39 -33 -70 -84 0 -93 -73 -14 -69 -40 -97 -6 -55 -45 -54 -10 -29 -96 -12 -83 -15 -21 -47 17 -2 -63 -89 88 13 -58 -82", "output": "89 -64 -51 -75 -98 -26 -1 -8 -99 -76 -53 -80 -43 -22 -100 -62 -34 -5 -65 -81 -18 -91 -92 -16 -23 -95 -9 -19 -44 -46 -79 -35 -87 -7 -90 -20 -71 -61 -67 -50 -66 -68 -49 -27 -32 -57 -85 -59 -30 -36 -3 -77 -25 -94 -56 -24 -37 -72 -41 -31 -48 -38 -42 -39 -33 -70 -84 -93 -73 -14 -69 -40 -97 -6 -55 -45 -54 -10 -29 -96 -12 -83 -15 -21 -47 -2 -63 -89 -58 -82\n10 74 52 4 86 60 11 28 17 88 13\n1 0" }, { "input": "100\n3 -66 -17 54 24 -29 76 89 32 -37 93 -16 99 -25 51 78 23 68 -95 59 18 34 -45 77 9 39 -10 19 8 73 -5 60 12 31 0 2 26 40 48 30 52 49 27 4 87 57 85 58 -61 50 83 80 69 67 91 97 -96 11 100 56 82 53 13 -92 -72 70 1 -94 -63 47 21 14 74 7 6 33 55 65 64 -41 81 42 36 28 38 20 43 71 90 -88 22 84 -86 15 75 62 44 35 98 46", "output": "19 -66 -17 -29 -37 -16 -25 -95 -45 -10 -5 -61 -96 -92 -72 -94 -63 -41 -88 -86\n80 3 54 24 76 89 32 93 99 51 78 23 68 59 18 34 77 9 39 19 8 73 60 12 31 2 26 40 48 30 52 49 27 4 87 57 85 58 50 83 80 69 67 91 97 11 100 56 82 53 13 70 1 47 21 14 74 7 6 33 55 65 64 81 42 36 28 38 20 43 71 90 22 84 15 75 62 44 35 98 46\n1 0" }, { "input": "100\n-17 16 -70 32 -60 75 -100 -9 -68 -30 -42 86 -88 -98 -47 -5 58 -14 -94 -73 -80 -51 -66 -85 -53 49 -25 -3 -45 -69 -11 -64 83 74 -65 67 13 -91 81 6 -90 -54 -12 -39 0 -24 -71 -41 -44 57 -93 -20 -92 18 -43 -52 -55 -84 -89 -19 40 -4 -99 -26 -87 -36 -56 -61 -62 37 -95 -28 63 23 35 -82 1 -2 -78 -96 -21 -77 -76 -27 -10 -97 -8 46 -15 -48 -34 -59 -7 -29 50 -33 -72 -79 22 38", "output": "75 -17 -70 -60 -100 -9 -68 -30 -42 -88 -98 -47 -5 -14 -94 -73 -80 -51 -66 -85 -53 -25 -3 -45 -69 -11 -64 -65 -91 -90 -54 -12 -39 -24 -71 -41 -44 -93 -20 -92 -43 -52 -55 -84 -89 -19 -4 -99 -26 -87 -36 -56 -61 -62 -95 -28 -82 -2 -78 -96 -21 -77 -76 -27 -10 -97 -8 -15 -48 -34 -59 -7 -29 -33 -72 -79\n24 16 32 75 86 58 49 83 74 67 13 81 6 57 18 40 37 63 23 35 1 46 50 22 38\n1 0" }, { "input": "100\n-97 -90 61 78 87 -52 -3 65 83 38 30 -60 35 -50 -73 -77 44 -32 -81 17 -67 58 -6 -34 47 -28 71 -45 69 -80 -4 -7 -57 -79 43 -27 -31 29 16 -89 -21 -93 95 -82 74 -5 -70 -20 -18 36 -64 -66 72 53 62 -68 26 15 76 -40 -99 8 59 88 49 -23 9 10 56 -48 -98 0 100 -54 25 94 13 -63 42 39 -1 55 24 -12 75 51 41 84 -96 -85 -2 -92 14 -46 -91 -19 -11 -86 22 -37", "output": "51 -97 -90 -52 -3 -60 -50 -73 -77 -32 -81 -67 -6 -34 -28 -45 -80 -4 -7 -57 -79 -27 -31 -89 -21 -93 -82 -5 -70 -20 -18 -64 -66 -68 -40 -99 -23 -48 -98 -54 -63 -1 -12 -96 -85 -2 -92 -46 -91 -19 -11 -86\n47 61 78 87 65 83 38 30 35 44 17 58 47 71 69 43 29 16 95 74 36 72 53 62 26 15 76 8 59 88 49 9 10 56 100 25 94 13 42 39 55 24 75 51 41 84 14 22\n2 0 -37" }, { "input": "100\n-75 -60 -18 -92 -71 -9 -37 -34 -82 28 -54 93 -83 -76 -58 -88 -17 -97 64 -39 -96 -81 -10 -98 -47 -100 -22 27 14 -33 -19 -99 87 -66 57 -21 -90 -70 -32 -26 24 -77 -74 13 -44 16 -5 -55 -2 -6 -7 -73 -1 -68 -30 -95 -42 69 0 -20 -79 59 -48 -4 -72 -67 -46 62 51 -52 -86 -40 56 -53 85 -35 -8 49 50 65 29 11 -43 -15 -41 -12 -3 -80 -31 -38 -91 -45 -25 78 94 -23 -63 84 89 -61", "output": "73 -75 -60 -18 -92 -71 -9 -37 -34 -82 -54 -83 -76 -58 -88 -17 -97 -39 -96 -81 -10 -98 -47 -100 -22 -33 -19 -99 -66 -21 -90 -70 -32 -26 -77 -74 -44 -5 -55 -2 -6 -7 -73 -1 -68 -30 -95 -42 -20 -79 -48 -4 -72 -67 -46 -52 -86 -40 -53 -35 -8 -43 -15 -41 -12 -3 -80 -31 -38 -91 -45 -25 -23 -63\n25 28 93 64 27 14 87 57 24 13 16 69 59 62 51 56 85 49 50 65 29 11 78 94 84 89\n2 0 -61" }, { "input": "100\n-87 -48 -76 -1 -10 -17 -22 -19 -27 -99 -43 49 38 -20 -45 -64 44 -96 -35 -74 -65 -41 -21 -75 37 -12 -67 0 -3 5 -80 -93 -81 -97 -47 -63 53 -100 95 -79 -83 -90 -32 88 -77 -16 -23 -54 -28 -4 -73 -98 -25 -39 60 -56 -34 -2 -11 -55 -52 -69 -68 -29 -82 -62 -36 -13 -6 -89 8 -72 18 -15 -50 -71 -70 -92 -42 -78 -61 -9 -30 -85 -91 -94 84 -86 -7 -57 -14 40 -33 51 -26 46 59 -31 -58 -66", "output": "83 -87 -48 -76 -1 -10 -17 -22 -19 -27 -99 -43 -20 -45 -64 -96 -35 -74 -65 -41 -21 -75 -12 -67 -3 -80 -93 -81 -97 -47 -63 -100 -79 -83 -90 -32 -77 -16 -23 -54 -28 -4 -73 -98 -25 -39 -56 -34 -2 -11 -55 -52 -69 -68 -29 -82 -62 -36 -13 -6 -89 -72 -15 -50 -71 -70 -92 -42 -78 -61 -9 -30 -85 -91 -94 -86 -7 -57 -14 -33 -26 -31 -58 -66\n16 49 38 44 37 5 53 95 88 60 8 18 84 40 51 46 59\n1 0" }, { "input": "100\n-95 -28 -43 -72 -11 -24 -37 -35 -44 -66 -45 -62 -96 -51 -55 -23 -31 -26 -59 -17 77 -69 -10 -12 -78 -14 -52 -57 -40 -75 4 -98 -6 7 -53 -3 -90 -63 -8 -20 88 -91 -32 -76 -80 -97 -34 -27 -19 0 70 -38 -9 -49 -67 73 -36 2 81 -39 -65 -83 -64 -18 -94 -79 -58 -16 87 -22 -74 -25 -13 -46 -89 -47 5 -15 -54 -99 56 -30 -60 -21 -86 33 -1 -50 -68 -100 -85 -29 92 -48 -61 42 -84 -93 -41 -82", "output": "85 -95 -28 -43 -72 -11 -24 -37 -35 -44 -66 -45 -62 -96 -51 -55 -23 -31 -26 -59 -17 -69 -10 -12 -78 -14 -52 -57 -40 -75 -98 -6 -53 -3 -90 -63 -8 -20 -91 -32 -76 -80 -97 -34 -27 -19 -38 -9 -49 -67 -36 -39 -65 -83 -64 -18 -94 -79 -58 -16 -22 -74 -25 -13 -46 -89 -47 -15 -54 -99 -30 -60 -21 -86 -1 -50 -68 -100 -85 -29 -48 -61 -84 -93 -41 -82\n14 77 4 7 88 70 73 2 81 87 5 56 33 92 42\n1 0" }, { "input": "100\n-12 -41 57 13 83 -36 53 69 -6 86 -75 87 11 -5 -4 -14 -37 -84 70 2 -73 16 31 34 -45 94 -9 26 27 52 -42 46 96 21 32 7 -18 61 66 -51 95 -48 -76 90 80 -40 89 77 78 54 -30 8 88 33 -24 82 -15 19 1 59 44 64 -97 -60 43 56 35 47 39 50 29 28 -17 -67 74 23 85 -68 79 0 65 55 -3 92 -99 72 93 -71 38 -10 -100 -98 81 62 91 -63 -58 49 -20 22", "output": "35 -12 -41 -36 -6 -75 -5 -4 -14 -37 -84 -73 -45 -9 -42 -18 -51 -48 -76 -40 -30 -24 -15 -97 -60 -17 -67 -68 -3 -99 -71 -10 -100 -98 -63 -58\n63 57 13 83 53 69 86 87 11 70 2 16 31 34 94 26 27 52 46 96 21 32 7 61 66 95 90 80 89 77 78 54 8 88 33 82 19 1 59 44 64 43 56 35 47 39 50 29 28 74 23 85 79 65 55 92 72 93 38 81 62 91 49 22\n2 0 -20" }, { "input": "100\n-34 81 85 -96 50 20 54 86 22 10 -19 52 65 44 30 53 63 71 17 98 -92 4 5 -99 89 -23 48 9 7 33 75 2 47 -56 42 70 -68 57 51 83 82 94 91 45 46 25 95 11 -12 62 -31 -87 58 38 67 97 -60 66 73 -28 13 93 29 59 -49 77 37 -43 -27 0 -16 72 15 79 61 78 35 21 3 8 84 1 -32 36 74 -88 26 100 6 14 40 76 18 90 24 69 80 64 55 41", "output": "19 -34 -96 -19 -92 -99 -23 -56 -68 -12 -31 -87 -60 -28 -49 -43 -27 -16 -32 -88\n80 81 85 50 20 54 86 22 10 52 65 44 30 53 63 71 17 98 4 5 89 48 9 7 33 75 2 47 42 70 57 51 83 82 94 91 45 46 25 95 11 62 58 38 67 97 66 73 13 93 29 59 77 37 72 15 79 61 78 35 21 3 8 84 1 36 74 26 100 6 14 40 76 18 90 24 69 80 64 55 41\n1 0" }, { "input": "100\n-1000 -986 -979 -955 -966 -963 -973 -959 -972 -906 -924 -927 -929 -918 -977 -967 -921 -989 -911 -995 -945 -919 -971 -913 -912 -933 -969 -975 -920 -988 -997 -994 -953 -962 -940 -905 -978 -948 -957 -996 0 -976 -949 -931 -903 -985 -923 -993 -944 -909 -938 -946 -934 -992 -904 -980 -954 -943 -917 -968 -991 -956 -902 -942 -999 -998 -908 -928 -930 -914 -922 -936 -960 -937 -939 -926 -965 -925 -951 -910 -907 -970 -990 -984 -964 -987 -916 -947 -982 -950 -974 -915 -932 -958 -981 -941 -961 -983 -952 -935", "output": "97 -1000 -986 -979 -955 -966 -963 -973 -959 -972 -906 -924 -927 -929 -918 -977 -967 -921 -989 -911 -995 -945 -919 -971 -913 -912 -933 -969 -975 -920 -988 -997 -994 -953 -962 -940 -905 -978 -948 -957 -996 -976 -949 -931 -903 -985 -923 -993 -944 -909 -938 -946 -934 -992 -904 -980 -954 -943 -917 -968 -991 -956 -902 -942 -999 -998 -908 -928 -930 -914 -922 -936 -960 -937 -939 -926 -965 -925 -951 -910 -907 -970 -990 -984 -964 -987 -916 -947 -982 -950 -974 -915 -932 -958 -981 -941 -961 -983\n2 -935 -952\n1 0" }, { "input": "99\n-1000 -986 -979 -955 -966 -963 -973 -959 -972 -906 -924 -927 -929 -918 -977 -967 -921 -989 -911 -995 -945 -919 -971 -913 -912 -933 -969 -975 -920 -988 -997 -994 -953 -962 -940 -905 -978 -948 -957 -996 0 -976 -949 -931 -903 -985 -923 -993 -944 -909 -938 -946 -934 -992 -904 -980 -954 -943 -917 -968 -991 -956 -902 -942 -999 -998 -908 -928 -930 -914 -922 -936 -960 -937 -939 -926 -965 -925 -951 -910 -907 -970 -990 -984 -964 -987 -916 -947 -982 -950 -974 -915 -932 -958 -981 -941 -961 -983 -952", "output": "95 -1000 -986 -979 -955 -966 -963 -973 -959 -972 -906 -924 -927 -929 -918 -977 -967 -921 -989 -911 -995 -945 -919 -971 -913 -912 -933 -969 -975 -920 -988 -997 -994 -953 -962 -940 -905 -978 -948 -957 -996 -976 -949 -931 -903 -985 -923 -993 -944 -909 -938 -946 -934 -992 -904 -980 -954 -943 -917 -968 -991 -956 -902 -942 -999 -998 -908 -928 -930 -914 -922 -936 -960 -937 -939 -926 -965 -925 -951 -910 -907 -970 -990 -984 -964 -987 -916 -947 -982 -950 -974 -915 -932 -958 -981 -941\n2 -952 -983\n2 0 -961" }, { "input": "59\n-990 -876 -641 -726 718 -53 803 -954 894 -265 -587 -665 904 349 754 -978 441 794 -768 -428 -569 -476 188 -620 -290 -333 45 705 -201 109 165 446 13 122 714 -562 -15 -86 -960 43 329 578 287 -776 -14 -71 915 886 -259 337 -495 913 -498 -669 -673 818 225 647 0", "output": "29 -990 -876 -641 -726 -53 -954 -265 -587 -665 -978 -768 -428 -569 -476 -620 -290 -333 -201 -562 -15 -86 -960 -776 -14 -71 -259 -495 -498 -669\n28 718 803 894 904 349 754 441 794 188 45 705 109 165 446 13 122 714 43 329 578 287 915 886 337 913 818 225 647\n2 0 -673" }, { "input": "64\n502 885 -631 -906 735 687 642 -29 -696 -165 -524 15 -129 -663 -846 -501 -651 895 -341 -833 -142 33 -847 688 945 -192 -587 -930 603 849 736 676 788 256 863 -509 319 -49 -807 -158 218 -886 -143 -639 118 -156 -291 325 892 -916 -622 -960 -959 -731 -943 436 -535 861 745 589 -159 376 -182 0", "output": "35 -631 -906 -29 -696 -165 -524 -129 -663 -846 -501 -651 -341 -833 -142 -847 -192 -587 -930 -509 -49 -807 -158 -886 -143 -639 -156 -291 -916 -622 -960 -959 -731 -943 -535 -159\n27 502 885 735 687 642 15 895 33 688 945 603 849 736 676 788 256 863 319 218 118 325 892 436 861 745 589 376\n2 0 -182" }, { "input": "5\n-1 -2 -3 -4 0", "output": "1 -1\n2 -4 -3\n2 0 -2" }, { "input": "3\n-101 101 0", "output": "1 -101\n1 101\n1 0" }, { "input": "21\n-100 -200 -300 -400 -500 -600 -700 -800 -900 -1000 0 100 200 300 400 500 600 700 800 900 1000", "output": "9 -100 -200 -300 -400 -500 -600 -700 -800 -900\n10 100 200 300 400 500 600 700 800 900 1000\n2 0 -1000" }, { "input": "4\n0 -1 -2 -3", "output": "1 -1\n2 -3 -2\n1 0" } ]

1,622,894,101

2,147,483,647

Python 3

OK

TESTS

20

218

0

n=int(input()) arr=list(map(int,input().split(" "))) pos=[] neg=[] zero=[] for i in range(len(arr)): if arr[i]>0: pos.append(arr[i]) elif arr[i]==0: zero.append(arr[i]) else: neg.append(arr[i]) if len(pos)==0: #print("yes no elements in positive") pos.append(neg[0]) pos.append(neg[1]) neg.pop(1) neg.pop(0) if len(neg)%2==0: #print("yes negative one is even") zero.append(neg[0]) neg.pop(0) print(len(neg),end=" ") for i in range(len(neg)): print(neg[i],end=" ") print() print(len(pos),end=" ") for i in range(len(pos)): print(pos[i],end=" ") print() print(len(zero),end=" ") for i in range(len(zero)): print(zero[i],end=" ")

Title: Array Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vitaly has an array of *n* distinct integers. Vitaly wants to divide this array into three non-empty sets so as the following conditions hold: 1. The product of all numbers in the first set is less than zero (<=<<=0). 1. The product of all numbers in the second set is greater than zero (<=><=0). 1. The product of all numbers in the third set is equal to zero. 1. Each number from the initial array must occur in exactly one set. Help Vitaly. Divide the given array. Input Specification: The first line of the input contains integer *n* (3<=≤<=*n*<=≤<=100). The second line contains *n* space-separated distinct integers *a*1,<=*a*2,<=...,<=*a**n* (|*a**i*|<=≤<=103) — the array elements. Output Specification: In the first line print integer *n*1 (*n*1<=><=0) — the number of elements in the first set. Then print *n*1 numbers — the elements that got to the first set. In the next line print integer *n*2 (*n*2<=><=0) — the number of elements in the second set. Then print *n*2 numbers — the elements that got to the second set. In the next line print integer *n*3 (*n*3<=><=0) — the number of elements in the third set. Then print *n*3 numbers — the elements that got to the third set. The printed sets must meet the described conditions. It is guaranteed that the solution exists. If there are several solutions, you are allowed to print any of them. Demo Input: ['3\n-1 2 0\n', '4\n-1 -2 -3 0\n'] Demo Output: ['1 -1\n1 2\n1 0\n', '1 -1\n2 -3 -2\n1 0\n'] Note: none

```python n=int(input()) arr=list(map(int,input().split(" "))) pos=[] neg=[] zero=[] for i in range(len(arr)): if arr[i]>0: pos.append(arr[i]) elif arr[i]==0: zero.append(arr[i]) else: neg.append(arr[i]) if len(pos)==0: #print("yes no elements in positive") pos.append(neg[0]) pos.append(neg[1]) neg.pop(1) neg.pop(0) if len(neg)%2==0: #print("yes negative one is even") zero.append(neg[0]) neg.pop(0) print(len(neg),end=" ") for i in range(len(neg)): print(neg[i],end=" ") print() print(len(pos),end=" ") for i in range(len(pos)): print(pos[i],end=" ") print() print(len(zero),end=" ") for i in range(len(zero)): print(zero[i],end=" ") ```

3

678

A

Johny Likes Numbers

PROGRAMMING

800

[ "implementation", "math" ]

null

Johny likes numbers *n* and *k* very much. Now Johny wants to find the smallest integer *x* greater than *n*, so it is divisible by the number *k*.

The only line contains two integers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=109).

Print the smallest integer *x*<=><=*n*, so it is divisible by the number *k*.

[ "5 3\n", "25 13\n", "26 13\n" ]

[ "6\n", "26\n", "39\n" ]

none

0

[ { "input": "5 3", "output": "6" }, { "input": "25 13", "output": "26" }, { "input": "26 13", "output": "39" }, { "input": "1 1", "output": "2" }, { "input": "8 8", "output": "16" }, { "input": "14 15", "output": "15" }, { "input": "197 894", "output": "894" }, { "input": "6058 8581", "output": "8581" }, { "input": "97259 41764", "output": "125292" }, { "input": "453145 333625", "output": "667250" }, { "input": "2233224 4394826", "output": "4394826" }, { "input": "76770926 13350712", "output": "80104272" }, { "input": "687355301 142098087", "output": "710490435" }, { "input": "1000000000 999999999", "output": "1999999998" }, { "input": "1000000000 1000000000", "output": "2000000000" }, { "input": "999999999 1000000000", "output": "1000000000" }, { "input": "1000000000 1", "output": "1000000001" }, { "input": "1000000000 2", "output": "1000000002" }, { "input": "999999999 1", "output": "1000000000" }, { "input": "100000000 1", "output": "100000001" }, { "input": "999999999 500000000", "output": "1000000000" }, { "input": "999999990 10", "output": "1000000000" }, { "input": "1000000000 999999997", "output": "1999999994" }, { "input": "999999999 2", "output": "1000000000" }, { "input": "999999984 1", "output": "999999985" }, { "input": "999999983 1", "output": "999999984" }, { "input": "666666666 1", "output": "666666667" }, { "input": "1000000000 990000000", "output": "1980000000" }, { "input": "41 48", "output": "48" }, { "input": "123456 2", "output": "123458" }, { "input": "111 111", "output": "222" }, { "input": "878787 1", "output": "878788" }, { "input": "121 1", "output": "122" }, { "input": "114514 114514", "output": "229028" }, { "input": "500000001 1000000000", "output": "1000000000" }, { "input": "999999997 1", "output": "999999998" }, { "input": "100000000 10", "output": "100000010" } ]

1,485,974,145

2,147,483,647

Python 3

COMPILATION_ERROR

TESTS

0

inp = input().split(" ") n = int(inp[0]) k = int(inp[1]) n += 1 while(True): if (n ℅ k == 0): break n += 1 print(n)

Title: Johny Likes Numbers Time Limit: None seconds Memory Limit: None megabytes Problem Description: Johny likes numbers *n* and *k* very much. Now Johny wants to find the smallest integer *x* greater than *n*, so it is divisible by the number *k*. Input Specification: The only line contains two integers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=109). Output Specification: Print the smallest integer *x*<=><=*n*, so it is divisible by the number *k*. Demo Input: ['5 3\n', '25 13\n', '26 13\n'] Demo Output: ['6\n', '26\n', '39\n'] Note: none

```python inp = input().split(" ") n = int(inp[0]) k = int(inp[1]) n += 1 while(True): if (n ℅ k == 0): break n += 1 print(n) ```

-1

318

A

Even Odds

PROGRAMMING

900

[ "math" ]

null

Being a nonconformist, Volodya is displeased with the current state of things, particularly with the order of natural numbers (natural number is positive integer number). He is determined to rearrange them. But there are too many natural numbers, so Volodya decided to start with the first *n*. He writes down the following sequence of numbers: firstly all odd integers from 1 to *n* (in ascending order), then all even integers from 1 to *n* (also in ascending order). Help our hero to find out which number will stand at the position number *k*.

The only line of input contains integers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=1012). Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.

Print the number that will stand at the position number *k* after Volodya's manipulations.

[ "10 3\n", "7 7\n" ]

[ "5", "6" ]

In the first sample Volodya's sequence will look like this: {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}. The third place in the sequence is therefore occupied by the number 5.

500

[ { "input": "10 3", "output": "5" }, { "input": "7 7", "output": "6" }, { "input": "7 1", "output": "1" }, { "input": "7 2", "output": "3" }, { "input": "8 5", "output": "2" }, { "input": "8 3", "output": "5" }, { "input": "8 4", "output": "7" }, { "input": "1000000000000 500000000001", "output": "2" }, { "input": "999999999997 499999999999", "output": "999999999997" }, { "input": "999999999999 999999999999", "output": "999999999998" }, { "input": "1000000000000 1", "output": "1" }, { "input": "999999999999 1", "output": "1" }, { "input": "1 1", "output": "1" }, { "input": "1000000000000 1000000000000", "output": "1000000000000" }, { "input": "1000000000000 500000000000", "output": "999999999999" }, { "input": "1000000000000 499999999999", "output": "999999999997" }, { "input": "999999999997 499999999998", "output": "999999999995" }, { "input": "619234238 556154835", "output": "493075432" }, { "input": "38151981 36650624", "output": "35149266" }, { "input": "680402465 442571217", "output": "204739968" }, { "input": "109135284 9408714", "output": "18817427" }, { "input": "603701841 56038951", "output": "112077901" }, { "input": "356764822 321510177", "output": "286255532" }, { "input": "284911189 142190783", "output": "284381565" }, { "input": "91028405 61435545", "output": "31842684" } ]

1,695,858,089

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

1

30

0

import math number, position = [int(x) for x in input().split()] if position <= (number+1)/2: n = 2 * position -1 else: n = 2 * (position - (number + 1) / 2) print(abs(n))

Title: Even Odds Time Limit: None seconds Memory Limit: None megabytes Problem Description: Being a nonconformist, Volodya is displeased with the current state of things, particularly with the order of natural numbers (natural number is positive integer number). He is determined to rearrange them. But there are too many natural numbers, so Volodya decided to start with the first *n*. He writes down the following sequence of numbers: firstly all odd integers from 1 to *n* (in ascending order), then all even integers from 1 to *n* (also in ascending order). Help our hero to find out which number will stand at the position number *k*. Input Specification: The only line of input contains integers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=1012). Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier. Output Specification: Print the number that will stand at the position number *k* after Volodya's manipulations. Demo Input: ['10 3\n', '7 7\n'] Demo Output: ['5', '6'] Note: In the first sample Volodya's sequence will look like this: {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}. The third place in the sequence is therefore occupied by the number 5.

```python import math number, position = [int(x) for x in input().split()] if position <= (number+1)/2: n = 2 * position -1 else: n = 2 * (position - (number + 1) / 2) print(abs(n)) ```

0

265

A

Colorful Stones (Simplified Edition)

PROGRAMMING

800

[ "implementation" ]

null

There is a sequence of colorful stones. The color of each stone is one of red, green, or blue. You are given a string *s*. The *i*-th (1-based) character of *s* represents the color of the *i*-th stone. If the character is "R", "G", or "B", the color of the corresponding stone is red, green, or blue, respectively. Initially Squirrel Liss is standing on the first stone. You perform instructions one or more times. Each instruction is one of the three types: "RED", "GREEN", or "BLUE". After an instruction *c*, if Liss is standing on a stone whose colors is *c*, Liss will move one stone forward, else she will not move. You are given a string *t*. The number of instructions is equal to the length of *t*, and the *i*-th character of *t* represents the *i*-th instruction. Calculate the final position of Liss (the number of the stone she is going to stand on in the end) after performing all the instructions, and print its 1-based position. It is guaranteed that Liss don't move out of the sequence.

The input contains two lines. The first line contains the string *s* (1<=≤<=|*s*|<=≤<=50). The second line contains the string *t* (1<=≤<=|*t*|<=≤<=50). The characters of each string will be one of "R", "G", or "B". It is guaranteed that Liss don't move out of the sequence.

Print the final 1-based position of Liss in a single line.

[ "RGB\nRRR\n", "RRRBGBRBBB\nBBBRR\n", "BRRBGBRGRBGRGRRGGBGBGBRGBRGRGGGRBRRRBRBBBGRRRGGBBB\nBBRBGGRGRGBBBRBGRBRBBBBRBRRRBGBBGBBRRBBGGRBRRBRGRB\n" ]

[ "2\n", "3\n", "15\n" ]

none

500

[ { "input": "RGB\nRRR", "output": "2" }, { "input": "RRRBGBRBBB\nBBBRR", "output": "3" }, { "input": "BRRBGBRGRBGRGRRGGBGBGBRGBRGRGGGRBRRRBRBBBGRRRGGBBB\nBBRBGGRGRGBBBRBGRBRBBBBRBRRRBGBBGBBRRBBGGRBRRBRGRB", "output": "15" }, { "input": "G\nRRBBRBRRBR", "output": "1" }, { "input": "RRRRRBRRBRRGRBGGRRRGRBBRBBBBBRGRBGBRRGBBBRBBGBRGBB\nB", "output": "1" }, { "input": "RRGGBRGRBG\nBRRGGBBGGR", "output": "7" }, { "input": "BBRRGBGGRGBRGBRBRBGR\nGGGRBGGGBRRRRGRBGBGRGRRBGRBGBG", "output": "15" }, { "input": "GBRRBGBGBBBBRRRGBGRRRGBGBBBRGR\nRRGBRRGRBBBBBBGRRBBR", "output": "8" }, { "input": "BRGRRGRGRRGBBGBBBRRBBRRBGBBGRGBBGGRGBRBGGGRRRBGGBB\nRGBBGRRBBBRRGRRBRBBRGBBGGGRGBGRRRRBRBGGBRBGGGRGBRR", "output": "16" }, { "input": "GGRGGBRRGRGBRRGGRBBGGRRGBBBGBBBGGRBGGBRBBRGBRRRBRG\nGGRGRRRRRRRRRGBBBBRGBRGRGRRGBBRGGBRBBRBGBRGRRRRGGR", "output": "18" }, { "input": "RBBRBGBBGGGBRRBGBRGRRGGRBBBBGRBGGBRRBGBBRBRGBBGGGG\nBRRGRBGRBGBRGBRBGGBBBGBBRGRBGRGRBGRBGGRRBGBRGRRBBG", "output": "23" }, { "input": "RRGGRRBRGRGBRGBRGBBRGGGBRBGBRGBRGGBRBRGBGRRBBGGRBR\nBRGRBBBGRBGRRGGRRRRRRRRGGGGGGGGBGGGGGGGRGRBBRGRGBR", "output": "14" }, { "input": "RBRBRRRRRGGR\nBBBBRRGGBGRBRGBBRGGGRGGBRRBRBRBGGG", "output": "12" }, { "input": "GGRGGGBRGRGRBBRGGGRBGRRR\nGBBBBGBGBGBBBRGGRGGBGRRGRRRGBGB", "output": "12" }, { "input": "RGRBGBRBBGBRRGGGBBGBRRBGRGBBBBBGRRRGGRBB\nBGR", "output": "2" }, { "input": "R\nB", "output": "1" }, { "input": "RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR\nRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR", "output": "50" }, { "input": "RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR\nGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG", "output": "1" }, { "input": "R\nGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG", "output": "1" } ]

1,625,081,191

2,147,483,647

Python 3

OK

TESTS

19

122

0

s=input() t=input() count=0 i=0 x=s[0] while i<len(t): if x==t[i]: count+=1 x=s[count] i+=1 print(count+1)

Title: Colorful Stones (Simplified Edition) Time Limit: None seconds Memory Limit: None megabytes Problem Description: There is a sequence of colorful stones. The color of each stone is one of red, green, or blue. You are given a string *s*. The *i*-th (1-based) character of *s* represents the color of the *i*-th stone. If the character is "R", "G", or "B", the color of the corresponding stone is red, green, or blue, respectively. Initially Squirrel Liss is standing on the first stone. You perform instructions one or more times. Each instruction is one of the three types: "RED", "GREEN", or "BLUE". After an instruction *c*, if Liss is standing on a stone whose colors is *c*, Liss will move one stone forward, else she will not move. You are given a string *t*. The number of instructions is equal to the length of *t*, and the *i*-th character of *t* represents the *i*-th instruction. Calculate the final position of Liss (the number of the stone she is going to stand on in the end) after performing all the instructions, and print its 1-based position. It is guaranteed that Liss don't move out of the sequence. Input Specification: The input contains two lines. The first line contains the string *s* (1<=≤<=|*s*|<=≤<=50). The second line contains the string *t* (1<=≤<=|*t*|<=≤<=50). The characters of each string will be one of "R", "G", or "B". It is guaranteed that Liss don't move out of the sequence. Output Specification: Print the final 1-based position of Liss in a single line. Demo Input: ['RGB\nRRR\n', 'RRRBGBRBBB\nBBBRR\n', 'BRRBGBRGRBGRGRRGGBGBGBRGBRGRGGGRBRRRBRBBBGRRRGGBBB\nBBRBGGRGRGBBBRBGRBRBBBBRBRRRBGBBGBBRRBBGGRBRRBRGRB\n'] Demo Output: ['2\n', '3\n', '15\n'] Note: none

```python s=input() t=input() count=0 i=0 x=s[0] while i<len(t): if x==t[i]: count+=1 x=s[count] i+=1 print(count+1) ```

3

234

G

Practice

PROGRAMMING

1,600

[ "constructive algorithms", "divide and conquer", "implementation" ]

null

Little time is left before Berland annual football championship. Therefore the coach of team "Losewille Rangers" decided to resume the practice, that were indefinitely interrupted for uncertain reasons. Overall there are *n* players in "Losewille Rangers". Each player on the team has a number — a unique integer from 1 to *n*. To prepare for the championship, the coach Mr. Floppe decided to spend some number of practices. Mr. Floppe spent some long nights of his holiday planning how to conduct the practices. He came to a very complex practice system. Each practice consists of one game, all *n* players of the team take part in the game. The players are sorted into two teams in some way. In this case, the teams may have different numbers of players, but each team must have at least one player. The coach wants to be sure that after the series of the practice sessions each pair of players had at least one practice, when they played in different teams. As the players' energy is limited, the coach wants to achieve the goal in the least number of practices. Help him to schedule the practices.

A single input line contains integer *n* (2<=≤<=*n*<=≤<=1000).

In the first line print *m* — the minimum number of practices the coach will have to schedule. Then print the descriptions of the practices in *m* lines. In the *i*-th of those lines print *f**i* — the number of players in the first team during the *i*-th practice (1<=≤<=*f**i*<=<<=*n*), and *f**i* numbers from 1 to *n* — the numbers of players in the first team. The rest of the players will play in the second team during this practice. Separate numbers on a line with spaces. Print the numbers of the players in any order. If there are multiple optimal solutions, print any of them.

[ "2\n", "3\n" ]

[ "1\n1 1\n", "2\n2 1 2\n1 1\n" ]

none

0

[ { "input": "2", "output": "1\n1 1" }, { "input": "3", "output": "2\n2 1 2\n1 1" }, { "input": "4", "output": "2\n2 1 2\n2 1 3" }, { "input": "5", "output": "3\n3 1 2 3\n3 1 2 4\n1 1" }, { "input": "6", "output": "3\n3 1 2 3\n4 1 2 4 5\n2 1 4" }, { "input": "7", "output": "3\n4 1 2 3 4\n4 1 2 5 6\n3 1 3 5" }, { "input": "8", "output": "3\n4 1 2 3 4\n4 1 2 5 6\n4 1 3 5 7" }, { "input": "9", "output": "4\n5 1 2 3 4 5\n5 1 2 3 6 7\n5 1 2 4 6 8\n1 1" }, { "input": "10", "output": "4\n5 1 2 3 4 5\n6 1 2 3 6 7 8\n6 1 2 4 6 7 9\n2 1 6" }, { "input": "11", "output": "4\n6 1 2 3 4 5 6\n6 1 2 3 7 8 9\n7 1 2 4 5 7 8 10\n3 1 4 7" }, { "input": "13", "output": "4\n7 1 2 3 4 5 6 7\n7 1 2 3 4 8 9 10\n8 1 2 5 6 8 9 11 12\n5 1 3 5 8 11" }, { "input": "15", "output": "4\n8 1 2 3 4 5 6 7 8\n8 1 2 3 4 9 10 11 12\n8 1 2 5 6 9 10 13 14\n7 1 3 5 7 9 11 13" }, { "input": "16", "output": "4\n8 1 2 3 4 5 6 7 8\n8 1 2 3 4 9 10 11 12\n8 1 2 5 6 9 10 13 14\n8 1 3 5 7 9 11 13 15" }, { "input": "18", "output": "5\n9 1 2 3 4 5 6 7 8 9\n10 1 2 3 4 5 10 11 12 13 14\n10 1 2 3 6 7 10 11 12 15 16\n10 1 2 4 6 8 10 11 13 15 17\n2 1 10" }, { "input": "20", "output": "5\n10 1 2 3 4 5 6 7 8 9 10\n10 1 2 3 4 5 11 12 13 14 15\n12 1 2 3 6 7 8 11 12 13 16 17 18\n12 1 2 4 6 7 9 11 12 14 16 17 19\n4 1 6 11 16" }, { "input": "100", "output": "7\n50 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50\n50 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75\n52 1 2 3 4 5 6 7 8 9 10 11 12 13 26 27 28 29 30 31 32 33 34 35 36 37 38 51 52 53 54 55 56 57 58 59 60 61 62 63 76 77 78 79 80 81 82 83 84 85 86 87 88\n52 1 2 3 4 5 6 7 14 15 16 17 18 19 26 27 28 29 30 31 32 39 40 41 42..." }, { "input": "110", "output": "7\n55 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55\n56 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83\n56 1 2 3 4 5 6 7 8 9 10 11 12 13 14 29 30 31 32 33 34 35 36 37 38 39 40 41 42 56 57 58 59 60 61 62 63 64 65 66 67 68 69 84 85 86 87 88 89 90 91 92 93 94 95 96 97\n56 1 2 3 4 5 6 7 15 16..." }, { "input": "120", "output": "7\n60 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60\n60 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90\n60 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 91 92 93 94 95 96 97 98 99 10..." }, { "input": "140", "output": "8\n70 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70\n70 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105\n72 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50..." }, { "input": "157", "output": "8\n79 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79\n79 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118\n80 1 2 3 4 5 6 7 8 9 10 1..." }, { "input": "171", "output": "8\n86 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86\n86 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 1..." }, { "input": "199", "output": "8\n100 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100\n100 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 11..." }, { "input": "200", "output": "8\n100 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100\n100 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 11..." }, { "input": "213", "output": "8\n107 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107\n107 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 108 109 110 111 112 113 11..." }, { "input": "231", "output": "8\n116 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116\n116 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51..." }, { "input": "240", "output": "8\n120 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120\n120 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 4..." }, { "input": "250", "output": "8\n125 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125\n126 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39..." }, { "input": "253", "output": "8\n127 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127\n127 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 ..." }, { "input": "260", "output": "9\n130 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130\n130 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 ..." }, { "input": "270", "output": "9\n135 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135\n136 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 2..." }, { "input": "271", "output": "9\n136 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136\n136 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 ..." }, { "input": "277", "output": "9\n139 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139\n139 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ..." }, { "input": "280", "output": "9\n140 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140\n140 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19..." }, { "input": "290", "output": "9\n145 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145\n146 1 2 3 4 5 6 7 8 9 10 11 12 ..." }, { "input": "300", "output": "9\n150 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150\n150 1 2 3 4..." }, { "input": "700", "output": "10\n350 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "730", "output": "10\n365 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "766", "output": "10\n383 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "777", "output": "10\n389 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "800", "output": "10\n400 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "832", "output": "10\n416 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "855", "output": "10\n428 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "869", "output": "10\n435 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "888", "output": "10\n444 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "900", "output": "10\n450 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "914", "output": "10\n457 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "930", "output": "10\n465 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "950", "output": "10\n475 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "990", "output": "10\n495 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." }, { "input": "1000", "output": "10\n500 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153..." } ]

1,623,760,413

2,147,483,647

PyPy 3

OK

TESTS

50

248

3,276,800

from math import * f1=open('input.txt','r') n=int(f1.readline()) f1.close() a=[[] for i in range(int(log(n,2))+1)] def f(l,r,d=0): global a if l!=r: m=(l+r)//2 a[d]+=list(range(l,m+1)) f(l,m,d+1) f(m+1,r,d+1) f(1,n) b=0 for i in range(len(a)): if a[i]: a[i]=[len(a[i])]+a[i] b+=1 f2=open('output.txt','w') print(b,file=f2) for i in range(b): print(*a[i],file=f2) f2.close()

Title: Practice Time Limit: None seconds Memory Limit: None megabytes Problem Description: Little time is left before Berland annual football championship. Therefore the coach of team "Losewille Rangers" decided to resume the practice, that were indefinitely interrupted for uncertain reasons. Overall there are *n* players in "Losewille Rangers". Each player on the team has a number — a unique integer from 1 to *n*. To prepare for the championship, the coach Mr. Floppe decided to spend some number of practices. Mr. Floppe spent some long nights of his holiday planning how to conduct the practices. He came to a very complex practice system. Each practice consists of one game, all *n* players of the team take part in the game. The players are sorted into two teams in some way. In this case, the teams may have different numbers of players, but each team must have at least one player. The coach wants to be sure that after the series of the practice sessions each pair of players had at least one practice, when they played in different teams. As the players' energy is limited, the coach wants to achieve the goal in the least number of practices. Help him to schedule the practices. Input Specification: A single input line contains integer *n* (2<=≤<=*n*<=≤<=1000). Output Specification: In the first line print *m* — the minimum number of practices the coach will have to schedule. Then print the descriptions of the practices in *m* lines. In the *i*-th of those lines print *f**i* — the number of players in the first team during the *i*-th practice (1<=≤<=*f**i*<=<<=*n*), and *f**i* numbers from 1 to *n* — the numbers of players in the first team. The rest of the players will play in the second team during this practice. Separate numbers on a line with spaces. Print the numbers of the players in any order. If there are multiple optimal solutions, print any of them. Demo Input: ['2\n', '3\n'] Demo Output: ['1\n1 1\n', '2\n2 1 2\n1 1\n'] Note: none

```python from math import * f1=open('input.txt','r') n=int(f1.readline()) f1.close() a=[[] for i in range(int(log(n,2))+1)] def f(l,r,d=0): global a if l!=r: m=(l+r)//2 a[d]+=list(range(l,m+1)) f(l,m,d+1) f(m+1,r,d+1) f(1,n) b=0 for i in range(len(a)): if a[i]: a[i]=[len(a[i])]+a[i] b+=1 f2=open('output.txt','w') print(b,file=f2) for i in range(b): print(*a[i],file=f2) f2.close() ```

3

225

B

Well-known Numbers

PROGRAMMING

1,600

[ "binary search", "greedy", "number theory" ]

null

Numbers *k*-bonacci (*k* is integer, *k*<=><=1) are a generalization of Fibonacci numbers and are determined as follows: - *F*(*k*,<=*n*)<==<=0, for integer *n*, 1<=≤<=*n*<=<<=*k*; - *F*(*k*,<=*k*)<==<=1; - *F*(*k*,<=*n*)<==<=*F*(*k*,<=*n*<=-<=1)<=+<=*F*(*k*,<=*n*<=-<=2)<=+<=...<=+<=*F*(*k*,<=*n*<=-<=*k*), for integer *n*, *n*<=><=*k*. Note that we determine the *k*-bonacci numbers, *F*(*k*,<=*n*), only for integer values of *n* and *k*. You've got a number *s*, represent it as a sum of several (at least two) distinct *k*-bonacci numbers.

The first line contains two integers *s* and *k* (1<=≤<=*s*,<=*k*<=≤<=109; *k*<=><=1).

In the first line print an integer *m* (*m*<=≥<=2) that shows how many numbers are in the found representation. In the second line print *m* distinct integers *a*1,<=*a*2,<=...,<=*a**m*. Each printed integer should be a *k*-bonacci number. The sum of printed integers must equal *s*. It is guaranteed that the answer exists. If there are several possible answers, print any of them.

[ "5 2\n", "21 5\n" ]

[ "3\n0 2 3\n", "3\n4 1 16\n" ]

none

1,000

[ { "input": "5 2", "output": "3\n0 2 3" }, { "input": "21 5", "output": "3\n4 1 16" }, { "input": "1 1000", "output": "2\n1 0 " }, { "input": "1000000000 1000000000", "output": "14\n536870912 268435456 134217728 33554432 16777216 8388608 1048576 524288 131072 32768 16384 2048 512 0 " }, { "input": "122 7", "output": "6\n64 32 16 8 2 0 " }, { "input": "4 3", "output": "2\n4 0 " }, { "input": "321123 3211232", "output": "11\n262144 32768 16384 8192 1024 512 64 32 2 1 0 " }, { "input": "1 2", "output": "2\n1 0 " }, { "input": "2 2", "output": "2\n2 0 " }, { "input": "3 2", "output": "2\n3 0 " }, { "input": "8 2", "output": "2\n8 0 " }, { "input": "17 2", "output": "4\n13 3 1 0 " }, { "input": "137 2", "output": "5\n89 34 13 1 0 " }, { "input": "7298 2", "output": "7\n6765 377 144 8 3 1 0 " }, { "input": "76754 2", "output": "7\n75025 1597 89 34 8 1 0 " }, { "input": "12345678 2", "output": "8\n9227465 2178309 832040 75025 28657 4181 1 0 " }, { "input": "987654321 2", "output": "16\n701408733 267914296 14930352 2178309 832040 317811 46368 17711 6765 1597 233 89 13 3 1 0 " }, { "input": "1000000000 2", "output": "15\n701408733 267914296 24157817 5702887 514229 196418 75025 28657 1597 233 89 13 5 1 0 " }, { "input": "701408733 2", "output": "2\n701408733 0 " }, { "input": "1 3", "output": "2\n1 0 " }, { "input": "2 3", "output": "2\n2 0 " }, { "input": "3 3", "output": "3\n2 1 0 " }, { "input": "100 3", "output": "5\n81 13 4 2 0 " }, { "input": "87783 3", "output": "8\n66012 19513 1705 504 44 4 1 0 " }, { "input": "615693473 3", "output": "23\n334745777 181997601 53798080 29249425 8646064 4700770 1389537 755476 223317 121415 35890 19513 5768 3136 927 504 149 81 24 13 4 2 0 " }, { "input": "615693474 3", "output": "2\n615693474 0 " }, { "input": "1000000000 3", "output": "15\n615693474 334745777 29249425 15902591 2555757 1389537 410744 35890 10609 5768 274 149 4 1 0 " }, { "input": "1 4", "output": "2\n1 0 " }, { "input": "2 4", "output": "2\n2 0 " }, { "input": "17 4", "output": "3\n15 2 0 " }, { "input": "234 4", "output": "6\n208 15 8 2 1 0 " }, { "input": "23435345 4", "output": "13\n14564533 7555935 1055026 147312 76424 20569 10671 2872 1490 401 108 4 0 " }, { "input": "989464701 4", "output": "18\n747044834 201061985 28074040 7555935 3919944 1055026 547337 147312 39648 10671 5536 1490 773 108 56 4 2 0 " }, { "input": "464 5", "output": "2\n464 0 " }, { "input": "7647474 5", "output": "8\n5976577 1546352 103519 13624 6930 464 8 0 " }, { "input": "457787655 5", "output": "14\n345052351 89277256 23099186 203513 103519 26784 13624 6930 3525 912 31 16 8 0 " }, { "input": "764747 6", "output": "13\n463968 233904 59448 3840 1936 976 492 125 32 16 8 2 0 " }, { "input": "980765665 7", "output": "16\n971364608 7805695 987568 495776 62725 31489 15808 1004 504 253 127 64 32 8 4 0 " }, { "input": "877655444 8", "output": "17\n512966536 256993248 64504063 32316160 8111200 2035872 510994 128257 64256 16128 8080 509 128 8 4 1 0 " }, { "input": "567886500 9", "output": "11\n525375999 32965728 8257696 1035269 129792 64960 32512 16272 8144 128 0 " }, { "input": "656777660 10", "output": "13\n531372800 66519472 33276064 16646200 8327186 521472 65280 32656 16336 128 64 2 0 " }, { "input": "197445609 11", "output": "18\n133628064 33423378 16715781 8359937 4180992 1045760 65424 16364 8184 1024 512 128 32 16 8 4 1 0 " }, { "input": "647474474 12", "output": "18\n535625888 66977797 33492993 8375296 2094336 523712 261888 65488 32748 16376 4095 2048 1024 512 256 16 1 0 " }, { "input": "856644446 14", "output": "16\n536592385 268304384 33541120 16771072 1048320 262096 65528 32765 16383 8192 2048 128 16 8 1 0 " }, { "input": "980345678 19", "output": "18\n536864768 268432640 134216448 33554176 4194284 2097144 524287 262144 131072 65536 2048 1024 64 32 8 2 1 0 " }, { "input": "561854567 23", "output": "17\n536870656 16777213 4194304 2097152 1048576 524288 262144 65536 8192 4096 2048 256 64 32 8 2 0 " }, { "input": "987654321 27", "output": "20\n536870904 268435453 134217727 33554432 8388608 4194304 1048576 524288 262144 131072 16384 8192 2048 128 32 16 8 4 1 0 " }, { "input": "780787655 29", "output": "18\n536870911 134217728 67108864 33554432 8388608 524288 65536 32768 16384 4096 2048 1024 512 256 128 64 8 0 " }, { "input": "999999999 30", "output": "22\n536870912 268435456 134217728 33554432 16777216 8388608 1048576 524288 131072 32768 16384 2048 256 128 64 32 16 8 4 2 1 0 " }, { "input": "1 50", "output": "2\n1 0 " }, { "input": "5 54", "output": "3\n4 1 0 " }, { "input": "378 83", "output": "7\n256 64 32 16 8 2 0 " }, { "input": "283847 111", "output": "10\n262144 16384 4096 1024 128 64 4 2 1 0 " }, { "input": "38746466 2847", "output": "14\n33554432 4194304 524288 262144 131072 65536 8192 4096 2048 256 64 32 2 0 " }, { "input": "83768466 12345", "output": "15\n67108864 8388608 4194304 2097152 1048576 524288 262144 131072 8192 4096 1024 128 16 2 0 " }, { "input": "987654321 7475657", "output": "18\n536870912 268435456 134217728 33554432 8388608 4194304 1048576 524288 262144 131072 16384 8192 2048 128 32 16 1 0 " }, { "input": "10 174764570", "output": "3\n8 2 0 " }, { "input": "967755664 974301345", "output": "17\n536870912 268435456 134217728 16777216 8388608 2097152 524288 262144 131072 32768 16384 1024 512 256 128 16 0 " }, { "input": "76 758866446", "output": "4\n64 8 4 0 " }, { "input": "1 1000000000", "output": "2\n1 0 " }, { "input": "469766205 719342208", "output": "10\n268435456 134217728 67108864 4096 32 16 8 4 1 0 " }, { "input": "918938066 77", "output": "17\n536870912 268435456 67108864 33554432 8388608 4194304 262144 65536 32768 16384 8192 256 128 64 16 2 0 " }, { "input": "856089381 19", "output": "15\n536864768 268432640 33554176 16777104 262144 131072 65536 1024 512 256 128 16 4 1 0 " }, { "input": "152235195 16", "output": "16\n134204416 16775936 1048528 131069 65535 8192 1024 256 128 64 32 8 4 2 1 0 " }, { "input": "429960894 3101", "output": "17\n268435456 134217728 16777216 8388608 2097152 32768 8192 2048 1024 512 128 32 16 8 4 2 0 " }, { "input": "450695564 7", "output": "18\n244804400 122895984 61695880 15548665 3918592 987568 495776 248888 62725 31489 3984 1004 504 64 32 8 1 0 " }, { "input": "154517270 24", "output": "18\n134217708 16777215 2097152 1048576 262144 65536 32768 8192 4096 2048 1024 512 256 32 8 2 1 0 " }, { "input": "300919980 24", "output": "20\n268435408 16777215 8388608 4194304 2097152 524288 262144 131072 65536 32768 8192 2048 1024 128 64 16 8 4 1 0 " }, { "input": "900077555 2", "output": "16\n701408733 165580141 24157817 5702887 2178309 832040 196418 17711 2584 610 233 55 13 3 1 0 " }, { "input": "172285923 26", "output": "17\n134217725 33554432 4194304 262144 32768 16384 4096 2048 1024 512 256 128 64 32 4 2 0 " } ]

1,441,297,830

1,349

PyPy 3

OK

TESTS

70

218

0

s,k=list(map(int,input().split(' '))) a=[0,1,1] while a[-1]<s: if len(a)<k: a.append(sum(a)) else: t=0 for i in range(k): t+=a[-i-1] a.append(t) if s==a[-1]: print(2) print(0,a[-1]) else: use=[] for i in range(len(a)): if s>=a[-i-1]: s-=a[-i-1] use.append(a[-i-1]) print(len(use)) for i in use: print(i,end=' ')

Title: Well-known Numbers Time Limit: None seconds Memory Limit: None megabytes Problem Description: Numbers *k*-bonacci (*k* is integer, *k*<=><=1) are a generalization of Fibonacci numbers and are determined as follows: - *F*(*k*,<=*n*)<==<=0, for integer *n*, 1<=≤<=*n*<=<<=*k*; - *F*(*k*,<=*k*)<==<=1; - *F*(*k*,<=*n*)<==<=*F*(*k*,<=*n*<=-<=1)<=+<=*F*(*k*,<=*n*<=-<=2)<=+<=...<=+<=*F*(*k*,<=*n*<=-<=*k*), for integer *n*, *n*<=><=*k*. Note that we determine the *k*-bonacci numbers, *F*(*k*,<=*n*), only for integer values of *n* and *k*. You've got a number *s*, represent it as a sum of several (at least two) distinct *k*-bonacci numbers. Input Specification: The first line contains two integers *s* and *k* (1<=≤<=*s*,<=*k*<=≤<=109; *k*<=><=1). Output Specification: In the first line print an integer *m* (*m*<=≥<=2) that shows how many numbers are in the found representation. In the second line print *m* distinct integers *a*1,<=*a*2,<=...,<=*a**m*. Each printed integer should be a *k*-bonacci number. The sum of printed integers must equal *s*. It is guaranteed that the answer exists. If there are several possible answers, print any of them. Demo Input: ['5 2\n', '21 5\n'] Demo Output: ['3\n0 2 3\n', '3\n4 1 16\n'] Note: none

```python s,k=list(map(int,input().split(' '))) a=[0,1,1] while a[-1]<s: if len(a)<k: a.append(sum(a)) else: t=0 for i in range(k): t+=a[-i-1] a.append(t) if s==a[-1]: print(2) print(0,a[-1]) else: use=[] for i in range(len(a)): if s>=a[-i-1]: s-=a[-i-1] use.append(a[-i-1]) print(len(use)) for i in use: print(i,end=' ') ```

3

50

A

Domino piling

PROGRAMMING

800

[ "greedy", "math" ]

A. Domino piling

2

256

You are given a rectangular board of *M*<=×<=*N* squares. Also you are given an unlimited number of standard domino pieces of 2<=×<=1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as possible on the board so as to meet the following conditions: 1. Each domino completely covers two squares. 2. No two dominoes overlap. 3. Each domino lies entirely inside the board. It is allowed to touch the edges of the board. Find the maximum number of dominoes, which can be placed under these restrictions.

In a single line you are given two integers *M* and *N* — board sizes in squares (1<=≤<=*M*<=≤<=*N*<=≤<=16).

Output one number — the maximal number of dominoes, which can be placed.

[ "2 4\n", "3 3\n" ]

[ "4\n", "4\n" ]

none

500

[ { "input": "2 4", "output": "4" }, { "input": "3 3", "output": "4" }, { "input": "1 5", "output": "2" }, { "input": "1 6", "output": "3" }, { "input": "1 15", "output": "7" }, { "input": "1 16", "output": "8" }, { "input": "2 5", "output": "5" }, { "input": "2 6", "output": "6" }, { "input": "2 7", "output": "7" }, { "input": "2 14", "output": "14" }, { "input": "2 15", "output": "15" }, { "input": "1 4", "output": "2" }, { "input": "2 16", "output": "16" }, { "input": "3 5", "output": "7" }, { "input": "3 6", "output": "9" }, { "input": "3 10", "output": "15" }, { "input": "3 14", "output": "21" }, { "input": "3 15", "output": "22" }, { "input": "3 16", "output": "24" }, { "input": "5 7", "output": "17" }, { "input": "16 16", "output": "128" }, { "input": "15 16", "output": "120" }, { "input": "2 3", "output": "3" }, { "input": "15 15", "output": "112" }, { "input": "14 16", "output": "112" }, { "input": "11 13", "output": "71" }, { "input": "5 16", "output": "40" }, { "input": "8 15", "output": "60" }, { "input": "2 2", "output": "2" }, { "input": "3 4", "output": "6" }, { "input": "4 4", "output": "8" }, { "input": "1 1", "output": "0" }, { "input": "1 2", "output": "1" }, { "input": "1 3", "output": "1" }, { "input": "14 15", "output": "105" } ]

1,610,219,109

2,147,483,647

Python 3

OK

TESTS

35

124

0

m, n = input().split() board = int(m) * int(n) print(int(board / 2))

Title: Domino piling Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: You are given a rectangular board of *M*<=×<=*N* squares. Also you are given an unlimited number of standard domino pieces of 2<=×<=1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as possible on the board so as to meet the following conditions: 1. Each domino completely covers two squares. 2. No two dominoes overlap. 3. Each domino lies entirely inside the board. It is allowed to touch the edges of the board. Find the maximum number of dominoes, which can be placed under these restrictions. Input Specification: In a single line you are given two integers *M* and *N* — board sizes in squares (1<=≤<=*M*<=≤<=*N*<=≤<=16). Output Specification: Output one number — the maximal number of dominoes, which can be placed. Demo Input: ['2 4\n', '3 3\n'] Demo Output: ['4\n', '4\n'] Note: none

```python m, n = input().split() board = int(m) * int(n) print(int(board / 2)) ```

3.969

0

none

0

[ "none" ]

null

The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness". The test consists of *n* questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question *n*. Question *i* contains *a**i* answer variants, exactly one of them is correct. A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the *n* questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves. Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case?

The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100). It is the number of questions in the test. The second line contains space-separated *n* positive integers *a**i* (1<=≤<=*a**i*<=≤<=109), the number of answer variants to question *i*.

Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario. Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.

[ "2\n1 1\n", "2\n2 2\n", "1\n10\n" ]

[ "2", "5", "10" ]

Note to the second sample. In the worst-case scenario you will need five clicks: - the first click selects the first variant to the first question, this answer turns out to be wrong. - the second click selects the second variant to the first question, it proves correct and we move on to the second question; - the third click selects the first variant to the second question, it is wrong and we go back to question 1; - the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question; - the fifth click selects the second variant to the second question, it proves correct, the test is finished.

0

[ { "input": "2\n1 1", "output": "2" }, { "input": "2\n2 2", "output": "5" }, { "input": "1\n10", "output": "10" }, { "input": "3\n2 4 1", "output": "10" }, { "input": "4\n5 5 3 1", "output": "22" }, { "input": "2\n1000000000 1000000000", "output": "2999999999" }, { "input": "10\n5 7 8 1 10 3 6 4 10 6", "output": "294" }, { "input": "100\n5 7 5 3 5 4 6 5 3 6 4 6 6 2 1 9 6 5 3 8 4 10 1 9 1 3 7 6 5 5 8 8 7 7 8 9 2 10 3 5 4 2 6 10 2 6 9 6 1 9 3 7 7 8 3 9 9 5 10 10 3 10 7 8 3 9 8 3 2 4 10 2 1 1 7 3 9 10 4 6 9 8 2 1 4 10 1 10 6 8 7 5 3 3 6 2 7 10 3 8", "output": "24212" }, { "input": "100\n96 23 25 62 34 30 85 15 26 61 59 87 34 99 60 41 52 73 63 84 50 89 42 29 87 99 19 94 84 43 82 90 41 100 60 61 99 49 26 3 97 5 24 34 51 59 69 61 11 41 72 60 33 36 18 29 82 53 18 80 52 98 38 32 56 95 55 79 32 80 37 64 45 13 62 80 70 29 1 58 88 24 79 68 41 80 12 72 52 39 64 19 54 56 70 58 19 3 83 62", "output": "261115" }, { "input": "100\n883 82 79 535 478 824 700 593 262 385 403 183 176 386 126 648 710 516 922 97 800 728 372 9 954 911 975 526 476 3 74 459 471 174 295 831 698 21 927 698 580 856 712 430 5 473 592 40 301 230 763 266 38 213 393 70 333 779 811 249 130 456 763 657 578 699 939 660 898 918 438 855 892 85 35 232 54 593 849 777 917 979 796 322 473 887 284 105 522 415 86 480 80 592 516 227 680 574 488 644", "output": "2519223" }, { "input": "100\n6659 5574 5804 7566 7431 1431 3871 6703 200 300 3523 3580 8500 2312 4812 3149 3324 5846 8965 5758 5831 1341 7733 4477 355 3024 2941 9938 1494 16 1038 8262 9938 9230 5192 8113 7575 7696 5566 2884 8659 1951 1253 6480 3877 3707 5482 3825 5359 44 3219 3258 1785 5478 4525 5950 2417 1991 8885 4264 8769 2961 7107 8904 5097 2319 5713 8811 9723 8677 2153 3237 7174 9528 9260 7390 3050 6823 6239 5222 4602 933 7823 4198 8304 244 5845 3189 4490 3216 7877 6323 1938 4597 880 1206 1691 1405 4122 5950", "output": "24496504" }, { "input": "50\n515844718 503470143 928669067 209884122 322869098 241621928 844696197 105586164 552680307 968792756 135928721 842094825 298782438 829020472 791637138 285482545 811025527 428952878 887796419 11883658 546401594 6272027 100292274 308219869 372132044 955814846 644008184 521195760 919389466 215065725 687764134 655750167 181397022 404292682 643251185 776299412 741398345 865144798 369796727 673902099 124966684 35796775 794385099 594562033 550366869 868093561 695094388 580789105 755076935 198783899", "output": "685659563557" }, { "input": "10\n12528238 329065023 620046219 303914458 356423530 751571368 72944261 883971060 123105651 868129460", "output": "27409624352" }, { "input": "1\n84355694", "output": "84355694" }, { "input": "2\n885992042 510468669", "output": "1906929379" }, { "input": "100\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "100" }, { "input": "100\n2 1 2 2 2 2 1 2 2 1 2 2 2 1 2 1 2 2 1 2 2 2 2 2 2 1 2 1 1 2 1 1 2 1 2 1 1 1 2 2 2 2 2 1 2 2 2 2 1 1 1 1 1 2 2 1 1 1 2 2 1 1 2 1 1 2 2 2 2 1 2 2 2 1 2 1 2 2 1 2 1 1 1 2 2 1 2 1 2 1 1 1 2 1 2 2 2 1 1 1", "output": "2686" }, { "input": "100\n1 3 2 1 1 2 1 3 2 2 3 1 1 1 2 2 1 3 3 1 1 2 2 3 2 1 3 1 3 2 1 1 3 3 2 1 2 2 2 3 2 2 3 2 2 3 2 1 3 1 1 2 1 3 2 2 1 1 1 1 1 1 3 1 2 3 1 1 1 1 1 2 3 3 1 1 1 1 2 3 3 1 3 2 2 3 2 1 3 2 2 3 1 1 3 2 3 2 3 1", "output": "4667" } ]

1,430,381,132

2,147,483,647

Python 3

OK

TESTS

25

124

4,710,400

n=int(input()) p=input().split() l=[] i=0 while i<n: l.append(int(p[i])) i=i+1 s=l[0] for i in range(1,n): s=s+l[i]+i*(l[i]-1) print(s)

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness". The test consists of *n* questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question *n*. Question *i* contains *a**i* answer variants, exactly one of them is correct. A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the *n* questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves. Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case? Input Specification: The first line contains a positive integer *n* (1<=≤<=*n*<=≤<=100). It is the number of questions in the test. The second line contains space-separated *n* positive integers *a**i* (1<=≤<=*a**i*<=≤<=109), the number of answer variants to question *i*. Output Specification: Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario. Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator. Demo Input: ['2\n1 1\n', '2\n2 2\n', '1\n10\n'] Demo Output: ['2', '5', '10'] Note: Note to the second sample. In the worst-case scenario you will need five clicks: - the first click selects the first variant to the first question, this answer turns out to be wrong. - the second click selects the second variant to the first question, it proves correct and we move on to the second question; - the third click selects the first variant to the second question, it is wrong and we go back to question 1; - the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question; - the fifth click selects the second variant to the second question, it proves correct, the test is finished.

```python n=int(input()) p=input().split() l=[] i=0 while i<n: l.append(int(p[i])) i=i+1 s=l[0] for i in range(1,n): s=s+l[i]+i*(l[i]-1) print(s) ```

3

895

C

Square Subsets

PROGRAMMING

2,000

[ "bitmasks", "combinatorics", "dp", "math" ]

null

Petya was late for the lesson too. The teacher gave him an additional task. For some array *a* Petya should find the number of different ways to select non-empty subset of elements from it in such a way that their product is equal to a square of some integer. Two ways are considered different if sets of indexes of elements chosen by these ways are different. Since the answer can be very large, you should find the answer modulo 109<=+<=7.

First line contains one integer *n* (1<=≤<=*n*<=≤<=105) — the number of elements in the array. Second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=70) — the elements of the array.

Print one integer — the number of different ways to choose some elements so that their product is a square of a certain integer modulo 109<=+<=7.

[ "4\n1 1 1 1\n", "4\n2 2 2 2\n", "5\n1 2 4 5 8\n" ]

[ "15\n", "7\n", "7\n" ]

In first sample product of elements chosen by any way is 1 and 1 = 12. So the answer is 24 - 1 = 15. In second sample there are six different ways to choose elements so that their product is 4, and only one way so that their product is 16. So the answer is 6 + 1 = 7.

1,750

[ { "input": "4\n1 1 1 1", "output": "15" }, { "input": "4\n2 2 2 2", "output": "7" }, { "input": "5\n1 2 4 5 8", "output": "7" }, { "input": "1\n64", "output": "1" }, { "input": "5\n2 2 2 2 2", "output": "15" }, { "input": "6\n1 2 3 4 5 6", "output": "7" }, { "input": "2\n70 70", "output": "1" }, { "input": "7\n4 9 16 25 36 49 64", "output": "127" }, { "input": "13\n64 65 40 26 36 46 53 31 63 11 2 46 59", "output": "15" }, { "input": "15\n66 34 43 45 61 14 12 67 38 25 55 9 30 41 16", "output": "15" }, { "input": "17\n44 57 54 57 54 65 40 57 59 16 39 51 32 51 20 9 8", "output": "511" }, { "input": "18\n22 41 40 8 36 48 23 5 58 12 26 44 53 49 3 56 58 57", "output": "127" }, { "input": "20\n20 34 51 40 70 64 14 30 24 20 6 1 70 28 38 43 9 60 31 69", "output": "2047" }, { "input": "5\n19 51 55 29 13", "output": "0" }, { "input": "6\n19 60 48 64 56 27", "output": "3" }, { "input": "7\n67 52 58 62 38 26 2", "output": "1" }, { "input": "7\n5 28 46 57 39 26 45", "output": "1" }, { "input": "7\n53 59 56 9 13 1 28", "output": "3" }, { "input": "10\n38 58 51 41 61 12 17 47 18 24", "output": "3" }, { "input": "10\n27 44 40 3 33 38 56 37 43 36", "output": "7" }, { "input": "10\n51 4 25 46 15 21 32 9 43 8", "output": "15" }, { "input": "10\n5 66 19 60 34 27 15 27 42 51", "output": "7" }, { "input": "5\n2 3 5 7 11", "output": "0" }, { "input": "10\n2 3 5 7 11 13 17 19 23 29", "output": "0" }, { "input": "2\n15 45", "output": "0" } ]

1,584,599,974

2,147,483,647

PyPy 3

TIME_LIMIT_EXCEEDED

TESTS

12

4,000

41,472,000

from sys import stdin def find_prime(max_value): assert max_value >= 2 result = [2] for i in range(3, max_value): state = 1 for item in result: if item * item > i: break elif i % item == 0: state = -1 break if state == 1: result.append(i) return result module = int(10e9) + 7 n = int(stdin.readline()) A = list(map(int, stdin.readline().split())) number = [0 for i in range(70)] for item in A: number[item - 1] += 1 prime_list = find_prime(70) prime_map = {} for i in range(2, 70 + 1): result = 0 for item in prime_list: cur = i num = 0 while cur % item == 0: num += 1 cur = int(cur / item) result = result * 2 + num % 2 prime_map[i] = result number_dic = {0: 1} for i in range(2, 70 + 1): mask = prime_map[i] for j in range(number[i - 1]): new_number_dic = number_dic.copy() key_list = list(number_dic.keys()) for key in key_list: new_key = key ^ mask value = new_number_dic[key] if new_key in number_dic: number_dic[new_key] += value else: number_dic[new_key] = value number_dic[new_key] %= module if number[0] == 0: print(number_dic[0] - 1) else: result = 1 for j in range(number[0]): result *= 2 result %= module result = (result * number_dic[0] - 1) % module print(result)

Title: Square Subsets Time Limit: None seconds Memory Limit: None megabytes Problem Description: Petya was late for the lesson too. The teacher gave him an additional task. For some array *a* Petya should find the number of different ways to select non-empty subset of elements from it in such a way that their product is equal to a square of some integer. Two ways are considered different if sets of indexes of elements chosen by these ways are different. Since the answer can be very large, you should find the answer modulo 109<=+<=7. Input Specification: First line contains one integer *n* (1<=≤<=*n*<=≤<=105) — the number of elements in the array. Second line contains *n* integers *a**i* (1<=≤<=*a**i*<=≤<=70) — the elements of the array. Output Specification: Print one integer — the number of different ways to choose some elements so that their product is a square of a certain integer modulo 109<=+<=7. Demo Input: ['4\n1 1 1 1\n', '4\n2 2 2 2\n', '5\n1 2 4 5 8\n'] Demo Output: ['15\n', '7\n', '7\n'] Note: In first sample product of elements chosen by any way is 1 and 1 = 12. So the answer is 24 - 1 = 15. In second sample there are six different ways to choose elements so that their product is 4, and only one way so that their product is 16. So the answer is 6 + 1 = 7.

```python from sys import stdin def find_prime(max_value): assert max_value >= 2 result = [2] for i in range(3, max_value): state = 1 for item in result: if item * item > i: break elif i % item == 0: state = -1 break if state == 1: result.append(i) return result module = int(10e9) + 7 n = int(stdin.readline()) A = list(map(int, stdin.readline().split())) number = [0 for i in range(70)] for item in A: number[item - 1] += 1 prime_list = find_prime(70) prime_map = {} for i in range(2, 70 + 1): result = 0 for item in prime_list: cur = i num = 0 while cur % item == 0: num += 1 cur = int(cur / item) result = result * 2 + num % 2 prime_map[i] = result number_dic = {0: 1} for i in range(2, 70 + 1): mask = prime_map[i] for j in range(number[i - 1]): new_number_dic = number_dic.copy() key_list = list(number_dic.keys()) for key in key_list: new_key = key ^ mask value = new_number_dic[key] if new_key in number_dic: number_dic[new_key] += value else: number_dic[new_key] = value number_dic[new_key] %= module if number[0] == 0: print(number_dic[0] - 1) else: result = 1 for j in range(number[0]): result *= 2 result %= module result = (result * number_dic[0] - 1) % module print(result) ```

0

672

A

Summer Camp

PROGRAMMING

800

[ "implementation" ]

null

Every year, hundreds of people come to summer camps, they learn new algorithms and solve hard problems. This is your first year at summer camp, and you are asked to solve the following problem. All integers starting with 1 are written in one line. The prefix of these line is "123456789101112131415...". Your task is to print the *n*-th digit of this string (digits are numbered starting with 1.

The only line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=1000) — the position of the digit you need to print.

Print the *n*-th digit of the line.

[ "3\n", "11\n" ]

[ "3\n", "0\n" ]

In the first sample the digit at position 3 is '3', as both integers 1 and 2 consist on one digit. In the second sample, the digit at position 11 is '0', it belongs to the integer 10.

500

[ { "input": "3", "output": "3" }, { "input": "11", "output": "0" }, { "input": "12", "output": "1" }, { "input": "13", "output": "1" }, { "input": "29", "output": "9" }, { "input": "30", "output": "2" }, { "input": "1000", "output": "3" }, { "input": "999", "output": "9" }, { "input": "100", "output": "5" }, { "input": "123", "output": "6" }, { "input": "8", "output": "8" }, { "input": "157", "output": "3" }, { "input": "289", "output": "1" }, { "input": "179", "output": "4" }, { "input": "942", "output": "0" }, { "input": "879", "output": "9" }, { "input": "394", "output": "1" }, { "input": "423", "output": "7" }, { "input": "952", "output": "3" }, { "input": "121", "output": "5" }, { "input": "613", "output": "2" }, { "input": "945", "output": "1" }, { "input": "270", "output": "6" }, { "input": "781", "output": "2" }, { "input": "453", "output": "7" }, { "input": "171", "output": "0" }, { "input": "643", "output": "2" }, { "input": "570", "output": "6" }, { "input": "750", "output": "6" }, { "input": "500", "output": "0" }, { "input": "2", "output": "2" }, { "input": "1", "output": "1" }, { "input": "108", "output": "5" }, { "input": "500", "output": "0" }, { "input": "189", "output": "9" }, { "input": "491", "output": "0" }, { "input": "191", "output": "0" } ]

1,582,170,581

2,147,483,647

Python 3

OK

TESTS

37

109

0

full = "" for i in range(1,400): full += str(i) n = int(input()) print(full[n-1])

Title: Summer Camp Time Limit: None seconds Memory Limit: None megabytes Problem Description: Every year, hundreds of people come to summer camps, they learn new algorithms and solve hard problems. This is your first year at summer camp, and you are asked to solve the following problem. All integers starting with 1 are written in one line. The prefix of these line is "123456789101112131415...". Your task is to print the *n*-th digit of this string (digits are numbered starting with 1. Input Specification: The only line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=1000) — the position of the digit you need to print. Output Specification: Print the *n*-th digit of the line. Demo Input: ['3\n', '11\n'] Demo Output: ['3\n', '0\n'] Note: In the first sample the digit at position 3 is '3', as both integers 1 and 2 consist on one digit. In the second sample, the digit at position 11 is '0', it belongs to the integer 10.

```python full = "" for i in range(1,400): full += str(i) n = int(input()) print(full[n-1]) ```

3

735

D

Taxes

PROGRAMMING

1,600

[ "math", "number theory" ]

null

Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to *n* (*n*<=≥<=2) burles and the amount of tax he has to pay is calculated as the maximum divisor of *n* (not equal to *n*, of course). For example, if *n*<==<=6 then Funt has to pay 3 burles, while for *n*<==<=25 he needs to pay 5 and if *n*<==<=2 he pays only 1 burle. As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial *n* in several parts *n*1<=+<=*n*2<=+<=...<=+<=*n**k*<==<=*n* (here *k* is arbitrary, even *k*<==<=1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition *n**i*<=≥<=2 should hold for all *i* from 1 to *k*. Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split *n* in parts.

The first line of the input contains a single integer *n* (2<=≤<=*n*<=≤<=2·109) — the total year income of mr. Funt.

Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.

[ "4\n", "27\n" ]

[ "2\n", "3\n" ]

none

1,750

[ { "input": "4", "output": "2" }, { "input": "27", "output": "3" }, { "input": "3", "output": "1" }, { "input": "5", "output": "1" }, { "input": "10", "output": "2" }, { "input": "2000000000", "output": "2" }, { "input": "26", "output": "2" }, { "input": "7", "output": "1" }, { "input": "2", "output": "1" }, { "input": "11", "output": "1" }, { "input": "1000000007", "output": "1" }, { "input": "1000000009", "output": "1" }, { "input": "1999999999", "output": "3" }, { "input": "1000000011", "output": "2" }, { "input": "101", "output": "1" }, { "input": "103", "output": "1" }, { "input": "1001", "output": "3" }, { "input": "1003", "output": "3" }, { "input": "10001", "output": "3" }, { "input": "10003", "output": "3" }, { "input": "129401294", "output": "2" }, { "input": "234911024", "output": "2" }, { "input": "192483501", "output": "3" }, { "input": "1234567890", "output": "2" }, { "input": "719241201", "output": "3" }, { "input": "9", "output": "2" }, { "input": "33", "output": "2" }, { "input": "25", "output": "2" }, { "input": "15", "output": "2" }, { "input": "147", "output": "3" }, { "input": "60119912", "output": "2" }, { "input": "45", "output": "2" }, { "input": "21", "output": "2" }, { "input": "9975", "output": "2" }, { "input": "17", "output": "1" }, { "input": "99", "output": "2" }, { "input": "49", "output": "2" }, { "input": "243", "output": "2" }, { "input": "43", "output": "1" }, { "input": "39", "output": "2" }, { "input": "6", "output": "2" }, { "input": "8", "output": "2" }, { "input": "12", "output": "2" }, { "input": "13", "output": "1" }, { "input": "14", "output": "2" }, { "input": "16", "output": "2" }, { "input": "18", "output": "2" }, { "input": "19", "output": "1" }, { "input": "20", "output": "2" }, { "input": "22", "output": "2" }, { "input": "23", "output": "1" }, { "input": "24", "output": "2" }, { "input": "962", "output": "2" }, { "input": "29", "output": "1" }, { "input": "55", "output": "2" }, { "input": "125", "output": "3" }, { "input": "1999999929", "output": "2" }, { "input": "493", "output": "2" }, { "input": "10000021", "output": "2" }, { "input": "541", "output": "1" }, { "input": "187", "output": "3" }, { "input": "95", "output": "3" }, { "input": "999991817", "output": "3" }, { "input": "37998938", "output": "2" }, { "input": "1847133842", "output": "2" }, { "input": "1000000005", "output": "3" }, { "input": "19828", "output": "2" }, { "input": "998321704", "output": "2" }, { "input": "370359", "output": "3" }, { "input": "115", "output": "2" }, { "input": "200000015", "output": "3" }, { "input": "479001600", "output": "2" }, { "input": "536870912", "output": "2" }, { "input": "10759922", "output": "2" }, { "input": "1999999927", "output": "1" }, { "input": "123", "output": "3" }, { "input": "200743933", "output": "3" }, { "input": "949575615", "output": "3" }, { "input": "99990001", "output": "1" }, { "input": "715827883", "output": "1" }, { "input": "5592406", "output": "2" }, { "input": "8388609", "output": "3" }, { "input": "1908903481", "output": "3" }, { "input": "1076153021", "output": "3" }, { "input": "344472101", "output": "3" } ]

1,562,399,220

2,147,483,647

Python 3

COMPILATION_ERROR

TESTS

0

a = input() if (a==2) print("1") elif (a%2==0) print("2") else print("3")

Title: Taxes Time Limit: None seconds Memory Limit: None megabytes Problem Description: Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to *n* (*n*<=≥<=2) burles and the amount of tax he has to pay is calculated as the maximum divisor of *n* (not equal to *n*, of course). For example, if *n*<==<=6 then Funt has to pay 3 burles, while for *n*<==<=25 he needs to pay 5 and if *n*<==<=2 he pays only 1 burle. As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial *n* in several parts *n*1<=+<=*n*2<=+<=...<=+<=*n**k*<==<=*n* (here *k* is arbitrary, even *k*<==<=1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition *n**i*<=≥<=2 should hold for all *i* from 1 to *k*. Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split *n* in parts. Input Specification: The first line of the input contains a single integer *n* (2<=≤<=*n*<=≤<=2·109) — the total year income of mr. Funt. Output Specification: Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax. Demo Input: ['4\n', '27\n'] Demo Output: ['2\n', '3\n'] Note: none

```python a = input() if (a==2) print("1") elif (a%2==0) print("2") else print("3") ```

-1

629

C

Famil Door and Brackets

PROGRAMMING

2,000

[ "dp", "strings" ]

null

As Famil Door’s birthday is coming, some of his friends (like Gabi) decided to buy a present for him. His friends are going to buy a string consisted of round brackets since Famil Door loves string of brackets of length *n* more than any other strings! The sequence of round brackets is called valid if and only if: 1. the total number of opening brackets is equal to the total number of closing brackets; 1. for any prefix of the sequence, the number of opening brackets is greater or equal than the number of closing brackets. Gabi bought a string *s* of length *m* (*m*<=≤<=*n*) and want to complete it to obtain a valid sequence of brackets of length *n*. He is going to pick some strings *p* and *q* consisting of round brackets and merge them in a string *p*<=+<=*s*<=+<=*q*, that is add the string *p* at the beginning of the string *s* and string *q* at the end of the string *s*. Now he wonders, how many pairs of strings *p* and *q* exists, such that the string *p*<=+<=*s*<=+<=*q* is a valid sequence of round brackets. As this number may be pretty large, he wants to calculate it modulo 109<=+<=7.

First line contains *n* and *m* (1<=≤<=*m*<=≤<=*n*<=≤<=100<=000,<=*n*<=-<=*m*<=≤<=2000) — the desired length of the string and the length of the string bought by Gabi, respectively. The second line contains string *s* of length *m* consisting of characters '(' and ')' only.

Print the number of pairs of string *p* and *q* such that *p*<=+<=*s*<=+<=*q* is a valid sequence of round brackets modulo 109<=+<=7.

[ "4 1\n(\n", "4 4\n(())\n", "4 3\n(((\n" ]

[ "4\n", "1\n", "0\n" ]

In the first sample there are four different valid pairs: 1. *p* = "(", *q* = "))" 1. *p* = "()", *q* = ")" 1. *p* = "", *q* = "())" 1. *p* = "", *q* = ")()" In the second sample the only way to obtain a desired string is choose empty *p* and *q*. In the third sample there is no way to get a valid sequence of brackets.

1,750

[ { "input": "4 1\n(", "output": "4" }, { "input": "4 4\n(())", "output": "1" }, { "input": "4 3\n(((", "output": "0" }, { "input": "875 50\n)))((())()))((()(())))))())))((((((()))))))()(((((", "output": "0" }, { "input": "1980 464\n))(()()))(((((((((()))))))(()(((()((()))()()())()))()))(()))))))(())((())))()())()((())())()())))(())()(()))(()())()((((()))())()(())))))(()()(()(((((()(()()))(((()))(())))))()())(())))))())()()((())))))))((()(())))))()()(()((()((()()))(()))(())(()))()((((())()()))))))()(())))()(()())()())(((((()))())))())())(()))()(()))())((())((((()(()(())))(((()()))))()()()))))((()())()((())())))())))()(()(()()(((((()((((()))()(())()))))()(()))(()(((((((()((()(())))(((((())", "output": "854368836" }, { "input": "1542 282\n())())()((()(()))()((())()))((())(()))))(()()))(())((()))()((()())())()))((())(((()(())((()()())((((())))((()((((()(()()))))(()(()()(())()((())())())))))()()())))(()((((()))(()(()(()(()))())((()()()()(()(()))())(((()(())()(())()()())))()))())(()))(((())()))((())()(())))))(())))()()", "output": "631927032" }, { "input": "2 2\n)(", "output": "0" }, { "input": "2 2\n))", "output": "0" } ]

1,455,990,456

4,356

Python 3

WRONG_ANSWER

PRETESTS

3

31

0

n,m = map(int,input().split()) s = input() if n % 2 == 0: p = 0 q = 0 p2 = -10000000 for i in range(m): if s[i] == "(": p -= 1 q += 1 else: p += 1 q -= 1 if p > p2: p2 = p num = 0 if p2 > 0: num += p2 q += p2 if q > 0: num += q if m + num > n: print(0) elif m + num == n: print(1) else: print(((n-num-m)//2)*(num+3)) else: print(0)

Title: Famil Door and Brackets Time Limit: None seconds Memory Limit: None megabytes Problem Description: As Famil Door’s birthday is coming, some of his friends (like Gabi) decided to buy a present for him. His friends are going to buy a string consisted of round brackets since Famil Door loves string of brackets of length *n* more than any other strings! The sequence of round brackets is called valid if and only if: 1. the total number of opening brackets is equal to the total number of closing brackets; 1. for any prefix of the sequence, the number of opening brackets is greater or equal than the number of closing brackets. Gabi bought a string *s* of length *m* (*m*<=≤<=*n*) and want to complete it to obtain a valid sequence of brackets of length *n*. He is going to pick some strings *p* and *q* consisting of round brackets and merge them in a string *p*<=+<=*s*<=+<=*q*, that is add the string *p* at the beginning of the string *s* and string *q* at the end of the string *s*. Now he wonders, how many pairs of strings *p* and *q* exists, such that the string *p*<=+<=*s*<=+<=*q* is a valid sequence of round brackets. As this number may be pretty large, he wants to calculate it modulo 109<=+<=7. Input Specification: First line contains *n* and *m* (1<=≤<=*m*<=≤<=*n*<=≤<=100<=000,<=*n*<=-<=*m*<=≤<=2000) — the desired length of the string and the length of the string bought by Gabi, respectively. The second line contains string *s* of length *m* consisting of characters '(' and ')' only. Output Specification: Print the number of pairs of string *p* and *q* such that *p*<=+<=*s*<=+<=*q* is a valid sequence of round brackets modulo 109<=+<=7. Demo Input: ['4 1\n(\n', '4 4\n(())\n', '4 3\n(((\n'] Demo Output: ['4\n', '1\n', '0\n'] Note: In the first sample there are four different valid pairs: 1. *p* = "(", *q* = "))" 1. *p* = "()", *q* = ")" 1. *p* = "", *q* = "())" 1. *p* = "", *q* = ")()" In the second sample the only way to obtain a desired string is choose empty *p* and *q*. In the third sample there is no way to get a valid sequence of brackets.

```python n,m = map(int,input().split()) s = input() if n % 2 == 0: p = 0 q = 0 p2 = -10000000 for i in range(m): if s[i] == "(": p -= 1 q += 1 else: p += 1 q -= 1 if p > p2: p2 = p num = 0 if p2 > 0: num += p2 q += p2 if q > 0: num += q if m + num > n: print(0) elif m + num == n: print(1) else: print(((n-num-m)//2)*(num+3)) else: print(0) ```

0

158

A

Next Round

PROGRAMMING

800

[ "*special", "implementation" ]

null

"Contestant who earns a score equal to or greater than the *k*-th place finisher's score will advance to the next round, as long as the contestant earns a positive score..." — an excerpt from contest rules. A total of *n* participants took part in the contest (*n*<=≥<=*k*), and you already know their scores. Calculate how many participants will advance to the next round.

The first line of the input contains two integers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=50) separated by a single space. The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (0<=≤<=*a**i*<=≤<=100), where *a**i* is the score earned by the participant who got the *i*-th place. The given sequence is non-increasing (that is, for all *i* from 1 to *n*<=-<=1 the following condition is fulfilled: *a**i*<=≥<=*a**i*<=+<=1).

Output the number of participants who advance to the next round.

[ "8 5\n10 9 8 7 7 7 5 5\n", "4 2\n0 0 0 0\n" ]

[ "6\n", "0\n" ]

In the first example the participant on the 5th place earned 7 points. As the participant on the 6th place also earned 7 points, there are 6 advancers. In the second example nobody got a positive score.

500

[ { "input": "8 5\n10 9 8 7 7 7 5 5", "output": "6" }, { "input": "4 2\n0 0 0 0", "output": "0" }, { "input": "5 1\n1 1 1 1 1", "output": "5" }, { "input": "5 5\n1 1 1 1 1", "output": "5" }, { "input": "1 1\n10", "output": "1" }, { "input": "17 14\n16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0", "output": "14" }, { "input": "5 5\n3 2 1 0 0", "output": "3" }, { "input": "8 6\n10 9 8 7 7 7 5 5", "output": "6" }, { "input": "8 7\n10 9 8 7 7 7 5 5", "output": "8" }, { "input": "8 4\n10 9 8 7 7 7 5 5", "output": "6" }, { "input": "8 3\n10 9 8 7 7 7 5 5", "output": "3" }, { "input": "8 1\n10 9 8 7 7 7 5 5", "output": "1" }, { "input": "8 2\n10 9 8 7 7 7 5 5", "output": "2" }, { "input": "1 1\n100", "output": "1" }, { "input": "1 1\n0", "output": "0" }, { "input": "50 25\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "50" }, { "input": "50 25\n2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "25" }, { "input": "50 25\n2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "26" }, { "input": "50 25\n2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "50" }, { "input": "11 5\n100 99 98 97 96 95 94 93 92 91 90", "output": "5" }, { "input": "10 4\n100 81 70 69 64 43 34 29 15 3", "output": "4" }, { "input": "11 6\n87 71 62 52 46 46 43 35 32 25 12", "output": "6" }, { "input": "17 12\n99 88 86 82 75 75 74 65 58 52 45 30 21 16 7 2 2", "output": "12" }, { "input": "20 3\n98 98 96 89 87 82 82 80 76 74 74 68 61 60 43 32 30 22 4 2", "output": "3" }, { "input": "36 12\n90 87 86 85 83 80 79 78 76 70 69 69 61 61 59 58 56 48 45 44 42 41 33 31 27 25 23 21 20 19 15 14 12 7 5 5", "output": "12" }, { "input": "49 8\n99 98 98 96 92 92 90 89 89 86 86 85 83 80 79 76 74 69 67 67 58 56 55 51 49 47 47 46 45 41 41 40 39 34 34 33 25 23 18 15 13 13 11 9 5 4 3 3 1", "output": "9" }, { "input": "49 29\n100 98 98 96 96 96 95 87 85 84 81 76 74 70 63 63 63 62 57 57 56 54 53 52 50 47 45 41 41 39 38 31 30 28 27 26 23 22 20 15 15 11 7 6 6 4 2 1 0", "output": "29" }, { "input": "49 34\n99 98 96 96 93 92 90 89 88 86 85 85 82 76 73 69 66 64 63 63 60 59 57 57 56 55 54 54 51 48 47 44 42 42 40 39 38 36 33 26 24 23 19 17 17 14 12 7 4", "output": "34" }, { "input": "50 44\n100 100 99 97 95 91 91 84 83 83 79 71 70 69 69 62 61 60 59 59 58 58 58 55 55 54 52 48 47 45 44 44 38 36 32 31 28 28 25 25 24 24 24 22 17 15 14 13 12 4", "output": "44" }, { "input": "50 13\n99 95 94 94 88 87 81 79 78 76 74 72 72 69 68 67 67 67 66 63 62 61 58 57 55 55 54 51 50 50 48 48 42 41 38 35 34 32 31 30 26 24 13 13 12 6 5 4 3 3", "output": "13" }, { "input": "50 30\n100 98 96 94 91 89 88 81 81 81 81 81 76 73 72 71 70 69 66 64 61 59 59 56 52 50 49 48 43 39 36 35 34 34 31 29 27 26 24 22 16 16 15 14 14 14 9 7 4 3", "output": "30" }, { "input": "2 1\n10 10", "output": "2" }, { "input": "2 2\n10 10", "output": "2" }, { "input": "2 2\n10 0", "output": "1" }, { "input": "2 2\n10 1", "output": "2" }, { "input": "2 1\n10 0", "output": "1" }, { "input": "2 1\n10 2", "output": "1" }, { "input": "50 13\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "output": "0" }, { "input": "50 1\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "output": "0" }, { "input": "50 50\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "output": "0" }, { "input": "10 1\n5 5 5 3 3 3 0 0 0 0", "output": "3" }, { "input": "10 2\n5 5 5 3 3 3 0 0 0 0", "output": "3" }, { "input": "10 3\n5 5 5 3 3 3 0 0 0 0", "output": "3" }, { "input": "10 4\n5 5 5 3 3 3 0 0 0 0", "output": "6" }, { "input": "10 5\n5 5 5 3 3 3 0 0 0 0", "output": "6" }, { "input": "10 6\n5 5 5 3 3 3 0 0 0 0", "output": "6" }, { "input": "10 7\n5 5 5 3 3 3 0 0 0 0", "output": "6" }, { "input": "10 8\n5 5 5 3 3 3 0 0 0 0", "output": "6" }, { "input": "10 9\n5 5 5 3 3 3 0 0 0 0", "output": "6" }, { "input": "10 10\n5 5 5 3 3 3 0 0 0 0", "output": "6" } ]

1,699,371,815

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

62

0

n,k=map(int,input().split()) arr = [int(x) for x in input.split()] next_round=[x for x in arr if(x>0 and x>=arr[k-1])] print(len(next_round))

Title: Next Round Time Limit: None seconds Memory Limit: None megabytes Problem Description: "Contestant who earns a score equal to or greater than the *k*-th place finisher's score will advance to the next round, as long as the contestant earns a positive score..." — an excerpt from contest rules. A total of *n* participants took part in the contest (*n*<=≥<=*k*), and you already know their scores. Calculate how many participants will advance to the next round. Input Specification: The first line of the input contains two integers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=50) separated by a single space. The second line contains *n* space-separated integers *a*1,<=*a*2,<=...,<=*a**n* (0<=≤<=*a**i*<=≤<=100), where *a**i* is the score earned by the participant who got the *i*-th place. The given sequence is non-increasing (that is, for all *i* from 1 to *n*<=-<=1 the following condition is fulfilled: *a**i*<=≥<=*a**i*<=+<=1). Output Specification: Output the number of participants who advance to the next round. Demo Input: ['8 5\n10 9 8 7 7 7 5 5\n', '4 2\n0 0 0 0\n'] Demo Output: ['6\n', '0\n'] Note: In the first example the participant on the 5th place earned 7 points. As the participant on the 6th place also earned 7 points, there are 6 advancers. In the second example nobody got a positive score.

```python n,k=map(int,input().split()) arr = [int(x) for x in input.split()] next_round=[x for x in arr if(x>0 and x>=arr[k-1])] print(len(next_round)) ```

-1

126

B

Password

PROGRAMMING

1,700

[ "binary search", "dp", "hashing", "string suffix structures", "strings" ]

null

Asterix, Obelix and their temporary buddies Suffix and Prefix has finally found the Harmony temple. However, its doors were firmly locked and even Obelix had no luck opening them. A little later they found a string *s*, carved on a rock below the temple's gates. Asterix supposed that that's the password that opens the temple and read the string aloud. However, nothing happened. Then Asterix supposed that a password is some substring *t* of the string *s*. Prefix supposed that the substring *t* is the beginning of the string *s*; Suffix supposed that the substring *t* should be the end of the string *s*; and Obelix supposed that *t* should be located somewhere inside the string *s*, that is, *t* is neither its beginning, nor its end. Asterix chose the substring *t* so as to please all his companions. Besides, from all acceptable variants Asterix chose the longest one (as Asterix loves long strings). When Asterix read the substring *t* aloud, the temple doors opened. You know the string *s*. Find the substring *t* or determine that such substring does not exist and all that's been written above is just a nice legend.

You are given the string *s* whose length can vary from 1 to 106 (inclusive), consisting of small Latin letters.

Print the string *t*. If a suitable *t* string does not exist, then print "Just a legend" without the quotes.

[ "fixprefixsuffix\n", "abcdabc\n" ]

[ "fix", "Just a legend" ]

none

1,000

[ { "input": "fixprefixsuffix", "output": "fix" }, { "input": "abcdabc", "output": "Just a legend" }, { "input": "qwertyqwertyqwerty", "output": "qwerty" }, { "input": "papapapap", "output": "papap" }, { "input": "aaaaaaaaaa", "output": "aaaaaaaa" }, { "input": "ghbdtn", "output": "Just a legend" }, { "input": "a", "output": "Just a legend" }, { "input": "aa", "output": "Just a legend" }, { "input": "ab", "output": "Just a legend" }, { "input": "aaa", "output": "a" }, { "input": "aba", "output": "Just a legend" }, { "input": "aab", "output": "Just a legend" }, { "input": "abb", "output": "Just a legend" }, { "input": "abc", "output": "Just a legend" }, { "input": "aaabaabaaaaab", "output": "Just a legend" }, { "input": "aabaaabaaaaab", "output": "aab" }, { "input": "aaabaaaabab", "output": "Just a legend" }, { "input": "abcabcabcabcabc", "output": "abcabcabc" }, { "input": "aaaaabaaaa", "output": "aaaa" }, { "input": "aaaabaaaaaaa", "output": "aaaa" }, { "input": "ghghghgxghghghg", "output": "ghghg" }, { "input": "kincenvizh", "output": "Just a legend" }, { "input": "amcksgurlgqzqizdauqminfzshiweejkevbazyzylrrghumnvqeqqdedyopgtvxakqwpvxntxgrkrcxabhrgoxngrwrxrvcguuyw", "output": "Just a legend" }, { "input": "kwuaizneqxfflhmyruotjlkqksinoanvkyvqptkkntnpjdyzicceelgooajdgpkneuhyvhdtmasiglplajxolxovlhkwuaizneqx", "output": "Just a legend" }, { "input": "nfbdzgdlbjhrlvfryyjbvtsmzacxglcvukmyexdgpuiwvqbnfbdzgdlbjhrlvfryyjbtuomcwbwvlhefnfbdzgdlbjhrlvfryyjb", "output": "nfbdzgdlbjhrlvfryyjb" }, { "input": "btbdpnzdenxueteteytvkwnegodyhmdwhmrmbftrifytzudumzlacwytsuzefqfpjesdblxhpcsidgksisjdmhyxmmugrjmtfcgxmcgpmvbxbyszdugvmoyjeeqsywcvuqskcjotyhvdijyslgfvyujxthngnonasgnbzzygyikheelirdfsvuicbiazfdeqecbtbdpnzdenxueteteytvkwnegodyhmdwhmrmbftrifytzudumzlacwytsuzefqfpjesdblxhpcsidgksisjdmhyxmmugrjmtfcgxmcgpccdtdteohtjjuicfjfcbzpynlqhecyqqrjpmexgfqywnfmusldgzvgnzdmuuujtkdfnlytzgstquwqpuccxbtbdpnzdenxueteteytvkwnegodyhmdwhmrmbftrifytzudumzlacwytsuzefqfpjesdblxhpcsidgksisjdmhyxmmugrjmtfcgxmcgp", "output": "btbdpnzdenxueteteytvkwnegodyhmdwhmrmbftrifytzudumzlacwytsuzefqfpjesdblxhpcsidgksisjdmhyxmmugrjmtfcgxmcgp" }, { "input": "abcazabca", "output": "a" } ]

1,642,231,753

2,147,483,647

PyPy 3-64

TIME_LIMIT_EXCEEDED

TESTS

25

2,000

9,216,000

def longestString(N, S): ans = 0 for i in range (N - 1, 0, -1): if S[ : i] == S[N - i :]: if S[ : i] in S[1 : N - 1]: ans = i break if not ans: return "Just a legend" return S[ : ans] x=input() print(longestString(len(x),x))

Title: Password Time Limit: None seconds Memory Limit: None megabytes Problem Description: Asterix, Obelix and their temporary buddies Suffix and Prefix has finally found the Harmony temple. However, its doors were firmly locked and even Obelix had no luck opening them. A little later they found a string *s*, carved on a rock below the temple's gates. Asterix supposed that that's the password that opens the temple and read the string aloud. However, nothing happened. Then Asterix supposed that a password is some substring *t* of the string *s*. Prefix supposed that the substring *t* is the beginning of the string *s*; Suffix supposed that the substring *t* should be the end of the string *s*; and Obelix supposed that *t* should be located somewhere inside the string *s*, that is, *t* is neither its beginning, nor its end. Asterix chose the substring *t* so as to please all his companions. Besides, from all acceptable variants Asterix chose the longest one (as Asterix loves long strings). When Asterix read the substring *t* aloud, the temple doors opened. You know the string *s*. Find the substring *t* or determine that such substring does not exist and all that's been written above is just a nice legend. Input Specification: You are given the string *s* whose length can vary from 1 to 106 (inclusive), consisting of small Latin letters. Output Specification: Print the string *t*. If a suitable *t* string does not exist, then print "Just a legend" without the quotes. Demo Input: ['fixprefixsuffix\n', 'abcdabc\n'] Demo Output: ['fix', 'Just a legend'] Note: none

```python def longestString(N, S): ans = 0 for i in range (N - 1, 0, -1): if S[ : i] == S[N - i :]: if S[ : i] in S[1 : N - 1]: ans = i break if not ans: return "Just a legend" return S[ : ans] x=input() print(longestString(len(x),x)) ```

0

none

0

[ "none" ]

null

Today on a lecture about strings Gerald learned a new definition of string equivalency. Two strings *a* and *b* of equal length are called equivalent in one of the two cases: 1. They are equal. 1. If we split string *a* into two halves of the same size *a*1 and *a*2, and string *b* into two halves of the same size *b*1 and *b*2, then one of the following is correct: *a*1 is equivalent to *b*1, and *a*2 is equivalent to *b*2 1. *a*1 is equivalent to *b*2, and *a*2 is equivalent to *b*1 As a home task, the teacher gave two strings to his students and asked to determine if they are equivalent. Gerald has already completed this home task. Now it's your turn!

The first two lines of the input contain two strings given by the teacher. Each of them has the length from 1 to 200<=000 and consists of lowercase English letters. The strings have the same length.

Print "YES" (without the quotes), if these two strings are equivalent, and "NO" (without the quotes) otherwise.

[ "aaba\nabaa\n", "aabb\nabab\n" ]

[ "YES\n", "NO\n" ]

In the first sample you should split the first string into strings "aa" and "ba", the second one — into strings "ab" and "aa". "aa" is equivalent to "aa"; "ab" is equivalent to "ba" as "ab" = "a" + "b", "ba" = "b" + "a". In the second sample the first string can be splitted into strings "aa" and "bb", that are equivalent only to themselves. That's why string "aabb" is equivalent only to itself and to string "bbaa".

0

[ { "input": "aaba\nabaa", "output": "YES" }, { "input": "aabb\nabab", "output": "NO" }, { "input": "a\na", "output": "YES" }, { "input": "a\nb", "output": "NO" }, { "input": "ab\nab", "output": "YES" }, { "input": "ab\nba", "output": "YES" }, { "input": "ab\nbb", "output": "NO" }, { "input": "zzaa\naazz", "output": "YES" }, { "input": "azza\nzaaz", "output": "YES" }, { "input": "abc\nabc", "output": "YES" }, { "input": "abc\nacb", "output": "NO" }, { "input": "azzz\nzzaz", "output": "YES" }, { "input": "abcd\ndcab", "output": "YES" }, { "input": "abcd\ncdab", "output": "YES" }, { "input": "abcd\ndcba", "output": "YES" }, { "input": "abcd\nacbd", "output": "NO" }, { "input": "oloaxgddgujq\noloaxgujqddg", "output": "YES" }, { "input": "uwzwdxfmosmqatyv\ndxfmzwwusomqvyta", "output": "YES" }, { "input": "hagnzomowtledfdotnll\nledfdotnllomowthagnz", "output": "YES" }, { "input": "snyaydaeobufdg\nsnyaydaeobufdg", "output": "YES" }, { "input": "baaaaa\nabaaaa", "output": "NO" }, { "input": "hhiisug\nmzdjwju", "output": "NO" }, { "input": "bbbabbabaaab\naaaabbabbbbb", "output": "NO" }, { "input": "bbaaab\naababb", "output": "NO" }, { "input": "aabbaaaa\naaaaabab", "output": "NO" }, { "input": "aab\naba", "output": "NO" }, { "input": "abcddd\nbacddd", "output": "NO" }, { "input": "qgiufelsfhanx\naaaaaaaaaaaaa", "output": "NO" }, { "input": "aabaababaaba\naababaaababa", "output": "NO" }, { "input": "nocdqzdriyyil\naaaaaaaaaaaaa", "output": "NO" }, { "input": "zdmctxl\nkojqhgw", "output": "NO" }, { "input": "yhwepqwyhwepqwyhwepqweahnqtueahnqtueahnqtuyhwepqwyhwepqwyhwepqwyhwepqweahnqtueahnqtuyhwepqweahnqtueahnqtueahnqtueahnqtueahnqtueahnqtu\neahnqtueahnqtueahnqtuyhwepqweahnqtuyhwepqwyhwepqweahnqtuyhwepqweahnqtuyhwepqweahnqtueahnqtuyhwepqweahnqtueahnqtuyhwepqwyhwepqwyhwepqw", "output": "NO" }, { "input": "abc\nbac", "output": "NO" }, { "input": "ottceez\npcstdvz", "output": "NO" } ]

1,619,042,744

2,147,483,647

PyPy 3

TIME_LIMIT_EXCEEDED

TESTS

90

2,000

10,342,400

def isEquivalent(at, bt): size = len(at) if(size % 2 == 1): return at == bt mid = size//2 a1 = at[:mid] a2 = at[mid:] b1 = bt[:mid] b2 = bt[mid:] return (isEquivalent(a1, b1) and isEquivalent(a2, b2)) or (isEquivalent(a1, b2) and isEquivalent(a2, b1)) a = input() b = input() if isEquivalent(a, b): print('YES') else: print('NO')

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: Today on a lecture about strings Gerald learned a new definition of string equivalency. Two strings *a* and *b* of equal length are called equivalent in one of the two cases: 1. They are equal. 1. If we split string *a* into two halves of the same size *a*1 and *a*2, and string *b* into two halves of the same size *b*1 and *b*2, then one of the following is correct: *a*1 is equivalent to *b*1, and *a*2 is equivalent to *b*2 1. *a*1 is equivalent to *b*2, and *a*2 is equivalent to *b*1 As a home task, the teacher gave two strings to his students and asked to determine if they are equivalent. Gerald has already completed this home task. Now it's your turn! Input Specification: The first two lines of the input contain two strings given by the teacher. Each of them has the length from 1 to 200<=000 and consists of lowercase English letters. The strings have the same length. Output Specification: Print "YES" (without the quotes), if these two strings are equivalent, and "NO" (without the quotes) otherwise. Demo Input: ['aaba\nabaa\n', 'aabb\nabab\n'] Demo Output: ['YES\n', 'NO\n'] Note: In the first sample you should split the first string into strings "aa" and "ba", the second one — into strings "ab" and "aa". "aa" is equivalent to "aa"; "ab" is equivalent to "ba" as "ab" = "a" + "b", "ba" = "b" + "a". In the second sample the first string can be splitted into strings "aa" and "bb", that are equivalent only to themselves. That's why string "aabb" is equivalent only to itself and to string "bbaa".

```python def isEquivalent(at, bt): size = len(at) if(size % 2 == 1): return at == bt mid = size//2 a1 = at[:mid] a2 = at[mid:] b1 = bt[:mid] b2 = bt[mid:] return (isEquivalent(a1, b1) and isEquivalent(a2, b2)) or (isEquivalent(a1, b2) and isEquivalent(a2, b1)) a = input() b = input() if isEquivalent(a, b): print('YES') else: print('NO') ```

0

450

A

Jzzhu and Children

PROGRAMMING

1,000

[ "implementation" ]

null

There are *n* children in Jzzhu's school. Jzzhu is going to give some candies to them. Let's number all the children from 1 to *n*. The *i*-th child wants to get at least *a**i* candies. Jzzhu asks children to line up. Initially, the *i*-th child stands at the *i*-th place of the line. Then Jzzhu start distribution of the candies. He follows the algorithm: 1. Give *m* candies to the first child of the line. 1. If this child still haven't got enough candies, then the child goes to the end of the line, else the child go home. 1. Repeat the first two steps while the line is not empty. Consider all the children in the order they go home. Jzzhu wants to know, which child will be the last in this order?

The first line contains two integers *n*,<=*m* (1<=≤<=*n*<=≤<=100; 1<=≤<=*m*<=≤<=100). The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=100).

Output a single integer, representing the number of the last child.

[ "5 2\n1 3 1 4 2\n", "6 4\n1 1 2 2 3 3\n" ]

[ "4\n", "6\n" ]

Let's consider the first sample. Firstly child 1 gets 2 candies and go home. Then child 2 gets 2 candies and go to the end of the line. Currently the line looks like [3, 4, 5, 2] (indices of the children in order of the line). Then child 3 gets 2 candies and go home, and then child 4 gets 2 candies and goes to the end of the line. Currently the line looks like [5, 2, 4]. Then child 5 gets 2 candies and goes home. Then child 2 gets two candies and goes home, and finally child 4 gets 2 candies and goes home. Child 4 is the last one who goes home.

500

[ { "input": "5 2\n1 3 1 4 2", "output": "4" }, { "input": "6 4\n1 1 2 2 3 3", "output": "6" }, { "input": "7 3\n6 1 5 4 2 3 1", "output": "4" }, { "input": "10 5\n2 7 3 6 2 5 1 3 4 5", "output": "4" }, { "input": "100 1\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100", "output": "100" }, { "input": "9 3\n9 5 2 3 7 1 8 4 6", "output": "7" }, { "input": "20 10\n58 4 32 10 73 7 30 39 47 6 59 21 24 66 79 79 46 13 29 58", "output": "16" }, { "input": "50 5\n89 56 3 2 40 37 56 52 83 59 43 83 43 59 29 74 22 58 53 41 53 67 78 30 57 32 58 29 95 46 45 85 60 49 41 82 8 71 52 40 45 26 6 71 84 91 4 93 40 54", "output": "48" }, { "input": "50 1\n4 3 9 7 6 8 3 7 10 9 8 8 10 2 9 3 2 4 4 10 4 6 8 10 9 9 4 2 8 9 4 4 9 5 1 5 2 4 4 9 10 2 5 10 7 2 8 6 8 1", "output": "44" }, { "input": "50 5\n3 9 10 8 3 3 4 6 8 2 9 9 3 1 2 10 6 8 7 2 7 4 2 7 5 10 2 2 2 5 10 5 6 6 8 7 10 4 3 2 10 8 6 6 8 6 4 4 1 3", "output": "46" }, { "input": "50 2\n56 69 72 15 95 92 51 1 74 87 100 29 46 54 18 81 84 72 84 83 20 63 71 27 45 74 50 89 48 8 21 15 47 3 39 73 80 84 6 99 17 25 56 3 74 64 71 39 89 78", "output": "40" }, { "input": "50 3\n31 39 64 16 86 3 1 9 25 54 98 42 20 3 49 41 73 37 55 62 33 77 64 22 33 82 26 13 10 13 7 40 48 18 46 79 94 72 19 12 11 61 16 37 10 49 14 94 48 69", "output": "11" }, { "input": "50 100\n67 67 61 68 42 29 70 77 12 61 71 27 4 73 87 52 59 38 93 90 31 27 87 47 26 57 76 6 28 72 81 68 50 84 69 79 39 93 52 6 88 12 46 13 90 68 71 38 90 95", "output": "50" }, { "input": "100 3\n4 14 20 11 19 11 14 20 5 7 6 12 11 17 5 11 7 6 2 10 13 5 12 8 5 17 20 18 7 19 11 7 7 20 20 8 10 17 17 19 20 5 15 16 19 7 11 16 4 17 2 10 1 20 20 16 19 9 9 11 5 7 12 9 9 6 20 18 13 19 8 4 8 1 2 4 10 11 15 14 1 7 17 12 13 19 12 2 3 14 15 15 5 17 14 12 17 14 16 9", "output": "86" }, { "input": "100 5\n16 8 14 16 12 11 17 19 19 2 8 9 5 6 19 9 11 18 6 9 14 16 14 18 17 17 17 5 15 20 19 7 7 10 10 5 14 20 5 19 11 16 16 19 17 9 7 12 14 10 2 11 14 5 20 8 10 11 19 2 14 14 19 17 5 10 8 8 4 2 1 10 20 12 14 11 7 6 6 15 1 5 9 15 3 17 16 17 5 14 11 9 16 15 1 11 10 6 15 7", "output": "93" }, { "input": "100 1\n58 94 18 50 17 14 96 62 83 80 75 5 9 22 25 41 3 96 74 45 66 37 2 37 13 85 68 54 77 11 85 19 25 21 52 59 90 61 72 89 82 22 10 16 3 68 61 29 55 76 28 85 65 76 27 3 14 10 56 37 86 18 35 38 56 68 23 88 33 38 52 87 55 83 94 34 100 41 83 56 91 77 32 74 97 13 67 31 57 81 53 39 5 88 46 1 79 4 49 42", "output": "77" }, { "input": "100 2\n1 51 76 62 34 93 90 43 57 59 52 78 3 48 11 60 57 48 5 54 28 81 87 23 44 77 67 61 14 73 29 53 21 89 67 41 47 9 63 37 1 71 40 85 4 14 77 40 78 75 89 74 4 70 32 65 81 95 49 90 72 41 76 55 69 83 73 84 85 93 46 6 74 90 62 37 97 7 7 37 83 30 37 88 34 16 11 59 85 19 57 63 85 20 63 97 97 65 61 48", "output": "97" }, { "input": "100 3\n30 83 14 55 61 66 34 98 90 62 89 74 45 93 33 31 75 35 82 100 63 69 48 18 99 2 36 71 14 30 70 76 96 85 97 90 49 36 6 76 37 94 70 3 63 73 75 48 39 29 13 2 46 26 9 56 1 18 54 53 85 34 2 12 1 93 75 67 77 77 14 26 33 25 55 9 57 70 75 6 87 66 18 3 41 69 73 24 49 2 20 72 39 58 91 54 74 56 66 78", "output": "20" }, { "input": "100 4\n69 92 76 3 32 50 15 38 21 22 14 3 67 41 95 12 10 62 83 52 78 1 18 58 94 35 62 71 58 75 13 73 60 34 50 97 50 70 19 96 53 10 100 26 20 39 62 59 88 26 24 83 70 68 66 8 6 38 16 93 2 91 81 89 78 74 21 8 31 56 28 53 77 5 81 5 94 42 77 75 92 15 59 36 61 18 55 45 69 68 81 51 12 42 85 74 98 31 17 41", "output": "97" }, { "input": "100 5\n2 72 10 60 6 50 72 34 97 77 35 43 80 64 40 53 46 6 90 22 29 70 26 68 52 19 72 88 83 18 55 32 99 81 11 21 39 42 41 63 60 97 30 23 55 78 89 35 24 50 99 52 27 76 24 8 20 27 51 37 17 82 69 18 46 19 26 77 52 83 76 65 43 66 84 84 13 30 66 88 84 23 37 1 17 26 11 50 73 56 54 37 40 29 35 8 1 39 50 82", "output": "51" }, { "input": "100 7\n6 73 7 54 92 33 66 65 80 47 2 53 28 59 61 16 54 89 37 48 77 40 49 59 27 52 17 22 78 80 81 80 8 93 50 7 87 57 29 16 89 55 20 7 51 54 30 98 44 96 27 70 1 1 32 61 22 92 84 98 31 89 91 90 28 56 49 25 86 49 55 16 19 1 18 8 88 47 16 18 73 86 2 96 16 91 74 49 38 98 94 25 34 85 29 27 99 31 31 58", "output": "97" }, { "input": "100 9\n36 4 45 16 19 6 10 87 44 82 71 49 70 35 83 19 40 76 45 94 44 96 10 54 82 77 86 63 11 37 21 3 15 89 80 88 89 16 72 23 25 9 51 25 10 45 96 5 6 18 51 31 42 57 41 51 42 15 89 61 45 82 16 48 61 67 19 40 9 33 90 36 78 36 79 79 16 10 83 87 9 22 84 12 23 76 36 14 2 81 56 33 56 23 57 84 76 55 35 88", "output": "47" }, { "input": "100 10\n75 81 39 64 90 58 92 28 75 9 96 78 92 83 77 68 76 71 14 46 58 60 80 25 78 11 13 63 22 82 65 68 47 6 33 63 90 50 85 43 73 94 80 48 67 11 83 17 22 15 94 80 66 99 66 4 46 35 52 1 62 39 96 57 37 47 97 49 64 12 36 63 90 16 4 75 85 82 85 56 13 4 92 45 44 93 17 35 22 46 18 44 29 7 52 4 100 98 87 51", "output": "98" }, { "input": "100 20\n21 19 61 70 54 97 98 14 61 72 25 94 24 56 55 25 12 80 76 11 35 17 80 26 11 94 52 47 84 61 10 2 74 25 10 21 2 79 55 50 30 75 10 64 44 5 60 96 52 16 74 41 20 77 20 44 8 86 74 36 49 61 99 13 54 64 19 99 50 43 12 73 48 48 83 55 72 73 63 81 30 27 95 9 97 82 24 3 89 90 33 14 47 88 22 78 12 75 58 67", "output": "94" }, { "input": "100 30\n56 79 59 23 11 23 67 82 81 80 99 79 8 58 93 36 98 81 46 39 34 67 3 50 4 68 70 71 2 21 52 30 75 23 33 21 16 100 56 43 8 27 40 8 56 24 17 40 94 10 67 49 61 36 95 87 17 41 7 94 33 19 17 50 26 11 94 54 38 46 77 9 53 35 98 42 50 20 43 6 78 6 38 24 100 45 43 16 1 50 16 46 14 91 95 88 10 1 50 19", "output": "95" }, { "input": "100 40\n86 11 97 17 38 95 11 5 13 83 67 75 50 2 46 39 84 68 22 85 70 23 64 46 59 93 39 80 35 78 93 21 83 19 64 1 49 59 99 83 44 81 70 58 15 82 83 47 55 65 91 10 2 92 4 77 37 32 12 57 78 11 42 8 59 21 96 69 61 30 44 29 12 70 91 14 10 83 11 75 14 10 19 39 8 98 5 81 66 66 79 55 36 29 22 45 19 24 55 49", "output": "88" }, { "input": "100 50\n22 39 95 69 94 53 80 73 33 90 40 60 2 4 84 50 70 38 92 12 36 74 87 70 51 36 57 5 54 6 35 81 52 17 55 100 95 81 32 76 21 1 100 1 95 1 40 91 98 59 84 19 11 51 79 19 47 86 45 15 62 2 59 77 31 68 71 92 17 33 10 33 85 57 5 2 88 97 91 99 63 20 63 54 79 93 24 62 46 27 30 87 3 64 95 88 16 50 79 1", "output": "99" }, { "input": "100 70\n61 48 89 17 97 6 93 13 64 50 66 88 24 52 46 99 6 65 93 64 82 37 57 41 47 1 84 5 97 83 79 46 16 35 40 7 64 15 44 96 37 17 30 92 51 67 26 3 14 56 27 68 66 93 36 39 51 6 40 55 79 26 71 54 8 48 18 2 71 12 55 60 29 37 31 97 26 37 25 68 67 70 3 87 100 41 5 82 65 92 24 66 76 48 89 8 40 93 31 95", "output": "100" }, { "input": "100 90\n87 32 30 15 10 52 93 63 84 1 82 41 27 51 75 32 42 94 39 53 70 13 4 22 99 35 44 38 5 23 18 100 61 80 9 12 42 93 9 77 3 7 60 95 66 78 95 42 69 8 1 88 93 66 96 20 76 63 15 36 92 52 2 72 36 57 48 63 29 20 74 88 49 47 81 61 94 74 70 93 47 3 19 52 59 41 5 40 22 3 76 97 91 37 95 88 91 99 76 15", "output": "98" }, { "input": "100 100\n79 75 7 28 6 96 38 35 57 95 41 74 24 96 32 78 81 13 63 84 24 95 3 23 66 1 60 6 96 49 41 5 14 18 31 97 66 19 49 89 49 70 51 28 20 99 18 1 28 77 24 46 69 21 40 32 31 66 28 6 66 97 9 16 70 90 91 30 34 82 93 41 65 11 39 52 1 88 63 43 80 50 60 49 28 56 18 76 24 57 74 1 28 99 36 35 79 54 18 16", "output": "100" }, { "input": "1 3\n5", "output": "1" }, { "input": "1 1\n100", "output": "1" }, { "input": "2 3\n4 2", "output": "1" }, { "input": "2 5\n99 97", "output": "2" }, { "input": "3 4\n7 5 2", "output": "2" }, { "input": "3 50\n47 86 51", "output": "3" }, { "input": "5 100\n82 100 85 1 37", "output": "5" }, { "input": "5 20\n40 39 21 5 20", "output": "3" }, { "input": "1 27\n81", "output": "1" }, { "input": "20 13\n7 8 29 83 74 28 93 85 7 8 3 9 8 70 49 50 39 41 57 1", "output": "7" }, { "input": "2 1\n100 2", "output": "1" }, { "input": "2 2\n6 4", "output": "1" }, { "input": "5 2\n6 4 4 1 1", "output": "1" }, { "input": "1 4\n3", "output": "1" }, { "input": "3 2\n1 5 3", "output": "2" }, { "input": "3 1\n3 2 2", "output": "1" }, { "input": "3 1\n2 3 2", "output": "2" }, { "input": "5 1\n5 1 1 1 1", "output": "1" }, { "input": "2 3\n7 4", "output": "1" } ]

1,650,140,879

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

40

93

2,252,800

from collections import deque n, m = map(int,input().split()) d = list(map(int,input().split())) sm = sum(d) ok = -1 for i in range(n): if sm == 0: break for j in range(n): if d[j] != 0: if d[j] <= m: sm -= d[j] d[j] = 0 ok = j + 1 else: d[j] -= m sm -= m ok = j + 1 print(ok)

Title: Jzzhu and Children Time Limit: None seconds Memory Limit: None megabytes Problem Description: There are *n* children in Jzzhu's school. Jzzhu is going to give some candies to them. Let's number all the children from 1 to *n*. The *i*-th child wants to get at least *a**i* candies. Jzzhu asks children to line up. Initially, the *i*-th child stands at the *i*-th place of the line. Then Jzzhu start distribution of the candies. He follows the algorithm: 1. Give *m* candies to the first child of the line. 1. If this child still haven't got enough candies, then the child goes to the end of the line, else the child go home. 1. Repeat the first two steps while the line is not empty. Consider all the children in the order they go home. Jzzhu wants to know, which child will be the last in this order? Input Specification: The first line contains two integers *n*,<=*m* (1<=≤<=*n*<=≤<=100; 1<=≤<=*m*<=≤<=100). The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=100). Output Specification: Output a single integer, representing the number of the last child. Demo Input: ['5 2\n1 3 1 4 2\n', '6 4\n1 1 2 2 3 3\n'] Demo Output: ['4\n', '6\n'] Note: Let's consider the first sample. Firstly child 1 gets 2 candies and go home. Then child 2 gets 2 candies and go to the end of the line. Currently the line looks like [3, 4, 5, 2] (indices of the children in order of the line). Then child 3 gets 2 candies and go home, and then child 4 gets 2 candies and goes to the end of the line. Currently the line looks like [5, 2, 4]. Then child 5 gets 2 candies and goes home. Then child 2 gets two candies and goes home, and finally child 4 gets 2 candies and goes home. Child 4 is the last one who goes home.

```python from collections import deque n, m = map(int,input().split()) d = list(map(int,input().split())) sm = sum(d) ok = -1 for i in range(n): if sm == 0: break for j in range(n): if d[j] != 0: if d[j] <= m: sm -= d[j] d[j] = 0 ok = j + 1 else: d[j] -= m sm -= m ok = j + 1 print(ok) ```

0

424

C

Magic Formulas

PROGRAMMING

1,600

[ "math" ]

null

People in the Tomskaya region like magic formulas very much. You can see some of them below. Imagine you are given a sequence of positive integer numbers *p*1, *p*2, ..., *p**n*. Lets write down some magic formulas: Here, "mod" means the operation of taking the residue after dividing. The expression means applying the bitwise *xor* (excluding "OR") operation to integers *x* and *y*. The given operation exists in all modern programming languages. For example, in languages C++ and Java it is represented by "^", in Pascal — by "xor". People in the Tomskaya region like magic formulas very much, but they don't like to calculate them! Therefore you are given the sequence *p*, calculate the value of *Q*.

The first line of the input contains the only integer *n* (1<=≤<=*n*<=≤<=106). The next line contains *n* integers: *p*1,<=*p*2,<=...,<=*p**n* (0<=≤<=*p**i*<=≤<=2·109).

The only line of output should contain a single integer — the value of *Q*.

[ "3\n1 2 3\n" ]

[ "3\n" ]

none

1,500

[ { "input": "3\n1 2 3", "output": "3" }, { "input": "1\n0", "output": "0" }, { "input": "2\n65535 0", "output": "65534" }, { "input": "10\n1356106972 165139648 978829595 410669403 873711167 287346624 117863440 228957745 835903650 1575323015", "output": "948506286" }, { "input": "20\n1999581813 313463235 1733614990 662007911 1789348031 1120800519 196972430 1579897311 191001928 241720485 1426288783 1103088596 839698523 1974815116 77040208 904949865 840522850 1488919296 1027394709 857931762", "output": "1536068328" }, { "input": "25\n39226529 640445129 936289624 364461191 1096077769 573427707 1919403410 950067229 1217479531 455229458 1574949468 397268319 1267289585 995220637 1920919164 501015483 1815262670 1197059269 86947741 1137410885 667368575 733666398 1536581408 611239452 947487746", "output": "259654661" } ]

1,679,130,000

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

1

46

0

n=int(input()) lst=list(map(int,input().split())) m=0 for i in lst: m=m^i print(m^n)

Title: Magic Formulas Time Limit: None seconds Memory Limit: None megabytes Problem Description: People in the Tomskaya region like magic formulas very much. You can see some of them below. Imagine you are given a sequence of positive integer numbers *p*1, *p*2, ..., *p**n*. Lets write down some magic formulas: Here, "mod" means the operation of taking the residue after dividing. The expression means applying the bitwise *xor* (excluding "OR") operation to integers *x* and *y*. The given operation exists in all modern programming languages. For example, in languages C++ and Java it is represented by "^", in Pascal — by "xor". People in the Tomskaya region like magic formulas very much, but they don't like to calculate them! Therefore you are given the sequence *p*, calculate the value of *Q*. Input Specification: The first line of the input contains the only integer *n* (1<=≤<=*n*<=≤<=106). The next line contains *n* integers: *p*1,<=*p*2,<=...,<=*p**n* (0<=≤<=*p**i*<=≤<=2·109). Output Specification: The only line of output should contain a single integer — the value of *Q*. Demo Input: ['3\n1 2 3\n'] Demo Output: ['3\n'] Note: none

```python n=int(input()) lst=list(map(int,input().split())) m=0 for i in lst: m=m^i print(m^n) ```

0

518

B

Tanya and Postcard

PROGRAMMING

1,400

[ "greedy", "implementation", "strings" ]

null

Little Tanya decided to present her dad a postcard on his Birthday. She has already created a message — string *s* of length *n*, consisting of uppercase and lowercase English letters. Tanya can't write yet, so she found a newspaper and decided to cut out the letters and glue them into the postcard to achieve string *s*. The newspaper contains string *t*, consisting of uppercase and lowercase English letters. We know that the length of string *t* greater or equal to the length of the string *s*. The newspaper may possibly have too few of some letters needed to make the text and too many of some other letters. That's why Tanya wants to cut some *n* letters out of the newspaper and make a message of length exactly *n*, so that it looked as much as possible like *s*. If the letter in some position has correct value and correct letter case (in the string *s* and in the string that Tanya will make), then she shouts joyfully "YAY!", and if the letter in the given position has only the correct value but it is in the wrong case, then the girl says "WHOOPS". Tanya wants to make such message that lets her shout "YAY!" as much as possible. If there are multiple ways to do this, then her second priority is to maximize the number of times she says "WHOOPS". Your task is to help Tanya make the message.

The first line contains line *s* (1<=≤<=|*s*|<=≤<=2·105), consisting of uppercase and lowercase English letters — the text of Tanya's message. The second line contains line *t* (|*s*|<=≤<=|*t*|<=≤<=2·105), consisting of uppercase and lowercase English letters — the text written in the newspaper. Here |*a*| means the length of the string *a*.

Print two integers separated by a space: - the first number is the number of times Tanya shouts "YAY!" while making the message, - the second number is the number of times Tanya says "WHOOPS" while making the message.

[ "AbC\nDCbA\n", "ABC\nabc\n", "abacaba\nAbaCaBA\n" ]

[ "3 0\n", "0 3\n", "3 4\n" ]

none

1,000

[ { "input": "AbC\nDCbA", "output": "3 0" }, { "input": "ABC\nabc", "output": "0 3" }, { "input": "abacaba\nAbaCaBA", "output": "3 4" }, { "input": "zzzzz\nZZZZZ", "output": "0 5" }, { "input": "zzzZZZ\nZZZzzZ", "output": "5 1" }, { "input": "abcdefghijklmnopqrstuvwxyz\nABCDEFGHIJKLMNOPQRSTUVWXYZ", "output": "0 26" }, { "input": "abcdefghijklmnopqrstuvwxyz\nqrsimtabuvzhnwcdefgjklxyop", "output": "26 0" }, { "input": "l\nFPbAVjsMpPDTLkfwNYFmBDHPTDSWSOUlrBHYJHPM", "output": "1 0" }, { "input": "ncMeXssLHS\nuwyeMcaFatpInZVdEYpwJQSnVxLK", "output": "6 1" }, { "input": "DpiNBmCRFWxpdbfGOzvvOcemjructoAdEwegTvbVbfWWRPGyEAxGdDRWVlqNyGWMWHMrHAIZpyxvgaflrsVZhhZRouvpxrKXFZam\nwwPLFtNfPtJXvMLuHjKfYyaRhreNSWSzOvDpqHCGcqllACNPGHxReeFUCmAqIKXYytsSQwIxJzNiiUtgebVuwRmWpRALLyKAzyDPvgIGxALSaeeTIqm", "output": "66 12" }, { "input": "CCAE\ndcecc", "output": "0 3" }, { "input": "Dccb\nbeeeb", "output": "1 0" }, { "input": "Adc\neadeabcad", "output": "2 1" }, { "input": "DBAdeb\ndeeabcddadaa", "output": "3 2" }, { "input": "EDCED\neebeacdba", "output": "0 4" }, { "input": "CdAbD\ndecbde", "output": "2 2" }, { "input": "a\nB", "output": "0 0" }, { "input": "r\nqA", "output": "0 0" } ]

1,686,623,195

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

7

78

1,331,200

from collections import Counter s = input() bank = dict(Counter(input())) yay = 0 for letter in s: if letter in bank and bank[letter] > 0: bank[letter] -= 1 yay += 1 print(yay, len(s) - yay)

Title: Tanya and Postcard Time Limit: None seconds Memory Limit: None megabytes Problem Description: Little Tanya decided to present her dad a postcard on his Birthday. She has already created a message — string *s* of length *n*, consisting of uppercase and lowercase English letters. Tanya can't write yet, so she found a newspaper and decided to cut out the letters and glue them into the postcard to achieve string *s*. The newspaper contains string *t*, consisting of uppercase and lowercase English letters. We know that the length of string *t* greater or equal to the length of the string *s*. The newspaper may possibly have too few of some letters needed to make the text and too many of some other letters. That's why Tanya wants to cut some *n* letters out of the newspaper and make a message of length exactly *n*, so that it looked as much as possible like *s*. If the letter in some position has correct value and correct letter case (in the string *s* and in the string that Tanya will make), then she shouts joyfully "YAY!", and if the letter in the given position has only the correct value but it is in the wrong case, then the girl says "WHOOPS". Tanya wants to make such message that lets her shout "YAY!" as much as possible. If there are multiple ways to do this, then her second priority is to maximize the number of times she says "WHOOPS". Your task is to help Tanya make the message. Input Specification: The first line contains line *s* (1<=≤<=|*s*|<=≤<=2·105), consisting of uppercase and lowercase English letters — the text of Tanya's message. The second line contains line *t* (|*s*|<=≤<=|*t*|<=≤<=2·105), consisting of uppercase and lowercase English letters — the text written in the newspaper. Here |*a*| means the length of the string *a*. Output Specification: Print two integers separated by a space: - the first number is the number of times Tanya shouts "YAY!" while making the message, - the second number is the number of times Tanya says "WHOOPS" while making the message. Demo Input: ['AbC\nDCbA\n', 'ABC\nabc\n', 'abacaba\nAbaCaBA\n'] Demo Output: ['3 0\n', '0 3\n', '3 4\n'] Note: none

```python from collections import Counter s = input() bank = dict(Counter(input())) yay = 0 for letter in s: if letter in bank and bank[letter] > 0: bank[letter] -= 1 yay += 1 print(yay, len(s) - yay) ```

0

163

E

e-Government

PROGRAMMING

2,800

[ "data structures", "dfs and similar", "dp", "strings", "trees" ]

null

The best programmers of Embezzland compete to develop a part of the project called "e-Government" — the system of automated statistic collecting and press analysis. We know that any of the *k* citizens can become a member of the Embezzland government. The citizens' surnames are *a*1,<=*a*2,<=...,<=*a**k*. All surnames are different. Initially all *k* citizens from this list are members of the government. The system should support the following options: - Include citizen *a**i* to the government. - Exclude citizen *a**i* from the government. - Given a newspaper article text, calculate how politicized it is. To do this, for every active government member the system counts the number of times his surname occurs in the text as a substring. All occurrences are taken into consideration, including the intersecting ones. The degree of politicization of a text is defined as the sum of these values for all active government members. Implement this system.

The first line contains space-separated integers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=105) — the number of queries to the system and the number of potential government members. Next *k* lines contain the surnames *a*1,<=*a*2,<=...,<=*a**k*, one per line. All surnames are pairwise different. Next *n* lines contain queries to the system, one per line. Each query consists of a character that determines an operation and the operation argument, written consecutively without a space. Operation "include in the government" corresponds to the character "+", operation "exclude" corresponds to "-". An argument of those operations is an integer between 1 and *k* — the index of the citizen involved in the operation. Any citizen can be included and excluded from the government an arbitrary number of times in any order. Including in the government a citizen who is already there or excluding the citizen who isn't there changes nothing. The operation "calculate politicization" corresponds to character "?". Its argument is a text. All strings — surnames and texts — are non-empty sequences of lowercase Latin letters. The total length of all surnames doesn't exceed 106, the total length of all texts doesn't exceed 106.

For any "calculate politicization" operation print on a separate line the degree of the politicization of the given text. Print nothing for other operations.

[ "7 3\na\naa\nab\n?aaab\n-2\n?aaab\n-3\n?aaab\n+2\n?aabbaa\n" ]

[ "6\n4\n3\n6\n" ]

none

2,500

[]

1,681,378,036

2,147,483,647

PyPy 3-64

TIME_LIMIT_EXCEEDED

TESTS

5

1,000

11,673,600

def count_substring_occurrences(substring, text): return sum(1 for i in range(len(text) - len(substring) + 1) if text[i:i + len(substring)] == substring) def main(): n, k = map(int, input().split()) surnames = [input().strip() for _ in range(k)] gov_members = set(range(k)) for _ in range(n): query = input().strip() operation, arg = query[0], query[1:] if operation == '+': gov_members.add(int(arg) - 1) elif operation == '-': gov_members.discard(int(arg) - 1) elif operation == '?': politicization = sum(count_substring_occurrences(surnames[i], arg) for i in gov_members) print(politicization) if __name__ == "__main__": main()

Title: e-Government Time Limit: None seconds Memory Limit: None megabytes Problem Description: The best programmers of Embezzland compete to develop a part of the project called "e-Government" — the system of automated statistic collecting and press analysis. We know that any of the *k* citizens can become a member of the Embezzland government. The citizens' surnames are *a*1,<=*a*2,<=...,<=*a**k*. All surnames are different. Initially all *k* citizens from this list are members of the government. The system should support the following options: - Include citizen *a**i* to the government. - Exclude citizen *a**i* from the government. - Given a newspaper article text, calculate how politicized it is. To do this, for every active government member the system counts the number of times his surname occurs in the text as a substring. All occurrences are taken into consideration, including the intersecting ones. The degree of politicization of a text is defined as the sum of these values for all active government members. Implement this system. Input Specification: The first line contains space-separated integers *n* and *k* (1<=≤<=*n*,<=*k*<=≤<=105) — the number of queries to the system and the number of potential government members. Next *k* lines contain the surnames *a*1,<=*a*2,<=...,<=*a**k*, one per line. All surnames are pairwise different. Next *n* lines contain queries to the system, one per line. Each query consists of a character that determines an operation and the operation argument, written consecutively without a space. Operation "include in the government" corresponds to the character "+", operation "exclude" corresponds to "-". An argument of those operations is an integer between 1 and *k* — the index of the citizen involved in the operation. Any citizen can be included and excluded from the government an arbitrary number of times in any order. Including in the government a citizen who is already there or excluding the citizen who isn't there changes nothing. The operation "calculate politicization" corresponds to character "?". Its argument is a text. All strings — surnames and texts — are non-empty sequences of lowercase Latin letters. The total length of all surnames doesn't exceed 106, the total length of all texts doesn't exceed 106. Output Specification: For any "calculate politicization" operation print on a separate line the degree of the politicization of the given text. Print nothing for other operations. Demo Input: ['7 3\na\naa\nab\n?aaab\n-2\n?aaab\n-3\n?aaab\n+2\n?aabbaa\n'] Demo Output: ['6\n4\n3\n6\n'] Note: none

```python def count_substring_occurrences(substring, text): return sum(1 for i in range(len(text) - len(substring) + 1) if text[i:i + len(substring)] == substring) def main(): n, k = map(int, input().split()) surnames = [input().strip() for _ in range(k)] gov_members = set(range(k)) for _ in range(n): query = input().strip() operation, arg = query[0], query[1:] if operation == '+': gov_members.add(int(arg) - 1) elif operation == '-': gov_members.discard(int(arg) - 1) elif operation == '?': politicization = sum(count_substring_occurrences(surnames[i], arg) for i in gov_members) print(politicization) if __name__ == "__main__": main() ```

0

999

A

Mishka and Contest

PROGRAMMING

800

[ "brute force", "implementation" ]

null

Mishka started participating in a programming contest. There are $n$ problems in the contest. Mishka's problem-solving skill is equal to $k$. Mishka arranges all problems from the contest into a list. Because of his weird principles, Mishka only solves problems from one of the ends of the list. Every time, he chooses which end (left or right) he will solve the next problem from. Thus, each problem Mishka solves is either the leftmost or the rightmost problem in the list. Mishka cannot solve a problem with difficulty greater than $k$. When Mishka solves the problem, it disappears from the list, so the length of the list decreases by $1$. Mishka stops when he is unable to solve any problem from any end of the list. How many problems can Mishka solve?

The first line of input contains two integers $n$ and $k$ ($1 \le n, k \le 100$) — the number of problems in the contest and Mishka's problem-solving skill. The second line of input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$), where $a_i$ is the difficulty of the $i$-th problem. The problems are given in order from the leftmost to the rightmost in the list.

Print one integer — the maximum number of problems Mishka can solve.

[ "8 4\n4 2 3 1 5 1 6 4\n", "5 2\n3 1 2 1 3\n", "5 100\n12 34 55 43 21\n" ]

[ "5\n", "0\n", "5\n" ]

In the first example, Mishka can solve problems in the following order: $[4, 2, 3, 1, 5, 1, 6, 4] \rightarrow [2, 3, 1, 5, 1, 6, 4] \rightarrow [2, 3, 1, 5, 1, 6] \rightarrow [3, 1, 5, 1, 6] \rightarrow [1, 5, 1, 6] \rightarrow [5, 1, 6]$, so the number of solved problems will be equal to $5$. In the second example, Mishka can't solve any problem because the difficulties of problems from both ends are greater than $k$. In the third example, Mishka's solving skill is so amazing that he can solve all the problems.

0

[ { "input": "8 4\n4 2 3 1 5 1 6 4", "output": "5" }, { "input": "5 2\n3 1 2 1 3", "output": "0" }, { "input": "5 100\n12 34 55 43 21", "output": "5" }, { "input": "100 100\n44 47 36 83 76 94 86 69 31 2 22 77 37 51 10 19 25 78 53 25 1 29 48 95 35 53 22 72 49 86 60 38 13 91 89 18 54 19 71 2 25 33 65 49 53 5 95 90 100 68 25 5 87 48 45 72 34 14 100 44 94 75 80 26 25 7 57 82 49 73 55 43 42 60 34 8 51 11 71 41 81 23 20 89 12 72 68 26 96 92 32 63 13 47 19 9 35 56 79 62", "output": "100" }, { "input": "100 99\n84 82 43 4 71 3 30 92 15 47 76 43 2 17 76 4 1 33 24 96 44 98 75 99 59 11 73 27 67 17 8 88 69 41 44 22 91 48 4 46 42 21 21 67 85 51 57 84 11 100 100 59 39 72 89 82 74 19 98 14 37 97 20 78 38 52 44 83 19 83 69 32 56 6 93 13 98 80 80 2 33 71 11 15 55 51 98 58 16 91 39 32 83 58 77 79 88 81 17 98", "output": "98" }, { "input": "100 69\n80 31 12 89 16 35 8 28 39 12 32 51 42 67 64 53 17 88 63 97 29 41 57 28 51 33 82 75 93 79 57 86 32 100 83 82 99 33 1 27 86 22 65 15 60 100 42 37 38 85 26 43 90 62 91 13 1 92 16 20 100 19 28 30 23 6 5 69 24 22 9 1 10 14 28 14 25 9 32 8 67 4 39 7 10 57 15 7 8 35 62 6 53 59 62 13 24 7 53 2", "output": "39" }, { "input": "100 2\n2 2 2 2 1 1 1 2 1 2 2 2 1 2 2 2 2 1 2 1 2 1 1 1 2 1 2 1 2 1 1 2 2 2 2 2 1 2 1 2 1 1 2 1 2 1 1 2 1 2 1 2 2 1 2 1 2 1 1 2 1 2 2 1 1 2 2 2 1 1 2 1 1 2 2 2 1 1 1 2 2 2 1 2 1 2 1 1 1 1 1 1 1 1 1 1 1 2 2 16", "output": "99" }, { "input": "100 3\n86 53 82 40 2 20 59 2 46 63 75 49 24 81 70 22 9 9 93 72 47 23 29 77 78 51 17 59 19 71 35 3 20 60 70 9 11 96 71 94 91 19 88 93 50 49 72 19 53 30 38 67 62 71 81 86 5 26 5 32 63 98 1 97 22 32 87 65 96 55 43 85 56 37 56 67 12 100 98 58 77 54 18 20 33 53 21 66 24 64 42 71 59 32 51 69 49 79 10 1", "output": "1" }, { "input": "13 7\n1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "13" }, { "input": "1 5\n4", "output": "1" }, { "input": "3 2\n1 4 1", "output": "2" }, { "input": "1 2\n100", "output": "0" }, { "input": "7 4\n4 2 3 4 4 2 3", "output": "7" }, { "input": "1 2\n1", "output": "1" }, { "input": "1 2\n15", "output": "0" }, { "input": "2 1\n1 1", "output": "2" }, { "input": "5 3\n3 4 3 2 1", "output": "4" }, { "input": "1 1\n2", "output": "0" }, { "input": "1 5\n1", "output": "1" }, { "input": "6 6\n7 1 1 1 1 1", "output": "5" }, { "input": "5 5\n6 5 5 5 5", "output": "4" }, { "input": "1 4\n2", "output": "1" }, { "input": "9 4\n1 2 1 2 4 2 1 2 1", "output": "9" }, { "input": "1 1\n1", "output": "1" }, { "input": "1 10\n5", "output": "1" }, { "input": "5 5\n1 1 1 1 1", "output": "5" }, { "input": "100 10\n2 5 1 10 10 2 7 7 9 4 1 8 1 1 8 4 7 9 10 5 7 9 5 6 7 2 7 5 3 2 1 82 4 80 9 8 6 1 10 7 5 7 1 5 6 7 19 4 2 4 6 2 1 8 31 6 2 2 57 42 3 2 7 1 9 5 10 8 5 4 10 8 3 5 8 7 2 7 6 5 3 3 4 10 6 7 10 8 7 10 7 2 4 6 8 10 10 2 6 4", "output": "71" }, { "input": "100 90\n17 16 5 51 17 62 24 45 49 41 90 30 19 78 67 66 59 34 28 47 42 8 33 77 90 41 61 16 86 33 43 71 90 95 23 9 56 41 24 90 31 12 77 36 90 67 47 15 92 50 79 88 42 19 21 79 86 60 41 26 47 4 70 62 44 90 82 89 84 91 54 16 90 53 29 69 21 44 18 28 88 74 56 43 12 76 10 22 34 24 27 52 28 76 90 75 5 29 50 90", "output": "63" }, { "input": "100 10\n6 4 8 4 1 9 4 8 5 2 2 5 2 6 10 2 2 5 3 5 2 3 10 5 2 9 1 1 6 1 5 9 16 42 33 49 26 31 81 27 53 63 81 90 55 97 70 51 87 21 79 62 60 91 54 95 26 26 30 61 87 79 47 11 59 34 40 82 37 40 81 2 7 1 8 4 10 7 1 10 8 7 3 5 2 8 3 3 9 2 1 1 5 7 8 7 1 10 9 8", "output": "61" }, { "input": "100 90\n45 57 52 69 17 81 85 60 59 39 55 14 87 90 90 31 41 57 35 89 74 20 53 4 33 49 71 11 46 90 71 41 71 90 63 74 51 13 99 92 99 91 100 97 93 40 93 96 100 99 100 92 98 96 78 91 91 91 91 100 94 97 95 97 96 95 17 13 45 35 54 26 2 74 6 51 20 3 73 90 90 42 66 43 86 28 84 70 37 27 90 30 55 80 6 58 57 51 10 22", "output": "72" }, { "input": "100 10\n10 2 10 10 10 10 10 10 10 7 10 10 10 10 10 10 9 10 10 10 10 10 10 10 10 7 9 10 10 10 37 10 4 10 10 10 59 5 95 10 10 10 10 39 10 10 10 10 10 10 10 5 10 10 10 10 10 10 10 10 10 10 10 10 66 10 10 10 10 10 5 10 10 10 10 10 10 44 10 10 10 10 10 10 10 10 10 10 10 7 10 10 10 10 10 10 10 10 10 2", "output": "52" }, { "input": "100 90\n57 90 90 90 90 90 90 90 81 90 3 90 39 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 92 90 90 90 90 90 90 90 90 98 90 90 90 90 90 90 90 90 90 90 90 90 90 54 90 90 90 90 90 62 90 90 91 90 90 90 90 90 90 91 90 90 90 90 90 90 90 3 90 90 90 90 90 90 90 2 90 90 90 90 90 90 90 90 90 2 90 90 90 90 90", "output": "60" }, { "input": "100 10\n10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 6 10 10 10 10 10 10 78 90 61 40 87 39 91 50 64 30 10 24 10 55 28 11 28 35 26 26 10 57 45 67 14 99 96 51 67 79 59 11 21 55 70 33 10 16 92 70 38 50 66 52 5 10 10 10 2 4 10 10 10 10 10 10 10 10 10 6 10 10 10 10 10 10 10 10 10 10 8 10 10 10 10 10", "output": "56" }, { "input": "100 90\n90 90 90 90 90 90 55 21 90 90 90 90 90 90 90 90 90 90 69 83 90 90 90 90 90 90 90 90 93 95 92 98 92 97 91 92 92 91 91 95 94 95 100 100 96 97 94 93 90 90 95 95 97 99 90 95 98 91 94 96 99 99 94 95 95 97 99 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 12 90 3 90 90 90 90 90 90 90", "output": "61" }, { "input": "100 49\n71 25 14 36 36 48 36 49 28 40 49 49 49 38 40 49 33 22 49 49 14 46 8 44 49 11 37 49 40 49 2 49 3 49 37 49 49 11 25 49 49 32 49 11 49 30 16 21 49 49 23 24 30 49 49 49 49 49 49 27 49 42 49 49 20 32 30 29 35 49 30 49 9 49 27 25 5 49 49 42 49 20 49 35 49 22 15 49 49 49 19 49 29 28 13 49 22 7 6 24", "output": "99" }, { "input": "100 50\n38 68 9 6 50 18 19 50 50 20 33 34 43 50 24 50 50 2 50 50 50 50 50 21 30 50 41 40 50 50 50 50 50 7 50 21 19 23 1 50 24 50 50 50 25 50 50 50 50 50 50 50 7 24 28 18 50 5 43 50 20 50 13 50 50 16 50 3 2 24 50 50 18 5 50 4 50 50 38 50 33 49 12 33 11 14 50 50 50 33 50 50 50 50 50 50 7 4 50 50", "output": "99" }, { "input": "100 48\n8 6 23 47 29 48 48 48 48 48 48 26 24 48 48 48 3 48 27 28 41 45 9 29 48 48 48 48 48 48 48 48 48 48 47 23 48 48 48 5 48 22 40 48 48 48 20 48 48 57 48 32 19 48 33 2 4 19 48 48 39 48 16 48 48 44 48 48 48 48 29 14 25 43 46 7 48 19 30 48 18 8 39 48 30 47 35 18 48 45 48 48 30 13 48 48 48 17 9 48", "output": "99" }, { "input": "100 57\n57 9 57 4 43 57 57 57 57 26 57 18 57 57 57 57 57 57 57 47 33 57 57 43 57 57 55 57 14 57 57 4 1 57 57 57 57 57 46 26 57 57 57 57 57 57 57 39 57 57 57 5 57 12 11 57 57 57 25 37 34 57 54 18 29 57 39 57 5 57 56 34 57 24 7 57 57 57 2 57 57 57 57 1 55 39 19 57 57 57 57 21 3 40 13 3 57 57 62 57", "output": "99" }, { "input": "100 51\n51 51 38 51 51 45 51 51 51 18 51 36 51 19 51 26 37 51 11 51 45 34 51 21 51 51 33 51 6 51 51 51 21 47 51 13 51 51 30 29 50 51 51 51 51 51 51 45 14 51 2 51 51 23 9 51 50 23 51 29 34 51 40 32 1 36 31 51 11 51 51 47 51 51 51 51 51 51 51 50 39 51 14 4 4 12 3 11 51 51 51 51 41 51 51 51 49 37 5 93", "output": "99" }, { "input": "100 50\n87 91 95 73 50 50 16 97 39 24 58 50 33 89 42 37 50 50 12 71 3 55 50 50 80 10 76 50 52 36 88 44 66 69 86 71 77 50 72 50 21 55 50 50 78 61 75 89 65 2 50 69 62 47 11 92 97 77 41 31 55 29 35 51 36 48 50 91 92 86 50 36 50 94 51 74 4 27 55 63 50 36 87 50 67 7 65 75 20 96 88 50 41 73 35 51 66 21 29 33", "output": "3" }, { "input": "100 50\n50 37 28 92 7 76 50 50 50 76 100 57 50 50 50 32 76 50 8 72 14 8 50 91 67 50 55 82 50 50 24 97 88 50 59 61 68 86 44 15 61 67 88 50 40 50 36 99 1 23 63 50 88 59 76 82 99 76 68 50 50 30 31 68 57 98 71 12 15 60 35 79 90 6 67 50 50 50 50 68 13 6 50 50 16 87 84 50 67 67 50 64 50 58 50 50 77 51 50 51", "output": "3" }, { "input": "100 50\n43 50 50 91 97 67 6 50 86 50 76 60 50 59 4 56 11 38 49 50 37 50 50 20 60 47 33 54 95 58 22 50 77 77 72 9 57 40 81 57 95 50 81 63 62 76 13 87 50 39 74 69 50 99 63 1 11 62 84 31 97 99 56 73 70 36 45 100 28 91 93 9 19 52 73 50 83 58 84 52 86 12 50 44 64 52 97 50 12 71 97 52 87 66 83 66 86 50 9 49", "output": "6" }, { "input": "88 10\n10 8 1 10 10 1 3 7 10 5 8 8 10 2 7 10 10 10 10 10 1 10 10 10 10 1 2 9 10 9 10 10 10 64 100 25 10 12 9 52 13 8 10 56 10 4 10 7 10 3 10 79 74 8 73 10 10 10 9 10 3 5 10 10 10 5 1 10 10 4 3 10 10 10 4 10 6 4 10 10 10 10 3 3 8 5 6 8", "output": "66" }, { "input": "100 50\n80 39 33 69 75 50 23 88 50 50 67 90 87 50 29 15 55 32 60 50 50 50 38 95 62 50 50 88 8 97 45 50 42 12 22 93 49 50 24 50 50 71 60 4 50 72 57 57 50 50 50 83 69 17 1 31 72 55 50 11 50 80 93 41 91 94 20 60 50 50 51 48 53 56 76 73 50 72 19 98 50 50 50 50 50 28 48 45 62 11 16 67 93 88 63 50 50 66 48 95", "output": "0" }, { "input": "100 50\n70 50 38 50 38 50 32 30 50 31 26 42 50 33 34 50 50 50 28 21 50 44 50 47 50 50 9 40 50 50 50 50 50 42 50 50 16 50 50 3 24 50 50 50 4 26 50 2 50 50 33 1 27 50 50 50 8 29 50 23 33 50 6 29 50 50 15 50 50 50 32 50 43 50 50 50 31 50 4 50 50 31 50 50 31 16 50 17 50 17 31 13 25 16 50 10 50 47 50 66", "output": "0" }, { "input": "2 8\n8 8", "output": "2" }, { "input": "1 6\n3", "output": "1" }, { "input": "1 5\n5", "output": "1" } ]

1,623,426,335

2,147,483,647

Python 3

OK

TESTS

48

62

0

n,p=map(int,input().split()) l=list(map(int,input().split())) x=0 ans=0 while x<len(l): if p>=l[x]: l.pop(x) ans+=1 else: break y=len(l)-1 while y>0: if p>=l[y]: ans+=1 l.pop(y) y-=1 else: break print(ans)

Title: Mishka and Contest Time Limit: None seconds Memory Limit: None megabytes Problem Description: Mishka started participating in a programming contest. There are $n$ problems in the contest. Mishka's problem-solving skill is equal to $k$. Mishka arranges all problems from the contest into a list. Because of his weird principles, Mishka only solves problems from one of the ends of the list. Every time, he chooses which end (left or right) he will solve the next problem from. Thus, each problem Mishka solves is either the leftmost or the rightmost problem in the list. Mishka cannot solve a problem with difficulty greater than $k$. When Mishka solves the problem, it disappears from the list, so the length of the list decreases by $1$. Mishka stops when he is unable to solve any problem from any end of the list. How many problems can Mishka solve? Input Specification: The first line of input contains two integers $n$ and $k$ ($1 \le n, k \le 100$) — the number of problems in the contest and Mishka's problem-solving skill. The second line of input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$), where $a_i$ is the difficulty of the $i$-th problem. The problems are given in order from the leftmost to the rightmost in the list. Output Specification: Print one integer — the maximum number of problems Mishka can solve. Demo Input: ['8 4\n4 2 3 1 5 1 6 4\n', '5 2\n3 1 2 1 3\n', '5 100\n12 34 55 43 21\n'] Demo Output: ['5\n', '0\n', '5\n'] Note: In the first example, Mishka can solve problems in the following order: $[4, 2, 3, 1, 5, 1, 6, 4] \rightarrow [2, 3, 1, 5, 1, 6, 4] \rightarrow [2, 3, 1, 5, 1, 6] \rightarrow [3, 1, 5, 1, 6] \rightarrow [1, 5, 1, 6] \rightarrow [5, 1, 6]$, so the number of solved problems will be equal to $5$. In the second example, Mishka can't solve any problem because the difficulties of problems from both ends are greater than $k$. In the third example, Mishka's solving skill is so amazing that he can solve all the problems.

```python n,p=map(int,input().split()) l=list(map(int,input().split())) x=0 ans=0 while x<len(l): if p>=l[x]: l.pop(x) ans+=1 else: break y=len(l)-1 while y>0: if p>=l[y]: ans+=1 l.pop(y) y-=1 else: break print(ans) ```

3

26

A

Almost Prime

PROGRAMMING

900

[ "number theory" ]

A. Almost Prime

2

256

A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and *n*, inclusive.

Input contains one integer number *n* (1<=≤<=*n*<=≤<=3000).

Output the amount of almost prime numbers between 1 and *n*, inclusive.

[ "10\n", "21\n" ]

[ "2\n", "8\n" ]

none

500

[ { "input": "10", "output": "2" }, { "input": "21", "output": "8" }, { "input": "1", "output": "0" }, { "input": "2", "output": "0" }, { "input": "4", "output": "0" }, { "input": "3", "output": "0" }, { "input": "8", "output": "1" }, { "input": "19", "output": "6" }, { "input": "40", "output": "19" }, { "input": "77", "output": "41" }, { "input": "222", "output": "125" }, { "input": "987", "output": "501" }, { "input": "1000", "output": "508" }, { "input": "2000", "output": "958" }, { "input": "3000", "output": "1375" }, { "input": "2999", "output": "1375" }, { "input": "2998", "output": "1375" }, { "input": "2997", "output": "1374" }, { "input": "1429", "output": "706" }, { "input": "1673", "output": "808" }, { "input": "1500", "output": "732" }, { "input": "500", "output": "266" }, { "input": "856", "output": "439" } ]

1,670,484,777

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

122

307,200

N = 100001 primes = [1]*N def sieve(): primes[1] = 0 for p in range(2, int(N*0.5)+1): if primes[p] == 1: for i in range(2*p, N, p): primes[i] = 0 def almostPrimes(n): res = 0 # 6 is First almost primes no for i in range(6, n+1): count = 0 for j in range(2, int(i**0.5)+1): if (i % j) == 0: if (j * j) == i: if primes[j] == 1: count += 1 else: if primes[j] == 1: count += 1 if primes[i // j] == 1: count += 1 if count == 2: res += 1 return res sieve() T = int(input()) for case in range(T): n = int(input()) x = almostPrimes(n) print(x)

Title: Almost Prime Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and *n*, inclusive. Input Specification: Input contains one integer number *n* (1<=≤<=*n*<=≤<=3000). Output Specification: Output the amount of almost prime numbers between 1 and *n*, inclusive. Demo Input: ['10\n', '21\n'] Demo Output: ['2\n', '8\n'] Note: none

```python N = 100001 primes = [1]*N def sieve(): primes[1] = 0 for p in range(2, int(N*0.5)+1): if primes[p] == 1: for i in range(2*p, N, p): primes[i] = 0 def almostPrimes(n): res = 0 # 6 is First almost primes no for i in range(6, n+1): count = 0 for j in range(2, int(i**0.5)+1): if (i % j) == 0: if (j * j) == i: if primes[j] == 1: count += 1 else: if primes[j] == 1: count += 1 if primes[i // j] == 1: count += 1 if count == 2: res += 1 return res sieve() T = int(input()) for case in range(T): n = int(input()) x = almostPrimes(n) print(x) ```

-1

884

A

Book Reading

PROGRAMMING

800

[ "implementation" ]

null

Recently Luba bought a very interesting book. She knows that it will take *t* seconds to read the book. Luba wants to finish reading as fast as she can. But she has some work to do in each of *n* next days. The number of seconds that Luba has to spend working during *i*-th day is *a**i*. If some free time remains, she can spend it on reading. Help Luba to determine the minimum number of day when she finishes reading. It is guaranteed that the answer doesn't exceed *n*. Remember that there are 86400 seconds in a day.

The first line contains two integers *n* and *t* (1<=≤<=*n*<=≤<=100, 1<=≤<=*t*<=≤<=106) — the number of days and the time required to read the book. The second line contains *n* integers *a**i* (0<=≤<=*a**i*<=≤<=86400) — the time Luba has to spend on her work during *i*-th day.

Print the minimum day Luba can finish reading the book. It is guaranteed that answer doesn't exceed *n*.

[ "2 2\n86400 86398\n", "2 86400\n0 86400\n" ]

[ "2\n", "1\n" ]

none

0

[ { "input": "2 2\n86400 86398", "output": "2" }, { "input": "2 86400\n0 86400", "output": "1" }, { "input": "2 86400\n1 86399", "output": "2" }, { "input": "100 1000000\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "output": "12" }, { "input": "1 1\n86399", "output": "1" }, { "input": "6 1200\n86400 86400 86000 86000 86000 86400", "output": "5" }, { "input": "6 1200\n86400 86400 86000 86000 86001 86399", "output": "6" }, { "input": "4 172799\n1 1 86400 0", "output": "4" }, { "input": "4 172799\n0 86400 86399 0", "output": "4" }, { "input": "6 1\n1 1 86400 1 86399 1", "output": "1" }, { "input": "4 1\n86400 86399 86400 86400", "output": "2" }, { "input": "4 1\n86400 86400 0 86400", "output": "3" } ]

1,510,438,340

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

46

0

input_file = open("input.txt", "r") output_file = open("outpute.txt", "w") secInDay = 86400 n = input_file.readline().split() t = int(n[-1]) n = int(n[0]) #print(n, t) a = input_file.readline().split() i = -1 while t > 0: i += 1 t -= secInDay - int(a[i]) print(i+1) output_file.write(str(i))

Title: Book Reading Time Limit: None seconds Memory Limit: None megabytes Problem Description: Recently Luba bought a very interesting book. She knows that it will take *t* seconds to read the book. Luba wants to finish reading as fast as she can. But she has some work to do in each of *n* next days. The number of seconds that Luba has to spend working during *i*-th day is *a**i*. If some free time remains, she can spend it on reading. Help Luba to determine the minimum number of day when she finishes reading. It is guaranteed that the answer doesn't exceed *n*. Remember that there are 86400 seconds in a day. Input Specification: The first line contains two integers *n* and *t* (1<=≤<=*n*<=≤<=100, 1<=≤<=*t*<=≤<=106) — the number of days and the time required to read the book. The second line contains *n* integers *a**i* (0<=≤<=*a**i*<=≤<=86400) — the time Luba has to spend on her work during *i*-th day. Output Specification: Print the minimum day Luba can finish reading the book. It is guaranteed that answer doesn't exceed *n*. Demo Input: ['2 2\n86400 86398\n', '2 86400\n0 86400\n'] Demo Output: ['2\n', '1\n'] Note: none

```python input_file = open("input.txt", "r") output_file = open("outpute.txt", "w") secInDay = 86400 n = input_file.readline().split() t = int(n[-1]) n = int(n[0]) #print(n, t) a = input_file.readline().split() i = -1 while t > 0: i += 1 t -= secInDay - int(a[i]) print(i+1) output_file.write(str(i)) ```

-1

155

A

I_love_\%username\%

PROGRAMMING

800

[ "brute force" ]

null

Vasya adores sport programming. He can't write programs but he loves to watch the contests' progress. Vasya even has a favorite coder and Vasya pays special attention to him. One day Vasya decided to collect the results of all contests where his favorite coder participated and track the progress of his coolness. For each contest where this coder participated, he wrote out a single non-negative number — the number of points his favorite coder earned in the contest. Vasya wrote out the points for the contest in the order, in which the contests run (naturally, no two contests ran simultaneously). Vasya considers a coder's performance in a contest amazing in two situations: he can break either his best or his worst performance record. First, it is amazing if during the contest the coder earns strictly more points that he earned on each past contest. Second, it is amazing if during the contest the coder earns strictly less points that he earned on each past contest. A coder's first contest isn't considered amazing. Now he wants to count the number of amazing performances the coder had throughout his whole history of participating in contests. But the list of earned points turned out long and Vasya can't code... That's why he asks you to help him.

The first line contains the single integer *n* (1<=≤<=*n*<=≤<=1000) — the number of contests where the coder participated. The next line contains *n* space-separated non-negative integer numbers — they are the points which the coder has earned. The points are given in the chronological order. All points do not exceed 10000.

Print the single number — the number of amazing performances the coder has had during his whole history of participating in the contests.

[ "5\n100 50 200 150 200\n", "10\n4664 6496 5814 7010 5762 5736 6944 4850 3698 7242\n" ]

[ "2\n", "4\n" ]

In the first sample the performances number 2 and 3 are amazing. In the second sample the performances number 2, 4, 9 and 10 are amazing.

500

[ { "input": "5\n100 50 200 150 200", "output": "2" }, { "input": "10\n4664 6496 5814 7010 5762 5736 6944 4850 3698 7242", "output": "4" }, { "input": "1\n6", "output": "0" }, { "input": "2\n2 1", "output": "1" }, { "input": "5\n100 36 53 7 81", "output": "2" }, { "input": "5\n7 36 53 81 100", "output": "4" }, { "input": "5\n100 81 53 36 7", "output": "4" }, { "input": "10\n8 6 3 4 9 10 7 7 1 3", "output": "5" }, { "input": "10\n1627 1675 1488 1390 1812 1137 1746 1324 1952 1862", "output": "6" }, { "input": "10\n1 3 3 4 6 7 7 8 9 10", "output": "7" }, { "input": "10\n1952 1862 1812 1746 1675 1627 1488 1390 1324 1137", "output": "9" }, { "input": "25\n1448 4549 2310 2725 2091 3509 1565 2475 2232 3989 4231 779 2967 2702 608 3739 721 1552 2767 530 3114 665 1940 48 4198", "output": "5" }, { "input": "33\n1097 1132 1091 1104 1049 1038 1023 1080 1104 1029 1035 1061 1049 1060 1088 1106 1105 1087 1063 1076 1054 1103 1047 1041 1028 1120 1126 1063 1117 1110 1044 1093 1101", "output": "5" }, { "input": "34\n821 5536 2491 6074 7216 9885 764 1603 778 8736 8987 771 617 1587 8943 7922 439 7367 4115 8886 7878 6899 8811 5752 3184 3401 9760 9400 8995 4681 1323 6637 6554 6498", "output": "7" }, { "input": "68\n6764 6877 6950 6768 6839 6755 6726 6778 6699 6805 6777 6985 6821 6801 6791 6805 6940 6761 6677 6999 6911 6699 6959 6933 6903 6843 6972 6717 6997 6756 6789 6668 6735 6852 6735 6880 6723 6834 6810 6694 6780 6679 6698 6857 6826 6896 6979 6968 6957 6988 6960 6700 6919 6892 6984 6685 6813 6678 6715 6857 6976 6902 6780 6686 6777 6686 6842 6679", "output": "9" }, { "input": "60\n9000 9014 9034 9081 9131 9162 9174 9199 9202 9220 9221 9223 9229 9235 9251 9260 9268 9269 9270 9298 9307 9309 9313 9323 9386 9399 9407 9495 9497 9529 9531 9544 9614 9615 9627 9627 9643 9654 9656 9657 9685 9699 9701 9736 9745 9758 9799 9827 9843 9845 9854 9854 9885 9891 9896 9913 9942 9963 9986 9992", "output": "57" }, { "input": "100\n7 61 12 52 41 16 34 99 30 44 48 89 31 54 21 1 48 52 61 15 35 87 21 76 64 92 44 81 16 93 84 92 32 15 68 76 53 39 26 4 11 26 7 4 99 99 61 65 55 85 65 67 47 39 2 74 63 49 98 87 5 94 22 30 25 42 31 84 49 23 89 60 16 26 92 27 9 57 75 61 94 35 83 47 99 100 63 24 91 88 79 10 15 45 22 64 3 11 89 83", "output": "4" }, { "input": "100\n9999 9999 9999 9998 9998 9998 9997 9996 9996 9995 9993 9993 9991 9990 9989 9986 9984 9984 9983 9981 9981 9980 9980 9980 9979 9977 9977 9977 9977 9977 9976 9976 9975 9975 9973 9972 9972 9972 9972 9971 9969 9969 9969 9968 9967 9965 9962 9962 9962 9962 9960 9958 9958 9955 9954 9954 9954 9954 9950 9949 9949 9947 9943 9943 9940 9940 9939 9937 9937 9937 9936 9935 9932 9932 9931 9929 9927 9927 9926 9923 9919 9919 9918 9918 9918 9917 9917 9916 9916 9915 9914 9911 9910 9907 9907 9906 9905 9905 9904 9901", "output": "57" }, { "input": "100\n158 159 157 156 155 154 160 153 161 152 162 163 151 164 150 165 149 148 147 166 146 167 145 144 143 142 168 141 169 170 140 139 138 137 171 136 135 134 172 173 174 133 175 132 177 178 131 179 180 130 129 181 128 127 182 126 183 125 124 184 123 122 121 120 119 118 117 185 186 187 188 189 116 190 115 191 192 193 114 113 112 111 110 109 108 194 195 107 106 105 196 197 104 198 199 103 102 200 101 100", "output": "99" }, { "input": "2\n0 10000", "output": "1" }, { "input": "2\n5 5", "output": "0" }, { "input": "2\n1 1", "output": "0" }, { "input": "2\n10 10", "output": "0" }, { "input": "1\n0", "output": "0" } ]

1,689,116,888

2,147,483,647

Python 3

OK

TESTS

37

92

0

n = int(input()) l = list(map(int, input().split())) worst, best, am= l[0], l[0], 0 for c in l: if c > best: best = c; am += 1 elif c < worst: worst = c; am += 1 print(am)

Title: I_love_\%username\% Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vasya adores sport programming. He can't write programs but he loves to watch the contests' progress. Vasya even has a favorite coder and Vasya pays special attention to him. One day Vasya decided to collect the results of all contests where his favorite coder participated and track the progress of his coolness. For each contest where this coder participated, he wrote out a single non-negative number — the number of points his favorite coder earned in the contest. Vasya wrote out the points for the contest in the order, in which the contests run (naturally, no two contests ran simultaneously). Vasya considers a coder's performance in a contest amazing in two situations: he can break either his best or his worst performance record. First, it is amazing if during the contest the coder earns strictly more points that he earned on each past contest. Second, it is amazing if during the contest the coder earns strictly less points that he earned on each past contest. A coder's first contest isn't considered amazing. Now he wants to count the number of amazing performances the coder had throughout his whole history of participating in contests. But the list of earned points turned out long and Vasya can't code... That's why he asks you to help him. Input Specification: The first line contains the single integer *n* (1<=≤<=*n*<=≤<=1000) — the number of contests where the coder participated. The next line contains *n* space-separated non-negative integer numbers — they are the points which the coder has earned. The points are given in the chronological order. All points do not exceed 10000. Output Specification: Print the single number — the number of amazing performances the coder has had during his whole history of participating in the contests. Demo Input: ['5\n100 50 200 150 200\n', '10\n4664 6496 5814 7010 5762 5736 6944 4850 3698 7242\n'] Demo Output: ['2\n', '4\n'] Note: In the first sample the performances number 2 and 3 are amazing. In the second sample the performances number 2, 4, 9 and 10 are amazing.

```python n = int(input()) l = list(map(int, input().split())) worst, best, am= l[0], l[0], 0 for c in l: if c > best: best = c; am += 1 elif c < worst: worst = c; am += 1 print(am) ```

3

893

C

Rumor

PROGRAMMING

1,300

[ "dfs and similar", "graphs", "greedy" ]

null

Vova promised himself that he would never play computer games... But recently Firestorm — a well-known game developing company — published their newest game, World of Farcraft, and it became really popular. Of course, Vova started playing it. Now he tries to solve a quest. The task is to come to a settlement named Overcity and spread a rumor in it. Vova knows that there are *n* characters in Overcity. Some characters are friends to each other, and they share information they got. Also Vova knows that he can bribe each character so he or she starts spreading the rumor; *i*-th character wants *c**i* gold in exchange for spreading the rumor. When a character hears the rumor, he tells it to all his friends, and they start spreading the rumor to their friends (for free), and so on. The quest is finished when all *n* characters know the rumor. What is the minimum amount of gold Vova needs to spend in order to finish the quest? Take a look at the notes if you think you haven't understood the problem completely.

The first line contains two integer numbers *n* and *m* (1<=≤<=*n*<=≤<=105,<=0<=≤<=*m*<=≤<=105) — the number of characters in Overcity and the number of pairs of friends. The second line contains *n* integer numbers *c**i* (0<=≤<=*c**i*<=≤<=109) — the amount of gold *i*-th character asks to start spreading the rumor. Then *m* lines follow, each containing a pair of numbers (*x**i*,<=*y**i*) which represent that characters *x**i* and *y**i* are friends (1<=≤<=*x**i*,<=*y**i*<=≤<=*n*, *x**i*<=≠<=*y**i*). It is guaranteed that each pair is listed at most once.

Print one number — the minimum amount of gold Vova has to spend in order to finish the quest.

[ "5 2\n2 5 3 4 8\n1 4\n4 5\n", "10 0\n1 2 3 4 5 6 7 8 9 10\n", "10 5\n1 6 2 7 3 8 4 9 5 10\n1 2\n3 4\n5 6\n7 8\n9 10\n" ]

[ "10\n", "55\n", "15\n" ]

In the first example the best decision is to bribe the first character (he will spread the rumor to fourth character, and the fourth one will spread it to fifth). Also Vova has to bribe the second and the third characters, so they know the rumor. In the second example Vova has to bribe everyone. In the third example the optimal decision is to bribe the first, the third, the fifth, the seventh and the ninth characters.

0

[ { "input": "5 2\n2 5 3 4 8\n1 4\n4 5", "output": "10" }, { "input": "10 0\n1 2 3 4 5 6 7 8 9 10", "output": "55" }, { "input": "10 5\n1 6 2 7 3 8 4 9 5 10\n1 2\n3 4\n5 6\n7 8\n9 10", "output": "15" }, { "input": "1 0\n0", "output": "0" }, { "input": "1 0\n1000000000", "output": "1000000000" }, { "input": "2 0\n0 0", "output": "0" }, { "input": "2 0\n1000000000 0", "output": "1000000000" }, { "input": "2 0\n0 1000000000", "output": "1000000000" }, { "input": "2 0\n1000000000 1000000000", "output": "2000000000" }, { "input": "2 1\n0 0\n1 2", "output": "0" } ]

1,599,966,273

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

3

389

11,366,400

def dfs(visited,sv,arr,A): visited[sv]=True A.append(arr[sv]) for i in graph[sv]: if not visited[i]: dfs(visited,i,arr,A) def solve(graph,arr,n): visited=[False for _ in range(n)] ans=0 for i in range(n): if not visited[i]: A=[] dfs(visited,i,arr,A) if A: ans+=min(A) return ans n,m=map(int,input().split()) arr=list(map(int,input().split())) if m==0: print(sum(arr)) else: graph=[[] for _ in range(n)] for i in range(m): a,b=map(int,input().split()) a-=1 b-=1 graph[a].append(b) graph[b].append(a) print(solve(graph,arr,n))

Title: Rumor Time Limit: None seconds Memory Limit: None megabytes Problem Description: Vova promised himself that he would never play computer games... But recently Firestorm — a well-known game developing company — published their newest game, World of Farcraft, and it became really popular. Of course, Vova started playing it. Now he tries to solve a quest. The task is to come to a settlement named Overcity and spread a rumor in it. Vova knows that there are *n* characters in Overcity. Some characters are friends to each other, and they share information they got. Also Vova knows that he can bribe each character so he or she starts spreading the rumor; *i*-th character wants *c**i* gold in exchange for spreading the rumor. When a character hears the rumor, he tells it to all his friends, and they start spreading the rumor to their friends (for free), and so on. The quest is finished when all *n* characters know the rumor. What is the minimum amount of gold Vova needs to spend in order to finish the quest? Take a look at the notes if you think you haven't understood the problem completely. Input Specification: The first line contains two integer numbers *n* and *m* (1<=≤<=*n*<=≤<=105,<=0<=≤<=*m*<=≤<=105) — the number of characters in Overcity and the number of pairs of friends. The second line contains *n* integer numbers *c**i* (0<=≤<=*c**i*<=≤<=109) — the amount of gold *i*-th character asks to start spreading the rumor. Then *m* lines follow, each containing a pair of numbers (*x**i*,<=*y**i*) which represent that characters *x**i* and *y**i* are friends (1<=≤<=*x**i*,<=*y**i*<=≤<=*n*, *x**i*<=≠<=*y**i*). It is guaranteed that each pair is listed at most once. Output Specification: Print one number — the minimum amount of gold Vova has to spend in order to finish the quest. Demo Input: ['5 2\n2 5 3 4 8\n1 4\n4 5\n', '10 0\n1 2 3 4 5 6 7 8 9 10\n', '10 5\n1 6 2 7 3 8 4 9 5 10\n1 2\n3 4\n5 6\n7 8\n9 10\n'] Demo Output: ['10\n', '55\n', '15\n'] Note: In the first example the best decision is to bribe the first character (he will spread the rumor to fourth character, and the fourth one will spread it to fifth). Also Vova has to bribe the second and the third characters, so they know the rumor. In the second example Vova has to bribe everyone. In the third example the optimal decision is to bribe the first, the third, the fifth, the seventh and the ninth characters.

```python def dfs(visited,sv,arr,A): visited[sv]=True A.append(arr[sv]) for i in graph[sv]: if not visited[i]: dfs(visited,i,arr,A) def solve(graph,arr,n): visited=[False for _ in range(n)] ans=0 for i in range(n): if not visited[i]: A=[] dfs(visited,i,arr,A) if A: ans+=min(A) return ans n,m=map(int,input().split()) arr=list(map(int,input().split())) if m==0: print(sum(arr)) else: graph=[[] for _ in range(n)] for i in range(m): a,b=map(int,input().split()) a-=1 b-=1 graph[a].append(b) graph[b].append(a) print(solve(graph,arr,n)) ```

-1

932

A

Palindromic Supersequence

PROGRAMMING

800

[ "constructive algorithms" ]

null

You are given a string *A*. Find a string *B*, where *B* is a palindrome and *A* is a subsequence of *B*. A subsequence of a string is a string that can be derived from it by deleting some (not necessarily consecutive) characters without changing the order of the remaining characters. For example, "cotst" is a subsequence of "contest". A palindrome is a string that reads the same forward or backward. The length of string *B* should be at most 104. It is guaranteed that there always exists such string. You do not need to find the shortest answer, the only restriction is that the length of string *B* should not exceed 104.

First line contains a string *A* (1<=≤<=|*A*|<=≤<=103) consisting of lowercase Latin letters, where |*A*| is a length of *A*.

Output single line containing *B* consisting of only lowercase Latin letters. You do not need to find the shortest answer, the only restriction is that the length of string *B* should not exceed 104. If there are many possible *B*, print any of them.

[ "aba\n", "ab\n" ]

[ "aba", "aabaa" ]

In the first example, "aba" is a subsequence of "aba" which is a palindrome. In the second example, "ab" is a subsequence of "aabaa" which is a palindrome.

500

[ { "input": "aba", "output": "abaaba" }, { "input": "ab", "output": "abba" }, { "input": "krnyoixirslfszfqivgkaflgkctvbvksipwomqxlyqxhlbceuhbjbfnhofcgpgwdseffycthmlpcqejgskwjkbkbbmifnurnwyhevsoqzmtvzgfiqajfrgyuzxnrtxectcnlyoisbglpdbjbslxlpoymrcxmdtqhcnlvtqdwftuzgbdxsyscwbrguostbelnvtaqdmkmihmoxqtqlxvlsssisvqvvzotoyqryuyqwoknnqcqggysrqpkrccvyhxsjmhoqoyocwcriplarjoyiqrmmpmueqbsbljddwrumauczfziodpudheexalbwpiypmdjlmwtgdrzhpxneofhqzjdmurgvmrwdotuwyknlrbvuvtnhiouvqitgyfgfieonbaapyhwpcrmehxcpkijzfiayfvoxkpa", "output": "krnyoixirslfszfqivgkaflgkctvbvksipwomqxlyqxhlbceuhbjbfnhofcgpgwdseffycthmlpcqejgskwjkbkbbmifnurnwyhevsoqzmtvzgfiqajfrgyuzxnrtxectcnlyoisbglpdbjbslxlpoymrcxmdtqhcnlvtqdwftuzgbdxsyscwbrguostbelnvtaqdmkmihmoxqtqlxvlsssisvqvvzotoyqryuyqwoknnqcqggysrqpkrccvyhxsjmhoqoyocwcriplarjoyiqrmmpmueqbsbljddwrumauczfziodpudheexalbwpiypmdjlmwtgdrzhpxneofhqzjdmurgvmrwdotuwyknlrbvuvtnhiouvqitgyfgfieonbaapyhwpcrmehxcpkijzfiayfvoxkpaapkxovfyaifzjikpcxhemrcpwhypaabnoeifgfygtiqvuoihntvuvbrlnkywutodwrmvgrumdjzqhfoenxphzrdgtwmljdm..." }, { "input": "mgrfmzxqpejcixxppqgvuawutgrmezjkteofjbnrvzzkvjtacfxjjokisavsgrslryxfqgrmdsqwptajbqzvethuljbdatxghfzqrwvfgakwmoawlzqjypmhllbbuuhbpriqsnibywlgjlxowyzagrfnqafvcqwktkcjwejevzbnxhsfmwojshcdypnvbuhhuzqmgovmvgwiizatoxgblyudipahfbkewmuneoqhjmbpdtwnznblwvtjrniwlbyblhppndspojrouffazpoxtqdfpjuhitvijrohavpqatofxwmksvjcvhdecxwwmosqiczjpkfafqlboxosnjgzgdraehzdltthemeusxhiiimrdrugabnxwsygsktkcslhjebfexucsyvlwrptebkjhefsvfrmcqqdlanbetrgzwylizmrystvpgrkhlicfadco", "output": "mgrfmzxqpejcixxppqgvuawutgrmezjkteofjbnrvzzkvjtacfxjjokisavsgrslryxfqgrmdsqwptajbqzvethuljbdatxghfzqrwvfgakwmoawlzqjypmhllbbuuhbpriqsnibywlgjlxowyzagrfnqafvcqwktkcjwejevzbnxhsfmwojshcdypnvbuhhuzqmgovmvgwiizatoxgblyudipahfbkewmuneoqhjmbpdtwnznblwvtjrniwlbyblhppndspojrouffazpoxtqdfpjuhitvijrohavpqatofxwmksvjcvhdecxwwmosqiczjpkfafqlboxosnjgzgdraehzdltthemeusxhiiimrdrugabnxwsygsktkcslhjebfexucsyvlwrptebkjhefsvfrmcqqdlanbetrgzwylizmrystvpgrkhlicfadcoocdafcilhkrgpvtsyrmzilywzgrtebnaldqqcmrfvsfehjkbetprwlvyscuxef..." }, { "input": "hdmasfcjuigrwjchmjslmpynewnzpphmudzcbxzdexjuhktdtcoibzvevsmwaxakrtdfoivkvoooypyemiidadquqepxwqkesdnakxkbzrcjkgvwwxtqxvfpxcwitljyehldgsjytmekimkkndjvnzqtjykiymkmdzpwakxdtkzcqcatlevppgfhyykgmipuodjrnfjzhcmjdbzvhywprbwdcfxiffpzbjbmbyijkqnosslqbfvvicxvoeuzruraetglthgourzhfpnubzvblfzmmbgepjjyshchthulxar", "output": "hdmasfcjuigrwjchmjslmpynewnzpphmudzcbxzdexjuhktdtcoibzvevsmwaxakrtdfoivkvoooypyemiidadquqepxwqkesdnakxkbzrcjkgvwwxtqxvfpxcwitljyehldgsjytmekimkkndjvnzqtjykiymkmdzpwakxdtkzcqcatlevppgfhyykgmipuodjrnfjzhcmjdbzvhywprbwdcfxiffpzbjbmbyijkqnosslqbfvvicxvoeuzruraetglthgourzhfpnubzvblfzmmbgepjjyshchthulxarraxluhthchsyjjpegbmmzflbvzbunpfhzruoghtlgtearurzueovxcivvfbqlssonqkjiybmbjbzpffixfcdwbrpwyhvzbdjmchzjfnrjdoupimgkyyhfgppveltacqczktdxkawpzdmkmyikyjtqznvjdnkkmikemtyjsgdlheyjltiwcxpfvxqtxwwvgkjcrzbkxkandsekqwxpequ..." }, { "input": "fggbyzobbmxtwdajawqdywnppflkkmtxzjvxopqvliwdwhzepcuiwelhbuotlkvesexnwkytonfrpqcxzzqzdvsmbsjcxxeugavekozfjlolrtqgwzqxsfgrnvrgfrqpixhsskbpzghndesvwptpvvkasfalzsetopervpwzmkgpcexqnvtnoulprwnowmsorscecvvvrjfwumcjqyrounqsgdruxttvtmrkivtxauhosokdiahsyrftzsgvgyveqwkzhqstbgywrvmsgfcfyuxpphvmyydzpohgdicoxbtjnsbyhoidnkrialowvlvmjpxcfeygqzphmbcjkupojsmmuqlydixbaluwezvnfasjfxilbyllwyipsmovdzosuwotcxerzcfuvxprtziseshjfcosalyqglpotxvxaanpocypsiyazsejjoximnbvqucftuvdksaxutvjeunodbipsumlaymjnzljurefjg", "output": "fggbyzobbmxtwdajawqdywnppflkkmtxzjvxopqvliwdwhzepcuiwelhbuotlkvesexnwkytonfrpqcxzzqzdvsmbsjcxxeugavekozfjlolrtqgwzqxsfgrnvrgfrqpixhsskbpzghndesvwptpvvkasfalzsetopervpwzmkgpcexqnvtnoulprwnowmsorscecvvvrjfwumcjqyrounqsgdruxttvtmrkivtxauhosokdiahsyrftzsgvgyveqwkzhqstbgywrvmsgfcfyuxpphvmyydzpohgdicoxbtjnsbyhoidnkrialowvlvmjpxcfeygqzphmbcjkupojsmmuqlydixbaluwezvnfasjfxilbyllwyipsmovdzosuwotcxerzcfuvxprtziseshjfcosalyqglpotxvxaanpocypsiyazsejjoximnbvqucftuvdksaxutvjeunodbipsumlaymjnzljurefjggjferujlznjmyalmuspib..." }, { "input": "qyyxqkbxsvfnjzttdqmpzinbdgayllxpfrpopwciejjjzadguurnnhvixgueukugkkjyghxknedojvmdrskswiotgatsajowionuiumuhyggjuoympuxyfahwftwufvocdguxmxabbxnfviscxtilzzauizsgugwcqtbqgoosefhkumhodwpgolfdkbuiwlzjydonwbgyzzrjwxnceltqgqelrrljmzdbftmaogiuosaqhngmdzxzlmyrwefzhqawmkdckfnyyjgdjgadtfjvrkdwysqofcgyqrnyzutycvspzbjmmesobvhshtqlrytztyieknnkporrbcmlopgtknlmsstzkigreqwgsvagmvbrvwypoxttmzzsgm", "output": "qyyxqkbxsvfnjzttdqmpzinbdgayllxpfrpopwciejjjzadguurnnhvixgueukugkkjyghxknedojvmdrskswiotgatsajowionuiumuhyggjuoympuxyfahwftwufvocdguxmxabbxnfviscxtilzzauizsgugwcqtbqgoosefhkumhodwpgolfdkbuiwlzjydonwbgyzzrjwxnceltqgqelrrljmzdbftmaogiuosaqhngmdzxzlmyrwefzhqawmkdckfnyyjgdjgadtfjvrkdwysqofcgyqrnyzutycvspzbjmmesobvhshtqlrytztyieknnkporrbcmlopgtknlmsstzkigreqwgsvagmvbrvwypoxttmzzsgmmgszzmttxopywvrbvmgavsgwqergikztssmlnktgpolmcbrropknnkeiytztyrlqthshvbosemmjbzpsvcytuzynrqygcfoqsywdkrvjftdagjdgjyynfkcdkmwaqhzfewry..." }, { "input": "scvlhflaqvniyiyofonowwcuqajuwscdrzhbvasymvqfnthzvtjcfuaftrbjghhvslcohwpxkggrbtatjtgehuqtorwinwvrtdldyoeeozxwippuahgkuehvsmyqtodqvlufqqmqautaqirvwzvtodzxtgxiinubhrbeoiybidutrqamsdnasctxatzkvkjkrmavdravnsxyngjlugwftmhmcvvxdbfndurrbmcpuoigjpssqcortmqoqttrabhoqvopjkxvpbqdqsilvlplhgqazauyvnodsxtwnomlinjpozwhrgrkqwmlwcwdkxjxjftexiavwrejvdjcfptterblxysjcheesyqsbgdrzjxbfjqgjgmvccqcyj", "output": "scvlhflaqvniyiyofonowwcuqajuwscdrzhbvasymvqfnthzvtjcfuaftrbjghhvslcohwpxkggrbtatjtgehuqtorwinwvrtdldyoeeozxwippuahgkuehvsmyqtodqvlufqqmqautaqirvwzvtodzxtgxiinubhrbeoiybidutrqamsdnasctxatzkvkjkrmavdravnsxyngjlugwftmhmcvvxdbfndurrbmcpuoigjpssqcortmqoqttrabhoqvopjkxvpbqdqsilvlplhgqazauyvnodsxtwnomlinjpozwhrgrkqwmlwcwdkxjxjftexiavwrejvdjcfptterblxysjcheesyqsbgdrzjxbfjqgjgmvccqcyjjycqccvmgjgqjfbxjzrdgbsqyseehcjsyxlbrettpfcjdvjerwvaixetfjxjxkdwcwlmwqkrgrhwzopjnilmonwtxsdonvyuazaqghlplvlisqdqbpvxkjpovqohbarttqoqm..." }, { "input": "oohkqxxtvxzmvfjjxyjwlbqmeqwwlienzkdbhswgfbkhfygltsucdijozwaiewpixapyazfztksjeoqjugjfhdbqzuezbuajfvvffkwprroyivfoocvslejffgxuiofisenroxoeixmdbzonmreikpflciwsbafrdqfvdfojgoziiibqhwwsvhnzmptgirqqulkgmyzrfekzqqujmdumxkudsgexisupedisgmdgebvlvrpyfrbrqjknrxyzfpwmsxjxismgd", "output": "oohkqxxtvxzmvfjjxyjwlbqmeqwwlienzkdbhswgfbkhfygltsucdijozwaiewpixapyazfztksjeoqjugjfhdbqzuezbuajfvvffkwprroyivfoocvslejffgxuiofisenroxoeixmdbzonmreikpflciwsbafrdqfvdfojgoziiibqhwwsvhnzmptgirqqulkgmyzrfekzqqujmdumxkudsgexisupedisgmdgebvlvrpyfrbrqjknrxyzfpwmsxjxismgddgmsixjxsmwpfzyxrnkjqrbrfyprvlvbegdmgsidepusixegsdukxmudmjuqqzkefrzymgkluqqrigtpmznhvswwhqbiiizogjofdvfqdrfabswiclfpkiermnozbdmxieoxornesifoiuxgffjelsvcoofviyorrpwkffvvfjaubzeuzqbdhfjgujqoejsktzfzaypaxipweiawzojidcustlgyfhkbfgwshbdkzneilwwqemqblw..." }, { "input": "gilhoixzjgidfanqrmekjelnvicpuujlpxittgadgrhqallnkjlemwazntwfywjnrxdkgrnczlwzjyeyfktduzdjnivcldjjarfzmmdbyytvipbbnjqolfnlqjpidotxxfobgtgpvjmpddcyddwdcjsxxumuoyznhpvpqccgqnuouzojntanfwctthcgynrukcvshsuuqrxfdvqqggaatwytikkitywtaaggqqvdfxrquushsvckurnygchttcwfnatnjozuounqgccqpvphnzyoumuxxsjcdwddycddpmjvpgtgbofxxtodipjqlnfloqjnbbpivtyybdmmzfrajjdlcvinjdzudtkfyeyjzwlzcnrgkdxrnjwyfwtnzawmeljknllaqhrgdagttixpljuupcivnlejkemrqnafdigjzxiohlig", "output": "gilhoixzjgidfanqrmekjelnvicpuujlpxittgadgrhqallnkjlemwazntwfywjnrxdkgrnczlwzjyeyfktduzdjnivcldjjarfzmmdbyytvipbbnjqolfnlqjpidotxxfobgtgpvjmpddcyddwdcjsxxumuoyznhpvpqccgqnuouzojntanfwctthcgynrukcvshsuuqrxfdvqqggaatwytikkitywtaaggqqvdfxrquushsvckurnygchttcwfnatnjozuounqgccqpvphnzyoumuxxsjcdwddycddpmjvpgtgbofxxtodipjqlnfloqjnbbpivtyybdmmzfrajjdlcvinjdzudtkfyeyjzwlzcnrgkdxrnjwyfwtnzawmeljknllaqhrgdagttixpljuupcivnlejkemrqnafdigjzxiohliggilhoixzjgidfanqrmekjelnvicpuujlpxittgadgrhqallnkjlemwazntwfywjnrxdkgrnczlw..." }, { "input": "abcab", "output": "abcabbacba" }, { "input": "baaaaaaa", "output": "baaaaaaaaaaaaaab" }, { "input": "baaaaaa", "output": "baaaaaaaaaaaab" }, { "input": "baaaaaaaaa", "output": "baaaaaaaaaaaaaaaaaab" }, { "input": "baaaaaaaa", "output": "baaaaaaaaaaaaaaaab" } ]

1,518,706,265

965

Python 3

OK

TESTS

48

62

5,632,000

def pal(s): if(s==s[::-1]): return 1; else: return 0 k=input() if(pal(k)==1): print(k) else: print(k+k[::-1])

Title: Palindromic Supersequence Time Limit: None seconds Memory Limit: None megabytes Problem Description: You are given a string *A*. Find a string *B*, where *B* is a palindrome and *A* is a subsequence of *B*. A subsequence of a string is a string that can be derived from it by deleting some (not necessarily consecutive) characters without changing the order of the remaining characters. For example, "cotst" is a subsequence of "contest". A palindrome is a string that reads the same forward or backward. The length of string *B* should be at most 104. It is guaranteed that there always exists such string. You do not need to find the shortest answer, the only restriction is that the length of string *B* should not exceed 104. Input Specification: First line contains a string *A* (1<=≤<=|*A*|<=≤<=103) consisting of lowercase Latin letters, where |*A*| is a length of *A*. Output Specification: Output single line containing *B* consisting of only lowercase Latin letters. You do not need to find the shortest answer, the only restriction is that the length of string *B* should not exceed 104. If there are many possible *B*, print any of them. Demo Input: ['aba\n', 'ab\n'] Demo Output: ['aba', 'aabaa'] Note: In the first example, "aba" is a subsequence of "aba" which is a palindrome. In the second example, "ab" is a subsequence of "aabaa" which is a palindrome.

```python def pal(s): if(s==s[::-1]): return 1; else: return 0 k=input() if(pal(k)==1): print(k) else: print(k+k[::-1]) ```

3

59

A

Word

PROGRAMMING

800

[ "implementation", "strings" ]

A. Word

2

256

Vasya is very upset that many people on the Net mix uppercase and lowercase letters in one word. That's why he decided to invent an extension for his favorite browser that would change the letters' register in every word so that it either only consisted of lowercase letters or, vice versa, only of uppercase ones. At that as little as possible letters should be changed in the word. For example, the word HoUse must be replaced with house, and the word ViP — with VIP. If a word contains an equal number of uppercase and lowercase letters, you should replace all the letters with lowercase ones. For example, maTRIx should be replaced by matrix. Your task is to use the given method on one given word.

The first line contains a word *s* — it consists of uppercase and lowercase Latin letters and possesses the length from 1 to 100.

Print the corrected word *s*. If the given word *s* has strictly more uppercase letters, make the word written in the uppercase register, otherwise - in the lowercase one.

[ "HoUse\n", "ViP\n", "maTRIx\n" ]

[ "house\n", "VIP\n", "matrix\n" ]

none

500

[ { "input": "HoUse", "output": "house" }, { "input": "ViP", "output": "VIP" }, { "input": "maTRIx", "output": "matrix" }, { "input": "BNHWpnpawg", "output": "bnhwpnpawg" }, { "input": "VTYGP", "output": "VTYGP" }, { "input": "CHNenu", "output": "chnenu" }, { "input": "ERPZGrodyu", "output": "erpzgrodyu" }, { "input": "KSXBXWpebh", "output": "KSXBXWPEBH" }, { "input": "qvxpqullmcbegsdskddortcvxyqlbvxmmkhevovnezubvpvnrcajpxraeaxizgaowtfkzywvhnbgzsxbhkaipcmoumtikkiyyaiv", "output": "qvxpqullmcbegsdskddortcvxyqlbvxmmkhevovnezubvpvnrcajpxraeaxizgaowtfkzywvhnbgzsxbhkaipcmoumtikkiyyaiv" }, { "input": "Amnhaxtaopjzrkqlbroiyipitndczpunwygstmzevgyjdzyanxkdqnvgkikfabwouwkkbzuiuvgvxgpizsvqsbwepktpdrgdkmfd", "output": "amnhaxtaopjzrkqlbroiyipitndczpunwygstmzevgyjdzyanxkdqnvgkikfabwouwkkbzuiuvgvxgpizsvqsbwepktpdrgdkmfd" }, { "input": "ISAGFJFARYFBLOPQDSHWGMCNKMFTLVFUGNJEWGWNBLXUIATXEkqiettmmjgydwcpafqrppdsrrrtguinqbgmzzfqwonkpgpcwenv", "output": "isagfjfaryfblopqdshwgmcnkmftlvfugnjewgwnblxuiatxekqiettmmjgydwcpafqrppdsrrrtguinqbgmzzfqwonkpgpcwenv" }, { "input": "XHRPXZEGHSOCJPICUIXSKFUZUPYTSGJSDIYBCMNMNBPNDBXLXBzhbfnqvwcffvrdhtickyqhupmcehlsyvncqmfhautvxudqdhgg", "output": "xhrpxzeghsocjpicuixskfuzupytsgjsdiybcmnmnbpndbxlxbzhbfnqvwcffvrdhtickyqhupmcehlsyvncqmfhautvxudqdhgg" }, { "input": "RJIQZMJCIMSNDBOHBRAWIENODSALETAKGKPYUFGVEFGCBRENZGAdkcetqjljtmttlonpekcovdzebzdkzggwfsxhapmjkdbuceak", "output": "RJIQZMJCIMSNDBOHBRAWIENODSALETAKGKPYUFGVEFGCBRENZGADKCETQJLJTMTTLONPEKCOVDZEBZDKZGGWFSXHAPMJKDBUCEAK" }, { "input": "DWLWOBHNMMGTFOLFAECKBRNNGLYLYDXTGTVRLMEESZOIUATZZZXUFUZDLSJXMEVRTESSFBWLNZZCLCQWEVNNUCXYVHNGNXHCBDFw", "output": "DWLWOBHNMMGTFOLFAECKBRNNGLYLYDXTGTVRLMEESZOIUATZZZXUFUZDLSJXMEVRTESSFBWLNZZCLCQWEVNNUCXYVHNGNXHCBDFW" }, { "input": "NYCNHJWGBOCOTSPETKKHVWFGAQYNHOVJWJHCIEFOUQZXOYUIEQDZALFKTEHTVDBVJMEUBJUBCMNVPWGDPNCHQHZJRCHYRFPVIGUB", "output": "NYCNHJWGBOCOTSPETKKHVWFGAQYNHOVJWJHCIEFOUQZXOYUIEQDZALFKTEHTVDBVJMEUBJUBCMNVPWGDPNCHQHZJRCHYRFPVIGUB" }, { "input": "igxoixiecetohtgjgbqzvlaobkhstejxdklghowtvwunnnvauriohuspsdmpzckprwajyxldoyckgjivjpmbfqtszmtocovxwge", "output": "igxoixiecetohtgjgbqzvlaobkhstejxdklghowtvwunnnvauriohuspsdmpzckprwajyxldoyckgjivjpmbfqtszmtocovxwge" }, { "input": "Ykkekrsqolzryiwsmdlnbmfautxxxauoojrddvwklgnlyrfcvhorrzbmtcrvpaypqhcffdqhwziipyyskcmztjprjqvmzzqhqnw", "output": "ykkekrsqolzryiwsmdlnbmfautxxxauoojrddvwklgnlyrfcvhorrzbmtcrvpaypqhcffdqhwziipyyskcmztjprjqvmzzqhqnw" }, { "input": "YQOMLKYAORUQQUCQZCDYMIVDHGWZFFRMUVTAWCHERFPMNRYRIkgqrciokgajamehmcxgerpudvsqyonjonsxgbnefftzmygncks", "output": "yqomlkyaoruqqucqzcdymivdhgwzffrmuvtawcherfpmnryrikgqrciokgajamehmcxgerpudvsqyonjonsxgbnefftzmygncks" }, { "input": "CDOZDPBVVVHNBJVBYHEOXWFLJKRWJCAJMIFCOZWWYFKVWOGTVJcuusigdqfkumewjtdyitveeiaybwrhomrwmpdipjwiuxfnwuz", "output": "CDOZDPBVVVHNBJVBYHEOXWFLJKRWJCAJMIFCOZWWYFKVWOGTVJCUUSIGDQFKUMEWJTDYITVEEIAYBWRHOMRWMPDIPJWIUXFNWUZ" }, { "input": "WHIUVEXHVOOIJIDVJVPQUBJMEVPMPDKQWJKFBZSGSKUXMIPPMJWuckzcpxosodcjaaakvlxpbiigsiauviilylnnqlyucziihqg", "output": "WHIUVEXHVOOIJIDVJVPQUBJMEVPMPDKQWJKFBZSGSKUXMIPPMJWUCKZCPXOSODCJAAAKVLXPBIIGSIAUVIILYLNNQLYUCZIIHQG" }, { "input": "VGHUNFOXKETUYMZDJNGTAOIOANYXSGYNFOGOFFLDAWEUKYFOZXCJTCAFXZYLQZERYZLRSQXYQGAPCSUDPMEYTNCTTTMFAGVDWBO", "output": "VGHUNFOXKETUYMZDJNGTAOIOANYXSGYNFOGOFFLDAWEUKYFOZXCJTCAFXZYLQZERYZLRSQXYQGAPCSUDPMEYTNCTTTMFAGVDWBO" }, { "input": "EDUANHCQDOCJHFONTTSWBUJSTTIXBIXMAIUFSGFLXWAYIURTVAVZPYQDLAWIGCLMPHXCEFCJPFAAHXVNGQUFNHADAIUAZIDMHDd", "output": "EDUANHCQDOCJHFONTTSWBUJSTTIXBIXMAIUFSGFLXWAYIURTVAVZPYQDLAWIGCLMPHXCEFCJPFAAHXVNGQUFNHADAIUAZIDMHDD" }, { "input": "EBWOVSNLYTWWXrnovgugogtjahnmatomubebyxakas", "output": "ebwovsnlytwwxrnovgugogtjahnmatomubebyxakas" }, { "input": "AORNNDKTRLRVGDPXJKXFTPFpopuzrlqumrxssskvbm", "output": "AORNNDKTRLRVGDPXJKXFTPFPOPUZRLQUMRXSSSKVBM" }, { "input": "DBBZJCWQEVGYHEEUHJAWRHBDPsnplijbwtdibqrrheebfxqcvn", "output": "dbbzjcwqevgyheeuhjawrhbdpsnplijbwtdibqrrheebfxqcvn" }, { "input": "t", "output": "t" }, { "input": "N", "output": "N" }, { "input": "kv", "output": "kv" }, { "input": "Ur", "output": "ur" }, { "input": "CN", "output": "CN" } ]

1,619,506,870

2,147,483,647

Python 3

OK

TESTS

30

154

0

word = input() c=0 y=False cl='' for i in range(0, len(word)): cl = word[i] y = cl.isupper() if y == True: c = c+1 if c > (len(word)/2): print(word.upper()) else: print(word.lower())

Title: Word Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Vasya is very upset that many people on the Net mix uppercase and lowercase letters in one word. That's why he decided to invent an extension for his favorite browser that would change the letters' register in every word so that it either only consisted of lowercase letters or, vice versa, only of uppercase ones. At that as little as possible letters should be changed in the word. For example, the word HoUse must be replaced with house, and the word ViP — with VIP. If a word contains an equal number of uppercase and lowercase letters, you should replace all the letters with lowercase ones. For example, maTRIx should be replaced by matrix. Your task is to use the given method on one given word. Input Specification: The first line contains a word *s* — it consists of uppercase and lowercase Latin letters and possesses the length from 1 to 100. Output Specification: Print the corrected word *s*. If the given word *s* has strictly more uppercase letters, make the word written in the uppercase register, otherwise - in the lowercase one. Demo Input: ['HoUse\n', 'ViP\n', 'maTRIx\n'] Demo Output: ['house\n', 'VIP\n', 'matrix\n'] Note: none

```python word = input() c=0 y=False cl='' for i in range(0, len(word)): cl = word[i] y = cl.isupper() if y == True: c = c+1 if c > (len(word)/2): print(word.upper()) else: print(word.lower()) ```

3.9615

447

B

DZY Loves Strings

PROGRAMMING

1,000

[ "greedy", "implementation" ]

null

DZY loves collecting special strings which only contain lowercase letters. For each lowercase letter *c* DZY knows its value *w**c*. For each special string *s*<==<=*s*1*s*2... *s*|*s*| (|*s*| is the length of the string) he represents its value with a function *f*(*s*), where Now DZY has a string *s*. He wants to insert *k* lowercase letters into this string in order to get the largest possible value of the resulting string. Can you help him calculate the largest possible value he could get?

The first line contains a single string *s* (1<=≤<=|*s*|<=≤<=103). The second line contains a single integer *k* (0<=≤<=*k*<=≤<=103). The third line contains twenty-six integers from *w**a* to *w**z*. Each such number is non-negative and doesn't exceed 1000.

Print a single integer — the largest possible value of the resulting string DZY could get.

[ "abc\n3\n1 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n" ]

[ "41\n" ]

In the test sample DZY can obtain "abcbbc", *value* = 1·1 + 2·2 + 3·2 + 4·2 + 5·2 + 6·2 = 41.

1,000

[ { "input": "abc\n3\n1 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "41" }, { "input": "mmzhr\n3\n443 497 867 471 195 670 453 413 579 466 553 881 847 642 269 996 666 702 487 209 257 741 974 133 519 453", "output": "29978" }, { "input": "ajeeseerqnpaujubmajpibxrccazaawetywxmifzehojf\n23\n359 813 772 413 733 654 33 87 890 433 395 311 801 852 376 148 914 420 636 695 583 733 664 394 407 314", "output": "1762894" }, { "input": "uahngxejpomhbsebcxvelfsojbaouynnlsogjyvktpwwtcyddkcdqcqs\n34\n530 709 150 660 947 830 487 142 208 276 885 542 138 214 76 184 273 753 30 195 722 236 82 691 572 585", "output": "2960349" }, { "input": "xnzeqmouqyzvblcidmhbkqmtusszuczadpooslqxegldanwopilmdwzbczvrwgnwaireykwpugvpnpafbxlyggkgawghysufuegvmzvpgcqyjkoadcreaguzepbendwnowsuekxxivkziibxvxfoilofxcgnxvfefyezfhevfvtetsuhwtyxdlkccdkvqjl\n282\n170 117 627 886 751 147 414 187 150 960 410 70 576 681 641 729 798 877 611 108 772 643 683 166 305 933", "output": "99140444" }, { "input": "pplkqmluhfympkjfjnfdkwrkpumgdmbkfbbldpepicbbmdgafttpopzdxsevlqbtywzkoxyviglbbxsohycbdqksrhlumsldiwzjmednbkcjishkiekfrchzuztkcxnvuykhuenqojrmzaxlaoxnljnvqgnabtmcftisaazzgbmubmpsorygyusmeonrhrgphnfhlaxrvyhuxsnnezjxmdoklpquzpvjbxgbywppmegzxknhfzyygrmejleesoqfwheulmqhonqaukyuejtwxskjldplripyihbfpookxkuehiwqthbfafyrgmykuxglpplozycgydyecqkgfjljfqvigqhuxssqqtfanwszduwbsoytnrtgc\n464\n838 95 473 955 690 84 436 19 179 437 674 626 377 365 781 4 733 776 462 203 119 256 381 668 855 686", "output": "301124161" }, { "input": "qkautnuilwlhjsldfcuwhiqtgtoihifszlyvfaygrnivzgvwthkrzzdtfjcirrjjlrmjtbjlzmjeqmuffsjorjyggzefwgvmblvotvzffnwjhqxorpowzdcnfksdibezdtfjjxfozaghieksbmowrbeehuxlesmvqjsphlvauxiijm\n98\n121 622 0 691 616 959 838 161 581 862 876 830 267 812 598 106 337 73 588 323 999 17 522 399 657 495", "output": "30125295" }, { "input": "tghyxqfmhz\n8\n191 893 426 203 780 326 148 259 182 140 847 636 778 97 167 773 219 891 758 993 695 603 223 779 368 165", "output": "136422" }, { "input": "nyawbfjxnxjiyhwkydaruozobpphgjqdpfdqzezcsoyvurnapu\n30\n65 682 543 533 990 148 815 821 315 916 632 771 332 513 472 864 12 73 548 687 660 572 507 192 226 348", "output": "2578628" }, { "input": "pylrnkrbcjgoytvdnhmlvnkknijkdgdhworlvtwuonrkhrilkewcnofodaumgvnsisxooswgrgtvdeauyxhkipfoxrrtysuepjcf\n60\n894 206 704 179 272 337 413 828 119 182 330 46 440 102 250 191 242 539 678 783 843 431 612 567 33 338", "output": "9168707" }, { "input": "vhjnkrxbyhjhnjrxvwxmhxwoxttbtqosfxtcuvhfjlkyfspeypthsdkkwnqdpxdlnxsgtzvkrgqosgfjrwetqbxgoarkjhrjbspzgblsapifltkfxbfdbxqwoohlgyzijmiwnpmveybyzvasoctxsmgjehpyysmqblwnmkappbecklqjfmxhlyceordroflnposohfplrvijxbwvqdtvzhobtrumiujnyrfbwthvciinuveoizkccelxtaveiiagryqnyvsgfnipnavrtmdqlcnldepocbpzmqnarkdvykds\n276\n364 244 798 82 582 9 309 950 286 547 892 371 569 159 705 975 740 845 655 179 130 993 255 552 882 657", "output": "144901921" }, { "input": "gsaddmezrnttfalbwlqbnedumvikplfosw\n12\n290 850 872 361 483 895 152 118 974 619 701 154 899 285 328 712 669 984 407 340 851 775 324 892 554 860", "output": "809931" }, { "input": "a\n0\n5 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "5" }, { "input": "lol\n3\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "21" } ]

1,546,641,401

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

77

0

s=input() n=int(input()) a=list(map(int,input().split())) sum1=0 i=1 for c in s: sum1+=a[ord(c)-ord('a')]*i i+=1 a.sort() for j in range(26-n,26): i+=1 sum1+=a[j]*i print(sum1)

Title: DZY Loves Strings Time Limit: None seconds Memory Limit: None megabytes Problem Description: DZY loves collecting special strings which only contain lowercase letters. For each lowercase letter *c* DZY knows its value *w**c*. For each special string *s*<==<=*s*1*s*2... *s*|*s*| (|*s*| is the length of the string) he represents its value with a function *f*(*s*), where Now DZY has a string *s*. He wants to insert *k* lowercase letters into this string in order to get the largest possible value of the resulting string. Can you help him calculate the largest possible value he could get? Input Specification: The first line contains a single string *s* (1<=≤<=|*s*|<=≤<=103). The second line contains a single integer *k* (0<=≤<=*k*<=≤<=103). The third line contains twenty-six integers from *w**a* to *w**z*. Each such number is non-negative and doesn't exceed 1000. Output Specification: Print a single integer — the largest possible value of the resulting string DZY could get. Demo Input: ['abc\n3\n1 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n'] Demo Output: ['41\n'] Note: In the test sample DZY can obtain "abcbbc", *value* = 1·1 + 2·2 + 3·2 + 4·2 + 5·2 + 6·2 = 41.

```python s=input() n=int(input()) a=list(map(int,input().split())) sum1=0 i=1 for c in s: sum1+=a[ord(c)-ord('a')]*i i+=1 a.sort() for j in range(26-n,26): i+=1 sum1+=a[j]*i print(sum1) ```

0

26

B

Regular Bracket Sequence

PROGRAMMING

1,400

[ "greedy" ]

B. Regular Bracket Sequence

5

256

A bracket sequence is called regular if it is possible to obtain correct arithmetic expression by inserting characters «+» and «1» into this sequence. For example, sequences «(())()», «()» and «(()(()))» are regular, while «)(», «(()» and «(()))(» are not. One day Johnny got bracket sequence. He decided to remove some of the brackets from it in order to obtain a regular bracket sequence. What is the maximum length of a regular bracket sequence which can be obtained?

Input consists of a single line with non-empty string of «(» and «)» characters. Its length does not exceed 106.

Output the maximum possible length of a regular bracket sequence.

[ "(()))(\n", "((()())\n" ]

[ "4\n", "6\n" ]

none

1,000

[ { "input": "(()))(", "output": "4" }, { "input": "((()())", "output": "6" }, { "input": "(", "output": "0" }, { "input": ")", "output": "0" }, { "input": ")(()(", "output": "2" }, { "input": "))))))(", "output": "0" }, { "input": "()()(()(((", "output": "6" }, { "input": "()))(()((((()(())", "output": "10" }, { "input": "())))((()())())))))())", "output": "14" }, { "input": ")))((((())(()((()((((()()())((", "output": "16" }, { "input": "))()()((()()))())()(((((((())((((((((())()()((())(", "output": "32" }, { "input": "))())))))))())))))()()))()()))))())))))()))))))))))))(()))())(()))))(()))))())))((((()()))))()))()))", "output": "48" } ]

1,513,929,150

2,147,483,647

Python 3

OK

TESTS

38

998

16,588,800

m=input() cont=0 cont2=0 B=[] C=[] for i in m : if i == "(" : B.append(i) if i == ")" : if len(B)!=0: if B.pop() == "(" : cont+=1 else:cont2+=1 print(cont*2)

Title: Regular Bracket Sequence Time Limit: 5 seconds Memory Limit: 256 megabytes Problem Description: A bracket sequence is called regular if it is possible to obtain correct arithmetic expression by inserting characters «+» and «1» into this sequence. For example, sequences «(())()», «()» and «(()(()))» are regular, while «)(», «(()» and «(()))(» are not. One day Johnny got bracket sequence. He decided to remove some of the brackets from it in order to obtain a regular bracket sequence. What is the maximum length of a regular bracket sequence which can be obtained? Input Specification: Input consists of a single line with non-empty string of «(» and «)» characters. Its length does not exceed 106. Output Specification: Output the maximum possible length of a regular bracket sequence. Demo Input: ['(()))(\n', '((()())\n'] Demo Output: ['4\n', '6\n'] Note: none

```python m=input() cont=0 cont2=0 B=[] C=[] for i in m : if i == "(" : B.append(i) if i == ")" : if len(B)!=0: if B.pop() == "(" : cont+=1 else:cont2+=1 print(cont*2) ```

3.869301

4

A

Watermelon

PROGRAMMING

800

[ "brute force", "math" ]

A. Watermelon

1

64

One hot summer day Pete and his friend Billy decided to buy a watermelon. They chose the biggest and the ripest one, in their opinion. After that the watermelon was weighed, and the scales showed *w* kilos. They rushed home, dying of thirst, and decided to divide the berry, however they faced a hard problem. Pete and Billy are great fans of even numbers, that's why they want to divide the watermelon in such a way that each of the two parts weighs even number of kilos, at the same time it is not obligatory that the parts are equal. The boys are extremely tired and want to start their meal as soon as possible, that's why you should help them and find out, if they can divide the watermelon in the way they want. For sure, each of them should get a part of positive weight.

The first (and the only) input line contains integer number *w* (1<=≤<=*w*<=≤<=100) — the weight of the watermelon bought by the boys.

Print YES, if the boys can divide the watermelon into two parts, each of them weighing even number of kilos; and NO in the opposite case.

[ "8\n" ]

[ "YES\n" ]

For example, the boys can divide the watermelon into two parts of 2 and 6 kilos respectively (another variant — two parts of 4 and 4 kilos).

0

[ { "input": "8", "output": "YES" }, { "input": "5", "output": "NO" }, { "input": "4", "output": "YES" }, { "input": "3", "output": "NO" }, { "input": "2", "output": "NO" }, { "input": "1", "output": "NO" }, { "input": "7", "output": "NO" }, { "input": "6", "output": "YES" }, { "input": "10", "output": "YES" }, { "input": "9", "output": "NO" }, { "input": "53", "output": "NO" }, { "input": "77", "output": "NO" }, { "input": "32", "output": "YES" }, { "input": "44", "output": "YES" }, { "input": "98", "output": "YES" }, { "input": "99", "output": "NO" }, { "input": "90", "output": "YES" }, { "input": "67", "output": "NO" }, { "input": "100", "output": "YES" }, { "input": "88", "output": "YES" } ]

1,692,482,116

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

60

0

p = int(input("Ingresa el peso de la sandía: ")) if p % 2 == 0 and p > 2: print("YES") else: print("NO")

Title: Watermelon Time Limit: 1 seconds Memory Limit: 64 megabytes Problem Description: One hot summer day Pete and his friend Billy decided to buy a watermelon. They chose the biggest and the ripest one, in their opinion. After that the watermelon was weighed, and the scales showed *w* kilos. They rushed home, dying of thirst, and decided to divide the berry, however they faced a hard problem. Pete and Billy are great fans of even numbers, that's why they want to divide the watermelon in such a way that each of the two parts weighs even number of kilos, at the same time it is not obligatory that the parts are equal. The boys are extremely tired and want to start their meal as soon as possible, that's why you should help them and find out, if they can divide the watermelon in the way they want. For sure, each of them should get a part of positive weight. Input Specification: The first (and the only) input line contains integer number *w* (1<=≤<=*w*<=≤<=100) — the weight of the watermelon bought by the boys. Output Specification: Print YES, if the boys can divide the watermelon into two parts, each of them weighing even number of kilos; and NO in the opposite case. Demo Input: ['8\n'] Demo Output: ['YES\n'] Note: For example, the boys can divide the watermelon into two parts of 2 and 6 kilos respectively (another variant — two parts of 4 and 4 kilos).

```python p = int(input("Ingresa el peso de la sandía: ")) if p % 2 == 0 and p > 2: print("YES") else: print("NO") ```

-1

0

none

0

[ "none" ]

null

Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to . Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it. He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles.

The first and the single line of the input contains 6 space-separated integers *a*1,<=*a*2,<=*a*3,<=*a*4,<=*a*5 and *a*6 (1<=≤<=*a**i*<=≤<=1000) — the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists.

Print a single integer — the number of triangles with the sides of one 1 centimeter, into which the hexagon is split.

[ "1 1 1 1 1 1\n", "1 2 1 2 1 2\n" ]

[ "6\n", "13\n" ]

This is what Gerald's hexagon looks like in the first sample: <img class="tex-graphics" src="https://espresso.codeforces.com/84d193e27b02c38eb1eadc536602a2ec0b9f9519.png" style="max-width: 100.0%;max-height: 100.0%;"/> And that's what it looks like in the second sample: <img class="tex-graphics" src="https://espresso.codeforces.com/e29076a96da8ca864654cc6195654d9bf07d31ce.png" style="max-width: 100.0%;max-height: 100.0%;"/>

0

[ { "input": "1 1 1 1 1 1", "output": "6" }, { "input": "1 2 1 2 1 2", "output": "13" }, { "input": "2 4 5 3 3 6", "output": "83" }, { "input": "45 19 48 18 46 21", "output": "6099" }, { "input": "66 6 65 6 66 5", "output": "5832" }, { "input": "7 5 4 8 4 5", "output": "175" }, { "input": "3 2 1 4 1 2", "output": "25" }, { "input": "7 1 7 3 5 3", "output": "102" }, { "input": "9 2 9 3 8 3", "output": "174" }, { "input": "1 6 1 5 2 5", "output": "58" }, { "input": "41 64 48 61 44 68", "output": "17488" }, { "input": "1 59 2 59 1 60", "output": "3838" }, { "input": "30 36 36 32 34 38", "output": "7052" }, { "input": "50 40 46 38 52 34", "output": "11176" }, { "input": "4 60 4 60 4 60", "output": "4576" }, { "input": "718 466 729 470 714 481", "output": "2102808" }, { "input": "131 425 143 461 95 473", "output": "441966" }, { "input": "125 7 128 8 124 11", "output": "20215" }, { "input": "677 303 685 288 692 296", "output": "1365807" }, { "input": "1 577 7 576 2 582", "output": "342171" }, { "input": "1000 1000 1000 1000 1000 1000", "output": "6000000" }, { "input": "1 1 1000 1 1 1000", "output": "4002" }, { "input": "1000 1000 1 1000 1000 1", "output": "2004000" }, { "input": "1000 1 1000 999 2 999", "output": "2003997" }, { "input": "1 1000 1 1 1000 1", "output": "4002" }, { "input": "888 888 888 887 889 887", "output": "4729487" } ]

1,437,582,481

2,147,483,647

Python 3

OK

TESTS

26

62

0

import sys (a1, a2, a3, a4, a5, a6) = map(int, input().split()) def calc(h): res = 0 cur = 1 while cur <= h: res += cur + cur - 1 cur += 1 return res ax1 = a4 ax2 = a6 ans = calc(ax1 + ax2 + a5) - calc(ax1) - calc(ax2) - calc(a2) print(ans)

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: Gerald got a very curious hexagon for his birthday. The boy found out that all the angles of the hexagon are equal to . Then he measured the length of its sides, and found that each of them is equal to an integer number of centimeters. There the properties of the hexagon ended and Gerald decided to draw on it. He painted a few lines, parallel to the sides of the hexagon. The lines split the hexagon into regular triangles with sides of 1 centimeter. Now Gerald wonders how many triangles he has got. But there were so many of them that Gerald lost the track of his counting. Help the boy count the triangles. Input Specification: The first and the single line of the input contains 6 space-separated integers *a*1,<=*a*2,<=*a*3,<=*a*4,<=*a*5 and *a*6 (1<=≤<=*a**i*<=≤<=1000) — the lengths of the sides of the hexagons in centimeters in the clockwise order. It is guaranteed that the hexagon with the indicated properties and the exactly such sides exists. Output Specification: Print a single integer — the number of triangles with the sides of one 1 centimeter, into which the hexagon is split. Demo Input: ['1 1 1 1 1 1\n', '1 2 1 2 1 2\n'] Demo Output: ['6\n', '13\n'] Note: This is what Gerald's hexagon looks like in the first sample: <img class="tex-graphics" src="https://espresso.codeforces.com/84d193e27b02c38eb1eadc536602a2ec0b9f9519.png" style="max-width: 100.0%;max-height: 100.0%;"/> And that's what it looks like in the second sample: <img class="tex-graphics" src="https://espresso.codeforces.com/e29076a96da8ca864654cc6195654d9bf07d31ce.png" style="max-width: 100.0%;max-height: 100.0%;"/>

```python import sys (a1, a2, a3, a4, a5, a6) = map(int, input().split()) def calc(h): res = 0 cur = 1 while cur <= h: res += cur + cur - 1 cur += 1 return res ax1 = a4 ax2 = a6 ans = calc(ax1 + ax2 + a5) - calc(ax1) - calc(ax2) - calc(a2) print(ans) ```

3

144

A

Arrival of the General

PROGRAMMING

800

[ "implementation" ]

null

A Ministry for Defense sent a general to inspect the Super Secret Military Squad under the command of the Colonel SuperDuper. Having learned the news, the colonel ordered to all *n* squad soldiers to line up on the parade ground. By the military charter the soldiers should stand in the order of non-increasing of their height. But as there's virtually no time to do that, the soldiers lined up in the arbitrary order. However, the general is rather short-sighted and he thinks that the soldiers lined up correctly if the first soldier in the line has the maximum height and the last soldier has the minimum height. Please note that the way other solders are positioned does not matter, including the case when there are several soldiers whose height is maximum or minimum. Only the heights of the first and the last soldier are important. For example, the general considers the sequence of heights (4, 3, 4, 2, 1, 1) correct and the sequence (4, 3, 1, 2, 2) wrong. Within one second the colonel can swap any two neighboring soldiers. Help him count the minimum time needed to form a line-up which the general will consider correct.

The first input line contains the only integer *n* (2<=≤<=*n*<=≤<=100) which represents the number of soldiers in the line. The second line contains integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=100) the values of the soldiers' heights in the order of soldiers' heights' increasing in the order from the beginning of the line to its end. The numbers are space-separated. Numbers *a*1,<=*a*2,<=...,<=*a**n* are not necessarily different.

Print the only integer — the minimum number of seconds the colonel will need to form a line-up the general will like.

[ "4\n33 44 11 22\n", "7\n10 10 58 31 63 40 76\n" ]

[ "2\n", "10\n" ]

In the first sample the colonel will need to swap the first and second soldier and then the third and fourth soldier. That will take 2 seconds. The resulting position of the soldiers is (44, 33, 22, 11). In the second sample the colonel may swap the soldiers in the following sequence: 1. (10, 10, 58, 31, 63, 40, 76) 1. (10, 58, 10, 31, 63, 40, 76) 1. (10, 58, 10, 31, 63, 76, 40) 1. (10, 58, 10, 31, 76, 63, 40) 1. (10, 58, 31, 10, 76, 63, 40) 1. (10, 58, 31, 76, 10, 63, 40) 1. (10, 58, 31, 76, 63, 10, 40) 1. (10, 58, 76, 31, 63, 10, 40) 1. (10, 76, 58, 31, 63, 10, 40) 1. (76, 10, 58, 31, 63, 10, 40) 1. (76, 10, 58, 31, 63, 40, 10)

500

[ { "input": "4\n33 44 11 22", "output": "2" }, { "input": "7\n10 10 58 31 63 40 76", "output": "10" }, { "input": "2\n88 89", "output": "1" }, { "input": "5\n100 95 100 100 88", "output": "0" }, { "input": "7\n48 48 48 48 45 45 45", "output": "0" }, { "input": "10\n68 47 67 29 63 71 71 65 54 56", "output": "10" }, { "input": "15\n77 68 96 60 92 75 61 60 66 79 80 65 60 95 92", "output": "4" }, { "input": "3\n1 2 1", "output": "1" }, { "input": "20\n30 30 30 14 30 14 30 30 30 14 30 14 14 30 14 14 30 14 14 14", "output": "0" }, { "input": "35\n37 41 46 39 47 39 44 47 44 42 44 43 47 39 46 39 38 42 39 37 40 44 41 42 41 42 39 42 36 36 42 36 42 42 42", "output": "7" }, { "input": "40\n99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 98 99 99 99 99 99 99 99 99 100 99 99 99 99 99 99", "output": "47" }, { "input": "50\n48 52 44 54 53 56 62 49 39 41 53 39 40 64 53 50 62 48 40 52 51 48 40 52 61 62 62 61 48 64 55 57 56 40 48 58 41 60 60 56 64 50 64 45 48 45 46 63 59 57", "output": "50" }, { "input": "57\n7 24 17 19 6 19 10 11 12 22 14 5 5 11 13 10 24 19 24 24 24 11 21 20 4 14 24 24 18 13 24 3 20 3 3 3 3 9 3 9 22 22 16 3 3 3 15 11 3 3 8 17 10 13 3 14 13", "output": "3" }, { "input": "65\n58 50 35 44 35 37 36 58 38 36 58 56 56 49 48 56 58 43 40 44 52 44 58 58 57 50 43 35 55 39 38 49 53 56 50 42 41 56 34 57 49 38 34 51 56 38 58 40 53 46 48 34 38 43 49 49 58 56 41 43 44 34 38 48 36", "output": "3" }, { "input": "69\n70 48 49 48 49 71 48 53 55 69 48 53 54 58 53 63 48 48 69 67 72 75 71 75 74 74 57 63 65 60 48 48 65 48 48 51 50 49 62 53 76 68 76 56 76 76 64 76 76 57 61 76 73 51 59 76 65 50 69 50 76 67 76 63 62 74 74 58 73", "output": "73" }, { "input": "75\n70 65 64 71 71 64 71 64 68 71 65 64 65 68 71 66 66 69 68 63 69 65 71 69 68 68 71 67 71 65 65 65 71 71 65 69 63 66 62 67 64 63 62 64 67 65 62 69 62 64 69 62 67 64 67 70 64 63 64 64 69 62 62 64 70 62 62 68 67 69 62 64 66 70 68", "output": "7" }, { "input": "84\n92 95 84 85 94 80 90 86 80 92 95 84 86 83 86 83 93 91 95 92 84 88 82 84 84 84 80 94 93 80 94 80 95 83 85 80 95 95 80 84 86 92 83 81 90 87 81 89 92 93 80 87 90 85 93 85 93 94 93 89 94 83 93 91 80 83 90 94 95 80 95 92 85 84 93 94 94 82 91 95 95 89 85 94", "output": "15" }, { "input": "90\n86 87 72 77 82 71 75 78 61 67 79 90 64 94 94 74 85 87 73 76 71 71 60 69 77 73 76 80 82 57 62 57 57 83 76 72 75 87 72 94 77 85 59 82 86 69 62 80 95 73 83 94 79 85 91 68 85 74 93 95 68 75 89 93 83 78 95 78 83 77 81 85 66 92 63 65 75 78 67 91 77 74 59 86 77 76 90 67 70 64", "output": "104" }, { "input": "91\n94 98 96 94 95 98 98 95 98 94 94 98 95 95 99 97 97 94 95 98 94 98 96 98 96 98 97 95 94 94 94 97 94 96 98 98 98 94 96 95 94 95 97 97 97 98 94 98 96 95 98 96 96 98 94 97 96 98 97 95 97 98 94 95 94 94 97 94 96 97 97 93 94 95 95 94 96 98 97 96 94 98 98 96 96 96 96 96 94 96 97", "output": "33" }, { "input": "92\n44 28 32 29 41 41 36 39 40 39 41 35 41 28 35 27 41 34 28 38 43 43 41 38 27 26 28 36 30 29 39 32 35 35 32 30 39 30 37 27 41 41 28 30 43 31 35 33 36 28 44 40 41 35 31 42 37 38 37 34 39 40 27 40 33 33 44 43 34 33 34 34 35 38 38 37 30 39 35 41 45 42 41 32 33 33 31 30 43 41 43 43", "output": "145" }, { "input": "93\n46 32 52 36 39 30 57 63 63 30 32 44 27 59 46 38 40 45 44 62 35 36 51 48 39 58 36 51 51 51 48 58 59 36 29 35 31 49 64 60 34 38 42 56 33 42 52 31 63 34 45 51 35 45 33 53 33 62 31 38 66 29 51 54 28 61 32 45 57 41 36 34 47 36 31 28 67 48 52 46 32 40 64 58 27 53 43 57 34 66 43 39 26", "output": "76" }, { "input": "94\n56 55 54 31 32 42 46 29 24 54 40 40 20 45 35 56 32 33 51 39 26 56 21 56 51 27 29 39 56 52 54 43 43 55 48 51 44 49 52 49 23 19 19 28 20 26 45 33 35 51 42 36 25 25 38 23 21 35 54 50 41 20 37 28 42 20 22 43 37 34 55 21 24 38 19 41 45 34 19 33 44 54 38 31 23 53 35 32 47 40 39 31 20 34", "output": "15" }, { "input": "95\n57 71 70 77 64 64 76 81 81 58 63 75 81 77 71 71 71 60 70 70 69 67 62 64 78 64 69 62 76 76 57 70 68 77 70 68 73 77 79 73 60 57 69 60 74 65 58 75 75 74 73 73 65 75 72 57 81 62 62 70 67 58 76 57 79 81 68 64 58 77 70 59 79 64 80 58 71 59 81 71 80 64 78 80 78 65 70 68 78 80 57 63 64 76 81", "output": "11" }, { "input": "96\n96 95 95 95 96 97 95 97 96 95 98 96 97 95 98 96 98 96 98 96 98 95 96 95 95 95 97 97 95 95 98 98 95 96 96 95 97 96 98 96 95 97 97 95 97 97 95 94 96 96 97 96 97 97 96 94 94 97 95 95 95 96 95 96 95 97 97 95 97 96 95 94 97 97 97 96 97 95 96 94 94 95 97 94 94 97 97 97 95 97 97 95 94 96 95 95", "output": "13" }, { "input": "97\n14 15 12 12 13 15 12 15 12 12 12 12 12 14 15 15 13 12 15 15 12 12 12 13 14 15 15 13 14 15 14 14 14 14 12 13 12 13 13 12 15 12 13 13 15 12 15 13 12 13 13 13 14 13 12 15 14 13 14 15 13 14 14 13 14 12 15 12 14 12 13 14 15 14 13 15 13 12 15 15 15 13 15 15 13 14 16 16 16 13 15 13 15 14 15 15 15", "output": "104" }, { "input": "98\n37 69 35 70 58 69 36 47 41 63 60 54 49 35 55 50 35 53 52 43 35 41 40 49 38 35 48 70 42 35 35 65 56 54 44 59 59 48 51 49 59 67 35 60 69 35 58 50 35 44 48 69 41 58 44 45 35 47 70 61 49 47 37 39 35 51 44 70 72 65 36 41 63 63 48 66 45 50 50 71 37 52 72 67 72 39 72 39 36 64 48 72 69 49 45 72 72 67", "output": "100" }, { "input": "99\n31 31 16 15 19 31 19 22 29 27 12 22 28 30 25 33 26 25 19 22 34 21 17 33 31 22 16 26 22 30 31 17 13 33 13 17 28 25 18 33 27 22 31 22 13 27 20 22 23 15 24 32 29 13 16 20 32 33 14 33 19 27 16 28 25 17 17 28 18 26 32 33 19 23 30 13 14 23 24 28 14 28 22 20 30 14 24 23 17 29 18 28 29 21 28 18 16 24 32", "output": "107" }, { "input": "100\n37 54 39 29 32 49 21 13 34 21 16 42 34 27 16 26 7 34 51 9 11 27 16 40 36 7 48 52 30 42 42 52 51 11 32 26 6 7 28 54 48 51 6 54 42 20 51 48 46 4 4 31 47 6 9 16 8 23 36 50 49 30 47 37 45 24 48 26 8 50 18 24 27 13 39 7 37 34 5 43 42 19 34 23 52 38 35 6 29 11 53 49 21 29 36 22 45 33 51 22", "output": "50" }, { "input": "100\n41 5 20 23 5 47 28 28 64 5 12 14 34 56 22 48 6 52 39 55 62 40 24 54 39 28 56 27 35 51 14 24 38 10 55 20 39 62 52 2 30 55 49 48 15 23 59 44 31 28 66 29 62 59 31 13 28 12 50 45 41 47 29 27 64 66 14 39 62 22 44 63 24 5 63 17 42 7 25 41 49 33 31 51 63 3 37 66 19 9 2 40 16 45 56 21 34 29 39 61", "output": "59" }, { "input": "100\n66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95 95", "output": "99" }, { "input": "100\n81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 81 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10", "output": "0" }, { "input": "3\n2 1 2", "output": "1" }, { "input": "2\n100 99", "output": "0" }, { "input": "100\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100", "output": "197" }, { "input": "100\n87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87", "output": "0" }, { "input": "100\n100 99 98 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 70 69 68 67 66 65 64 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1", "output": "0" }, { "input": "2\n1 1", "output": "0" }, { "input": "3\n2 2 2", "output": "0" }, { "input": "3\n1 3 2", "output": "2" } ]

1,697,806,522

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

30

0

a = int(input()) b = list(map(int, input().split())) if b.index(min(b)) > b.index(max(a)): print (-1 + a - 1) else: print(-1 + a)

Title: Arrival of the General Time Limit: None seconds Memory Limit: None megabytes Problem Description: A Ministry for Defense sent a general to inspect the Super Secret Military Squad under the command of the Colonel SuperDuper. Having learned the news, the colonel ordered to all *n* squad soldiers to line up on the parade ground. By the military charter the soldiers should stand in the order of non-increasing of their height. But as there's virtually no time to do that, the soldiers lined up in the arbitrary order. However, the general is rather short-sighted and he thinks that the soldiers lined up correctly if the first soldier in the line has the maximum height and the last soldier has the minimum height. Please note that the way other solders are positioned does not matter, including the case when there are several soldiers whose height is maximum or minimum. Only the heights of the first and the last soldier are important. For example, the general considers the sequence of heights (4, 3, 4, 2, 1, 1) correct and the sequence (4, 3, 1, 2, 2) wrong. Within one second the colonel can swap any two neighboring soldiers. Help him count the minimum time needed to form a line-up which the general will consider correct. Input Specification: The first input line contains the only integer *n* (2<=≤<=*n*<=≤<=100) which represents the number of soldiers in the line. The second line contains integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=100) the values of the soldiers' heights in the order of soldiers' heights' increasing in the order from the beginning of the line to its end. The numbers are space-separated. Numbers *a*1,<=*a*2,<=...,<=*a**n* are not necessarily different. Output Specification: Print the only integer — the minimum number of seconds the colonel will need to form a line-up the general will like. Demo Input: ['4\n33 44 11 22\n', '7\n10 10 58 31 63 40 76\n'] Demo Output: ['2\n', '10\n'] Note: In the first sample the colonel will need to swap the first and second soldier and then the third and fourth soldier. That will take 2 seconds. The resulting position of the soldiers is (44, 33, 22, 11). In the second sample the colonel may swap the soldiers in the following sequence: 1. (10, 10, 58, 31, 63, 40, 76) 1. (10, 58, 10, 31, 63, 40, 76) 1. (10, 58, 10, 31, 63, 76, 40) 1. (10, 58, 10, 31, 76, 63, 40) 1. (10, 58, 31, 10, 76, 63, 40) 1. (10, 58, 31, 76, 10, 63, 40) 1. (10, 58, 31, 76, 63, 10, 40) 1. (10, 58, 76, 31, 63, 10, 40) 1. (10, 76, 58, 31, 63, 10, 40) 1. (76, 10, 58, 31, 63, 10, 40) 1. (76, 10, 58, 31, 63, 40, 10)

```python a = int(input()) b = list(map(int, input().split())) if b.index(min(b)) > b.index(max(a)): print (-1 + a - 1) else: print(-1 + a) ```

-1

169

A

Chores

PROGRAMMING

800

[ "sortings" ]

null

Petya and Vasya are brothers. Today is a special day for them as their parents left them home alone and commissioned them to do *n* chores. Each chore is characterized by a single parameter — its complexity. The complexity of the *i*-th chore equals *h**i*. As Petya is older, he wants to take the chores with complexity larger than some value *x* (*h**i*<=><=*x*) to leave to Vasya the chores with complexity less than or equal to *x* (*h**i*<=≤<=*x*). The brothers have already decided that Petya will do exactly *a* chores and Vasya will do exactly *b* chores (*a*<=+<=*b*<==<=*n*). In how many ways can they choose an integer *x* so that Petya got exactly *a* chores and Vasya got exactly *b* chores?

The first input line contains three integers *n*,<=*a* and *b* (2<=≤<=*n*<=≤<=2000; *a*,<=*b*<=≥<=1; *a*<=+<=*b*<==<=*n*) — the total number of chores, the number of Petya's chores and the number of Vasya's chores. The next line contains a sequence of integers *h*1,<=*h*2,<=...,<=*h**n* (1<=≤<=*h**i*<=≤<=109), *h**i* is the complexity of the *i*-th chore. The numbers in the given sequence are not necessarily different. All numbers on the lines are separated by single spaces.

Print the required number of ways to choose an integer value of *x*. If there are no such ways, print 0.

[ "5 2 3\n6 2 3 100 1\n", "7 3 4\n1 1 9 1 1 1 1\n" ]

[ "3\n", "0\n" ]

In the first sample the possible values of *x* are 3, 4 or 5. In the second sample it is impossible to find such *x*, that Petya got 3 chores and Vasya got 4.

500

[ { "input": "5 2 3\n6 2 3 100 1", "output": "3" }, { "input": "7 3 4\n1 1 9 1 1 1 1", "output": "0" }, { "input": "2 1 1\n10 2", "output": "8" }, { "input": "2 1 1\n7 7", "output": "0" }, { "input": "2 1 1\n1 1000000000", "output": "999999999" }, { "input": "3 1 2\n6 5 5", "output": "1" }, { "input": "3 2 1\n10 10 8", "output": "2" }, { "input": "8 3 5\n42 55 61 72 83 10 22 33", "output": "6" }, { "input": "10 5 5\n1 2 3 4 5 999999999 999999998 999999997 999999996 999999995", "output": "999999990" }, { "input": "4 1 3\n10 8 7 3", "output": "2" }, { "input": "4 2 2\n402 10 10 402", "output": "392" }, { "input": "4 1 3\n10 402 402 10", "output": "0" }, { "input": "4 3 1\n100 100 200 200", "output": "0" }, { "input": "150 10 140\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "0" }, { "input": "102 101 1\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1", "output": "0" } ]

1,598,471,586

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

2

93

0

n, a, b = map(int, input().split()) l=list(map(int, input().split())) l.sort() if l[a+1]-l[a]>0: print(l[a+1]-l[a]) else: print(0)

Title: Chores Time Limit: None seconds Memory Limit: None megabytes Problem Description: Petya and Vasya are brothers. Today is a special day for them as their parents left them home alone and commissioned them to do *n* chores. Each chore is characterized by a single parameter — its complexity. The complexity of the *i*-th chore equals *h**i*. As Petya is older, he wants to take the chores with complexity larger than some value *x* (*h**i*<=><=*x*) to leave to Vasya the chores with complexity less than or equal to *x* (*h**i*<=≤<=*x*). The brothers have already decided that Petya will do exactly *a* chores and Vasya will do exactly *b* chores (*a*<=+<=*b*<==<=*n*). In how many ways can they choose an integer *x* so that Petya got exactly *a* chores and Vasya got exactly *b* chores? Input Specification: The first input line contains three integers *n*,<=*a* and *b* (2<=≤<=*n*<=≤<=2000; *a*,<=*b*<=≥<=1; *a*<=+<=*b*<==<=*n*) — the total number of chores, the number of Petya's chores and the number of Vasya's chores. The next line contains a sequence of integers *h*1,<=*h*2,<=...,<=*h**n* (1<=≤<=*h**i*<=≤<=109), *h**i* is the complexity of the *i*-th chore. The numbers in the given sequence are not necessarily different. All numbers on the lines are separated by single spaces. Output Specification: Print the required number of ways to choose an integer value of *x*. If there are no such ways, print 0. Demo Input: ['5 2 3\n6 2 3 100 1\n', '7 3 4\n1 1 9 1 1 1 1\n'] Demo Output: ['3\n', '0\n'] Note: In the first sample the possible values of *x* are 3, 4 or 5. In the second sample it is impossible to find such *x*, that Petya got 3 chores and Vasya got 4.

```python n, a, b = map(int, input().split()) l=list(map(int, input().split())) l.sort() if l[a+1]-l[a]>0: print(l[a+1]-l[a]) else: print(0) ```

-1

843

B

Interactive LowerBound

PROGRAMMING

2,000

[ "brute force", "interactive", "probabilities" ]

null

This is an interactive problem. You are given a sorted in increasing order singly linked list. You should find the minimum integer in the list which is greater than or equal to *x*. More formally, there is a singly liked list built on an array of *n* elements. Element with index *i* contains two integers: *value**i* is the integer value in this element, and *next**i* that is the index of the next element of the singly linked list (or -1, if the current element is the last). The list is sorted, i.e. if *next**i*<=≠<=<=-<=1, then *value**next**i*<=><=*value**i*. You are given the number of elements in the list *n*, the index of the first element *start*, and the integer *x*. You can make up to 2000 queries of the following two types: - ? i (1<=≤<=*i*<=≤<=*n*) — ask the values *value**i* and *next**i*, - ! ans — give the answer for the problem: the minimum integer, greater than or equal to *x*, or ! -1, if there are no such integers. Your program should terminate after this query. Write a program that solves this problem.

The first line contains three integers *n*, *start*, *x* (1<=≤<=*n*<=≤<=50000, 1<=≤<=*start*<=≤<=*n*, 0<=≤<=*x*<=≤<=109) — the number of elements in the list, the index of the first element and the integer *x*.

To print the answer for the problem, print ! ans, where ans is the minimum integer in the list greater than or equal to *x*, or -1, if there is no such integer.

[ "5 3 80\n97 -1\n58 5\n16 2\n81 1\n79 4\n" ]

[ "? 1\n? 2\n? 3\n? 4\n? 5\n! 81" ]

You can read more about singly linked list by the following link: [https://en.wikipedia.org/wiki/Linked_list#Singly_linked_list](https://en.wikipedia.org/wiki/Linked_list#Singly_linked_list) The illustration for the first sample case. Start and finish elements are marked dark. <img class="tex-graphics" src="https://espresso.codeforces.com/5202ec3b5e896b7db692ff7b80457c26cf6adb32.png" style="max-width: 100.0%;max-height: 100.0%;"/>

1,000

[ { "input": "5 3 80\n97 -1\n58 5\n16 2\n81 1\n79 4", "output": "81\n1003" }, { "input": "5 1 6\n1 2\n2 3\n3 4\n4 5\n5 -1", "output": "-1\n1002" }, { "input": "1 1 0\n0 -1", "output": "0\n2" }, { "input": "1 1 2\n0 -1", "output": "-1\n1002" }, { "input": "1 1 1000000000\n0 -1", "output": "-1\n1002" }, { "input": "5 3 3\n3 5\n2 1\n0 4\n1 2\n4 -1", "output": "3\n1003" }, { "input": "5 3 145337745\n619347297 5\n344132479 1\n122841322 4\n169280018 2\n740666615 -1", "output": "169280018\n1003" }, { "input": "5 3 315433300\n411188472 5\n316581280 1\n200698791 4\n314885421 2\n759386148 -1", "output": "316581280\n1003" }, { "input": "5 3 381735506\n469559901 5\n359493082 1\n137017061 4\n202768106 2\n955698260 -1", "output": "469559901\n1003" }, { "input": "5 3 587634055\n563214082 5\n404100743 1\n179733654 4\n236438578 2\n673892808 -1", "output": "673892808\n1003" }, { "input": "5 3 974128233\n547205043 5\n318213550 1\n122625404 4\n184874700 2\n669820978 -1", "output": "-1\n1002" }, { "input": "10 3 2\n3 9\n9 -1\n0 7\n6 8\n5 4\n8 2\n1 10\n7 6\n4 5\n2 1", "output": "2\n1003" }, { "input": "10 3 632584719\n378382911 9\n978367651 -1\n176599346 7\n557138623 8\n441019502 4\n823417558 2\n244832688 10\n702148024 6\n385598339 5\n357778234 1", "output": "702148024\n1003" }, { "input": "1 1 50\n60 -1", "output": "60\n2" }, { "input": "5 1 100\n200 2\n300 3\n400 4\n500 5\n600 -1", "output": "200\n2" } ]

1,509,454,736

2,147,483,647

Python 3

OK

TESTS

171

139

716,800

from random import sample from sys import stdout read=lambda :map(int,input().split()) def ask(x): print('? {}'.format(x)) stdout.flush() return tuple(read()) def answer(x): print('! {}'.format(x)) stdout.flush() exit(0) n,st,x=read() a=[ask(st)] if a[0][0]>=x: answer(a[0][0]) for i in sample(range(1,n+1),min(n,999)): b=ask(i) if b[0]<x: a.append(b) elif b[0]==x: answer(x) b=max(a) while True: if b[0]>=x: answer(b[0]) if b[1]==-1: break else: b=ask(b[1]) answer(-1)

Title: Interactive LowerBound Time Limit: None seconds Memory Limit: None megabytes Problem Description: This is an interactive problem. You are given a sorted in increasing order singly linked list. You should find the minimum integer in the list which is greater than or equal to *x*. More formally, there is a singly liked list built on an array of *n* elements. Element with index *i* contains two integers: *value**i* is the integer value in this element, and *next**i* that is the index of the next element of the singly linked list (or -1, if the current element is the last). The list is sorted, i.e. if *next**i*<=≠<=<=-<=1, then *value**next**i*<=><=*value**i*. You are given the number of elements in the list *n*, the index of the first element *start*, and the integer *x*. You can make up to 2000 queries of the following two types: - ? i (1<=≤<=*i*<=≤<=*n*) — ask the values *value**i* and *next**i*, - ! ans — give the answer for the problem: the minimum integer, greater than or equal to *x*, or ! -1, if there are no such integers. Your program should terminate after this query. Write a program that solves this problem. Input Specification: The first line contains three integers *n*, *start*, *x* (1<=≤<=*n*<=≤<=50000, 1<=≤<=*start*<=≤<=*n*, 0<=≤<=*x*<=≤<=109) — the number of elements in the list, the index of the first element and the integer *x*. Output Specification: To print the answer for the problem, print ! ans, where ans is the minimum integer in the list greater than or equal to *x*, or -1, if there is no such integer. Demo Input: ['5 3 80\n97 -1\n58 5\n16 2\n81 1\n79 4\n'] Demo Output: ['? 1\n? 2\n? 3\n? 4\n? 5\n! 81'] Note: You can read more about singly linked list by the following link: [https://en.wikipedia.org/wiki/Linked_list#Singly_linked_list](https://en.wikipedia.org/wiki/Linked_list#Singly_linked_list) The illustration for the first sample case. Start and finish elements are marked dark. <img class="tex-graphics" src="https://espresso.codeforces.com/5202ec3b5e896b7db692ff7b80457c26cf6adb32.png" style="max-width: 100.0%;max-height: 100.0%;"/>

```python from random import sample from sys import stdout read=lambda :map(int,input().split()) def ask(x): print('? {}'.format(x)) stdout.flush() return tuple(read()) def answer(x): print('! {}'.format(x)) stdout.flush() exit(0) n,st,x=read() a=[ask(st)] if a[0][0]>=x: answer(a[0][0]) for i in sample(range(1,n+1),min(n,999)): b=ask(i) if b[0]<x: a.append(b) elif b[0]==x: answer(x) b=max(a) while True: if b[0]>=x: answer(b[0]) if b[1]==-1: break else: b=ask(b[1]) answer(-1) ```

3

294

B

Shaass and Bookshelf

PROGRAMMING

1,700

[ "dp", "greedy" ]

null

Shaass has *n* books. He wants to make a bookshelf for all his books. He wants the bookshelf's dimensions to be as small as possible. The thickness of the *i*-th book is *t**i* and its pages' width is equal to *w**i*. The thickness of each book is either 1 or 2. All books have the same page heights. Shaass puts the books on the bookshelf in the following way. First he selects some of the books and put them vertically. Then he puts the rest of the books horizontally above the vertical books. The sum of the widths of the horizontal books must be no more than the total thickness of the vertical books. A sample arrangement of the books is depicted in the figure. Help Shaass to find the minimum total thickness of the vertical books that we can achieve.

The first line of the input contains an integer *n*, (1<=≤<=*n*<=≤<=100). Each of the next *n* lines contains two integers *t**i* and *w**i* denoting the thickness and width of the *i*-th book correspondingly, (1<=≤<=*t**i*<=≤<=2,<=1<=≤<=*w**i*<=≤<=100).

On the only line of the output print the minimum total thickness of the vertical books that we can achieve.

[ "5\n1 12\n1 3\n2 15\n2 5\n2 1\n", "3\n1 10\n2 1\n2 4\n" ]

[ "5\n", "3\n" ]

none

1,000

[ { "input": "5\n1 12\n1 3\n2 15\n2 5\n2 1", "output": "5" }, { "input": "3\n1 10\n2 1\n2 4", "output": "3" }, { "input": "10\n2 10\n2 4\n2 8\n2 3\n2 5\n2 6\n1 2\n1 10\n1 10\n2 5", "output": "12" }, { "input": "1\n2 7", "output": "2" }, { "input": "50\n1 24\n1 16\n1 33\n2 34\n1 26\n2 35\n1 39\n2 44\n2 29\n2 28\n1 44\n2 48\n2 50\n2 41\n2 9\n1 22\n2 11\n2 27\n1 12\n1 50\n2 49\n1 17\n2 43\n2 6\n1 39\n2 28\n1 47\n1 45\n2 32\n1 43\n2 40\n1 10\n1 44\n2 31\n2 26\n2 15\n2 20\n1 49\n1 36\n2 43\n2 8\n1 46\n2 43\n2 26\n1 30\n1 23\n2 26\n1 32\n2 25\n2 42", "output": "67" }, { "input": "20\n2 4\n1 2\n2 2\n1 2\n2 1\n1 3\n2 5\n1 3\n1 1\n2 3\n1 4\n2 3\n1 5\n1 4\n1 4\n1 2\n2 5\n1 5\n2 2\n2 2", "output": "16" }, { "input": "30\n1 48\n1 3\n2 20\n2 41\n1 33\n2 46\n2 22\n2 21\n1 6\n2 44\n1 23\n2 28\n1 39\n1 19\n2 15\n2 49\n1 26\n1 22\n2 42\n2 27\n2 31\n1 49\n1 11\n1 33\n1 1\n2 31\n2 9\n1 18\n2 27\n1 18", "output": "38" }, { "input": "40\n2 14\n1 13\n1 51\n2 18\n2 99\n2 85\n1 37\n2 54\n2 82\n1 93\n1 71\n1 76\n1 40\n2 14\n1 61\n1 74\n2 83\n2 75\n1 12\n1 23\n1 95\n1 84\n2 90\n1 40\n1 96\n2 25\n2 68\n2 87\n2 34\n2 66\n2 60\n2 65\n2 18\n2 48\n1 97\n2 71\n1 94\n1 5\n1 47\n1 29", "output": "53" }, { "input": "1\n1 1", "output": "1" }, { "input": "1\n1 2", "output": "1" }, { "input": "2\n1 2\n2 2", "output": "2" }, { "input": "100\n2 2\n1 2\n1 1\n2 1\n1 2\n2 1\n2 2\n2 1\n2 1\n1 2\n1 2\n2 1\n1 2\n2 1\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 1\n2 2\n2 1\n1 1\n1 2\n2 2\n1 1\n2 2\n1 2\n2 1\n2 2\n1 2\n2 2\n1 2\n1 1\n2 2\n2 2\n1 1\n1 2\n2 2\n1 2\n1 1\n1 1\n1 1\n2 1\n2 1\n1 2\n1 2\n2 2\n1 2\n1 2\n1 1\n2 1\n2 1\n2 2\n1 2\n2 1\n1 1\n2 1\n1 2\n2 2\n1 1\n1 2\n1 2\n1 1\n2 2\n2 2\n1 1\n1 2\n1 2\n1 2\n2 1\n2 1\n2 2\n2 1\n1 2\n2 1\n1 2\n2 1\n1 2\n1 2\n2 1\n2 1\n1 1\n1 2\n2 1\n1 1\n1 1\n2 2\n2 2\n1 1\n2 1\n1 2\n2 2\n2 1\n1 2\n1 2\n1 2\n1 1\n2 1", "output": "60" }, { "input": "100\n2 2\n1 2\n1 5\n1 5\n1 2\n1 4\n2 3\n1 2\n1 5\n2 1\n2 2\n2 4\n1 2\n2 3\n1 1\n1 1\n2 5\n2 3\n2 2\n1 2\n2 1\n2 2\n1 5\n2 1\n2 4\n1 4\n1 4\n2 2\n1 1\n2 4\n1 4\n2 4\n1 2\n2 3\n2 3\n1 5\n1 5\n2 3\n1 4\n1 5\n2 2\n1 3\n2 2\n2 2\n1 1\n2 1\n2 5\n1 1\n2 3\n2 5\n1 5\n1 3\n1 5\n2 4\n1 5\n2 3\n2 5\n1 4\n2 3\n2 2\n2 5\n2 4\n1 1\n1 1\n1 3\n2 3\n2 1\n2 1\n1 2\n1 1\n2 5\n2 2\n2 1\n2 3\n2 2\n1 5\n1 2\n1 2\n1 1\n1 2\n1 4\n1 5\n1 4\n1 3\n1 1\n1 2\n2 2\n2 4\n1 2\n1 1\n2 3\n2 3\n2 5\n2 1\n1 5\n1 5\n1 4\n2 2\n1 4\n2 4", "output": "76" }, { "input": "50\n1 69\n2 39\n1 32\n2 35\n1 25\n2 24\n1 59\n2 99\n2 48\n2 54\n1 87\n1 81\n2 42\n2 8\n2 92\n1 78\n2 70\n2 91\n1 86\n1 87\n2 15\n1 93\n1 82\n2 36\n1 12\n1 56\n2 84\n1 98\n1 89\n2 79\n1 22\n1 65\n1 40\n2 13\n2 95\n2 93\n1 9\n2 99\n2 100\n1 76\n2 56\n1 10\n1 2\n2 93\n2 21\n2 33\n1 21\n1 81\n2 10\n2 93", "output": "66" }, { "input": "10\n1 61\n1 92\n2 97\n1 70\n2 37\n2 44\n2 29\n1 94\n2 65\n1 48", "output": "15" }, { "input": "40\n2 14\n1 13\n1 51\n2 18\n2 99\n2 85\n1 37\n2 54\n2 82\n1 93\n1 71\n1 76\n1 40\n2 14\n1 61\n1 74\n2 83\n2 75\n1 12\n1 23\n1 95\n1 84\n2 90\n1 40\n1 96\n2 25\n2 68\n2 87\n2 34\n2 66\n2 60\n2 65\n2 18\n2 48\n1 97\n2 71\n1 94\n1 5\n1 47\n1 29", "output": "53" }, { "input": "2\n1 100\n1 100", "output": "2" }, { "input": "3\n2 5\n2 5\n2 5", "output": "6" } ]

1,631,956,335

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

26

109

21,708,800

n=int(input()) a=[0]*n for i in range(n): a[i]=list(map(int,input().split())) s=sum(x[1] for x in a) x=10000 dp=[0]*x for v,w in a: for i in range(x-1,v-1,-1): dp[i]=max(dp[i],dp[i-v]+w) for i in range(x): if i>=s-dp[i]: print(i) break

Title: Shaass and Bookshelf Time Limit: None seconds Memory Limit: None megabytes Problem Description: Shaass has *n* books. He wants to make a bookshelf for all his books. He wants the bookshelf's dimensions to be as small as possible. The thickness of the *i*-th book is *t**i* and its pages' width is equal to *w**i*. The thickness of each book is either 1 or 2. All books have the same page heights. Shaass puts the books on the bookshelf in the following way. First he selects some of the books and put them vertically. Then he puts the rest of the books horizontally above the vertical books. The sum of the widths of the horizontal books must be no more than the total thickness of the vertical books. A sample arrangement of the books is depicted in the figure. Help Shaass to find the minimum total thickness of the vertical books that we can achieve. Input Specification: The first line of the input contains an integer *n*, (1<=≤<=*n*<=≤<=100). Each of the next *n* lines contains two integers *t**i* and *w**i* denoting the thickness and width of the *i*-th book correspondingly, (1<=≤<=*t**i*<=≤<=2,<=1<=≤<=*w**i*<=≤<=100). Output Specification: On the only line of the output print the minimum total thickness of the vertical books that we can achieve. Demo Input: ['5\n1 12\n1 3\n2 15\n2 5\n2 1\n', '3\n1 10\n2 1\n2 4\n'] Demo Output: ['5\n', '3\n'] Note: none

```python n=int(input()) a=[0]*n for i in range(n): a[i]=list(map(int,input().split())) s=sum(x[1] for x in a) x=10000 dp=[0]*x for v,w in a: for i in range(x-1,v-1,-1): dp[i]=max(dp[i],dp[i-v]+w) for i in range(x): if i>=s-dp[i]: print(i) break ```

0

387

A

George and Sleep

PROGRAMMING

900

[ "implementation" ]

null

George woke up and saw the current time *s* on the digital clock. Besides, George knows that he has slept for time *t*. Help George! Write a program that will, given time *s* and *t*, determine the time *p* when George went to bed. Note that George could have gone to bed yesterday relatively to the current time (see the second test sample).

The first line contains current time *s* as a string in the format "hh:mm". The second line contains time *t* in the format "hh:mm" — the duration of George's sleep. It is guaranteed that the input contains the correct time in the 24-hour format, that is, 00<=≤<=*hh*<=≤<=23, 00<=≤<=*mm*<=≤<=59.

In the single line print time *p* — the time George went to bed in the format similar to the format of the time in the input.

[ "05:50\n05:44\n", "00:00\n01:00\n", "00:01\n00:00\n" ]

[ "00:06\n", "23:00\n", "00:01\n" ]

In the first sample George went to bed at "00:06". Note that you should print the time only in the format "00:06". That's why answers "0:06", "00:6" and others will be considered incorrect. In the second sample, George went to bed yesterday. In the third sample, George didn't do to bed at all.

500

[ { "input": "05:50\n05:44", "output": "00:06" }, { "input": "00:00\n01:00", "output": "23:00" }, { "input": "00:01\n00:00", "output": "00:01" }, { "input": "23:59\n23:59", "output": "00:00" }, { "input": "23:44\n23:55", "output": "23:49" }, { "input": "00:00\n13:12", "output": "10:48" }, { "input": "12:00\n23:59", "output": "12:01" }, { "input": "12:44\n12:44", "output": "00:00" }, { "input": "05:55\n07:12", "output": "22:43" }, { "input": "07:12\n05:55", "output": "01:17" }, { "input": "22:22\n22:22", "output": "00:00" }, { "input": "22:22\n22:23", "output": "23:59" }, { "input": "23:24\n23:23", "output": "00:01" }, { "input": "00:00\n00:00", "output": "00:00" }, { "input": "23:30\n00:00", "output": "23:30" }, { "input": "01:00\n00:00", "output": "01:00" }, { "input": "05:44\n06:00", "output": "23:44" }, { "input": "00:00\n23:59", "output": "00:01" }, { "input": "21:00\n01:00", "output": "20:00" }, { "input": "21:21\n12:21", "output": "09:00" }, { "input": "12:21\n21:12", "output": "15:09" }, { "input": "12:33\n23:33", "output": "13:00" }, { "input": "07:55\n05:53", "output": "02:02" }, { "input": "19:30\n02:00", "output": "17:30" }, { "input": "21:30\n02:00", "output": "19:30" }, { "input": "19:30\n09:30", "output": "10:00" }, { "input": "13:08\n00:42", "output": "12:26" }, { "input": "13:04\n09:58", "output": "03:06" }, { "input": "21:21\n23:06", "output": "22:15" }, { "input": "20:53\n10:23", "output": "10:30" }, { "input": "12:59\n00:45", "output": "12:14" }, { "input": "12:39\n22:21", "output": "14:18" }, { "input": "21:10\n13:50", "output": "07:20" }, { "input": "03:38\n23:46", "output": "03:52" }, { "input": "03:48\n00:41", "output": "03:07" }, { "input": "07:43\n12:27", "output": "19:16" }, { "input": "03:23\n08:52", "output": "18:31" }, { "input": "16:04\n10:28", "output": "05:36" }, { "input": "12:53\n08:37", "output": "04:16" }, { "input": "13:43\n17:23", "output": "20:20" }, { "input": "00:00\n00:01", "output": "23:59" }, { "input": "10:10\n01:01", "output": "09:09" }, { "input": "10:05\n00:00", "output": "10:05" }, { "input": "09:09\n00:00", "output": "09:09" }, { "input": "09:10\n00:01", "output": "09:09" }, { "input": "23:24\n00:28", "output": "22:56" }, { "input": "10:00\n01:00", "output": "09:00" } ]

1,391,096,312

511

Python 3

WRONG_ANSWER

PRETESTS

4

62

409,600

s = input() p = input() t1 = int(s[len(s) - 2:len(s)]) - int(p[len(p) - 2:len(p)]) k = 0 if t1 < 0: t1 += 60 k = 1 t0 = int(s[:2]) - int(p[:2]) + k while t0 < 0: t0 += 24 t0 %= 24 res = str(t0) + ':' if len(res) < 3: res = '0' + res ss = '0' + str(t1) ss = ss[-2:] res += ss print(res)

Title: George and Sleep Time Limit: None seconds Memory Limit: None megabytes Problem Description: George woke up and saw the current time *s* on the digital clock. Besides, George knows that he has slept for time *t*. Help George! Write a program that will, given time *s* and *t*, determine the time *p* when George went to bed. Note that George could have gone to bed yesterday relatively to the current time (see the second test sample). Input Specification: The first line contains current time *s* as a string in the format "hh:mm". The second line contains time *t* in the format "hh:mm" — the duration of George's sleep. It is guaranteed that the input contains the correct time in the 24-hour format, that is, 00<=≤<=*hh*<=≤<=23, 00<=≤<=*mm*<=≤<=59. Output Specification: In the single line print time *p* — the time George went to bed in the format similar to the format of the time in the input. Demo Input: ['05:50\n05:44\n', '00:00\n01:00\n', '00:01\n00:00\n'] Demo Output: ['00:06\n', '23:00\n', '00:01\n'] Note: In the first sample George went to bed at "00:06". Note that you should print the time only in the format "00:06". That's why answers "0:06", "00:6" and others will be considered incorrect. In the second sample, George went to bed yesterday. In the third sample, George didn't do to bed at all.

```python s = input() p = input() t1 = int(s[len(s) - 2:len(s)]) - int(p[len(p) - 2:len(p)]) k = 0 if t1 < 0: t1 += 60 k = 1 t0 = int(s[:2]) - int(p[:2]) + k while t0 < 0: t0 += 24 t0 %= 24 res = str(t0) + ':' if len(res) < 3: res = '0' + res ss = '0' + str(t1) ss = ss[-2:] res += ss print(res) ```

0

791

A

Bear and Big Brother

PROGRAMMING

800

[ "implementation" ]

null

Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob. Right now, Limak and Bob weigh *a* and *b* respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight. Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year. After how many full years will Limak become strictly larger (strictly heavier) than Bob?

The only line of the input contains two integers *a* and *b* (1<=≤<=*a*<=≤<=*b*<=≤<=10) — the weight of Limak and the weight of Bob respectively.

Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.

[ "4 7\n", "4 9\n", "1 1\n" ]

[ "2\n", "3\n", "1\n" ]

In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2. In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights. In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.

500

[ { "input": "4 7", "output": "2" }, { "input": "4 9", "output": "3" }, { "input": "1 1", "output": "1" }, { "input": "4 6", "output": "2" }, { "input": "1 10", "output": "6" }, { "input": "1 1", "output": "1" }, { "input": "1 2", "output": "2" }, { "input": "1 3", "output": "3" }, { "input": "1 4", "output": "4" }, { "input": "1 5", "output": "4" }, { "input": "1 6", "output": "5" }, { "input": "1 7", "output": "5" }, { "input": "1 8", "output": "6" }, { "input": "1 9", "output": "6" }, { "input": "1 10", "output": "6" }, { "input": "2 2", "output": "1" }, { "input": "2 3", "output": "2" }, { "input": "2 4", "output": "2" }, { "input": "2 5", "output": "3" }, { "input": "2 6", "output": "3" }, { "input": "2 7", "output": "4" }, { "input": "2 8", "output": "4" }, { "input": "2 9", "output": "4" }, { "input": "2 10", "output": "4" }, { "input": "3 3", "output": "1" }, { "input": "3 4", "output": "1" }, { "input": "3 5", "output": "2" }, { "input": "3 6", "output": "2" }, { "input": "3 7", "output": "3" }, { "input": "3 8", "output": "3" }, { "input": "3 9", "output": "3" }, { "input": "3 10", "output": "3" }, { "input": "4 4", "output": "1" }, { "input": "4 5", "output": "1" }, { "input": "4 6", "output": "2" }, { "input": "4 7", "output": "2" }, { "input": "4 8", "output": "2" }, { "input": "4 9", "output": "3" }, { "input": "4 10", "output": "3" }, { "input": "5 5", "output": "1" }, { "input": "5 6", "output": "1" }, { "input": "5 7", "output": "1" }, { "input": "5 8", "output": "2" }, { "input": "5 9", "output": "2" }, { "input": "5 10", "output": "2" }, { "input": "6 6", "output": "1" }, { "input": "6 7", "output": "1" }, { "input": "6 8", "output": "1" }, { "input": "6 9", "output": "2" }, { "input": "6 10", "output": "2" }, { "input": "7 7", "output": "1" }, { "input": "7 8", "output": "1" }, { "input": "7 9", "output": "1" }, { "input": "7 10", "output": "1" }, { "input": "8 8", "output": "1" }, { "input": "8 9", "output": "1" }, { "input": "8 10", "output": "1" }, { "input": "9 9", "output": "1" }, { "input": "9 10", "output": "1" }, { "input": "10 10", "output": "1" }, { "input": "10 10", "output": "1" }, { "input": "1 2", "output": "2" } ]

1,698,145,849

2,147,483,647

Python 3

OK

TESTS

62

46

0

l, b = map(int, input().split()) years = 1 while l <= b: l = 3 * l b = 2 * b years += 1 print(years - 1)

Title: Bear and Big Brother Time Limit: None seconds Memory Limit: None megabytes Problem Description: Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob. Right now, Limak and Bob weigh *a* and *b* respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight. Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year. After how many full years will Limak become strictly larger (strictly heavier) than Bob? Input Specification: The only line of the input contains two integers *a* and *b* (1<=≤<=*a*<=≤<=*b*<=≤<=10) — the weight of Limak and the weight of Bob respectively. Output Specification: Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob. Demo Input: ['4 7\n', '4 9\n', '1 1\n'] Demo Output: ['2\n', '3\n', '1\n'] Note: In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2. In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights. In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.

```python l, b = map(int, input().split()) years = 1 while l <= b: l = 3 * l b = 2 * b years += 1 print(years - 1) ```

3

791

A

Bear and Big Brother

PROGRAMMING

800

[ "implementation" ]

null

Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob. Right now, Limak and Bob weigh *a* and *b* respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight. Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year. After how many full years will Limak become strictly larger (strictly heavier) than Bob?

The only line of the input contains two integers *a* and *b* (1<=≤<=*a*<=≤<=*b*<=≤<=10) — the weight of Limak and the weight of Bob respectively.

Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.

[ "4 7\n", "4 9\n", "1 1\n" ]

[ "2\n", "3\n", "1\n" ]

In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2. In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights. In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.

500

[ { "input": "4 7", "output": "2" }, { "input": "4 9", "output": "3" }, { "input": "1 1", "output": "1" }, { "input": "4 6", "output": "2" }, { "input": "1 10", "output": "6" }, { "input": "1 1", "output": "1" }, { "input": "1 2", "output": "2" }, { "input": "1 3", "output": "3" }, { "input": "1 4", "output": "4" }, { "input": "1 5", "output": "4" }, { "input": "1 6", "output": "5" }, { "input": "1 7", "output": "5" }, { "input": "1 8", "output": "6" }, { "input": "1 9", "output": "6" }, { "input": "1 10", "output": "6" }, { "input": "2 2", "output": "1" }, { "input": "2 3", "output": "2" }, { "input": "2 4", "output": "2" }, { "input": "2 5", "output": "3" }, { "input": "2 6", "output": "3" }, { "input": "2 7", "output": "4" }, { "input": "2 8", "output": "4" }, { "input": "2 9", "output": "4" }, { "input": "2 10", "output": "4" }, { "input": "3 3", "output": "1" }, { "input": "3 4", "output": "1" }, { "input": "3 5", "output": "2" }, { "input": "3 6", "output": "2" }, { "input": "3 7", "output": "3" }, { "input": "3 8", "output": "3" }, { "input": "3 9", "output": "3" }, { "input": "3 10", "output": "3" }, { "input": "4 4", "output": "1" }, { "input": "4 5", "output": "1" }, { "input": "4 6", "output": "2" }, { "input": "4 7", "output": "2" }, { "input": "4 8", "output": "2" }, { "input": "4 9", "output": "3" }, { "input": "4 10", "output": "3" }, { "input": "5 5", "output": "1" }, { "input": "5 6", "output": "1" }, { "input": "5 7", "output": "1" }, { "input": "5 8", "output": "2" }, { "input": "5 9", "output": "2" }, { "input": "5 10", "output": "2" }, { "input": "6 6", "output": "1" }, { "input": "6 7", "output": "1" }, { "input": "6 8", "output": "1" }, { "input": "6 9", "output": "2" }, { "input": "6 10", "output": "2" }, { "input": "7 7", "output": "1" }, { "input": "7 8", "output": "1" }, { "input": "7 9", "output": "1" }, { "input": "7 10", "output": "1" }, { "input": "8 8", "output": "1" }, { "input": "8 9", "output": "1" }, { "input": "8 10", "output": "1" }, { "input": "9 9", "output": "1" }, { "input": "9 10", "output": "1" }, { "input": "10 10", "output": "1" }, { "input": "10 10", "output": "1" }, { "input": "1 2", "output": "2" } ]

1,694,017,696

2,147,483,647

PyPy 3-64

OK

TESTS

62

0

d,e=map(int,input().split()) cnt=0 while d<=e: d=d*3 e=e*2 cnt+=1 print(cnt)

Title: Bear and Big Brother Time Limit: None seconds Memory Limit: None megabytes Problem Description: Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob. Right now, Limak and Bob weigh *a* and *b* respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight. Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year. After how many full years will Limak become strictly larger (strictly heavier) than Bob? Input Specification: The only line of the input contains two integers *a* and *b* (1<=≤<=*a*<=≤<=*b*<=≤<=10) — the weight of Limak and the weight of Bob respectively. Output Specification: Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob. Demo Input: ['4 7\n', '4 9\n', '1 1\n'] Demo Output: ['2\n', '3\n', '1\n'] Note: In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2. In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights. In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.

```python d,e=map(int,input().split()) cnt=0 while d<=e: d=d*3 e=e*2 cnt+=1 print(cnt) ```

3

268

A

Games

PROGRAMMING

800

[ "brute force" ]

null

Manao works on a sports TV. He's spent much time watching the football games of some country. After a while he began to notice different patterns. For example, each team has two sets of uniforms: home uniform and guest uniform. When a team plays a game at home, the players put on the home uniform. When a team plays as a guest on somebody else's stadium, the players put on the guest uniform. The only exception to that rule is: when the home uniform color of the host team matches the guests' uniform, the host team puts on its guest uniform as well. For each team the color of the home and guest uniform is different. There are *n* teams taking part in the national championship. The championship consists of *n*·(*n*<=-<=1) games: each team invites each other team to its stadium. At this point Manao wondered: how many times during the championship is a host team going to put on the guest uniform? Note that the order of the games does not affect this number. You know the colors of the home and guest uniform for each team. For simplicity, the colors are numbered by integers in such a way that no two distinct colors have the same number. Help Manao find the answer to his question.

The first line contains an integer *n* (2<=≤<=*n*<=≤<=30). Each of the following *n* lines contains a pair of distinct space-separated integers *h**i*, *a**i* (1<=≤<=*h**i*,<=*a**i*<=≤<=100) — the colors of the *i*-th team's home and guest uniforms, respectively.

In a single line print the number of games where the host team is going to play in the guest uniform.

[ "3\n1 2\n2 4\n3 4\n", "4\n100 42\n42 100\n5 42\n100 5\n", "2\n1 2\n1 2\n" ]

[ "1\n", "5\n", "0\n" ]

In the first test case the championship consists of 6 games. The only game with the event in question is the game between teams 2 and 1 on the stadium of team 2. In the second test sample the host team will have to wear guest uniform in the games between teams: 1 and 2, 2 and 1, 2 and 3, 3 and 4, 4 and 2 (the host team is written first).

500

[ { "input": "3\n1 2\n2 4\n3 4", "output": "1" }, { "input": "4\n100 42\n42 100\n5 42\n100 5", "output": "5" }, { "input": "2\n1 2\n1 2", "output": "0" }, { "input": "7\n4 7\n52 55\n16 4\n55 4\n20 99\n3 4\n7 52", "output": "6" }, { "input": "10\n68 42\n1 35\n25 70\n59 79\n65 63\n46 6\n28 82\n92 62\n43 96\n37 28", "output": "1" }, { "input": "30\n10 39\n89 1\n78 58\n75 99\n36 13\n77 50\n6 97\n79 28\n27 52\n56 5\n93 96\n40 21\n33 74\n26 37\n53 59\n98 56\n61 65\n42 57\n9 7\n25 63\n74 34\n96 84\n95 47\n12 23\n34 21\n71 6\n27 13\n15 47\n64 14\n12 77", "output": "6" }, { "input": "30\n46 100\n87 53\n34 84\n44 66\n23 20\n50 34\n90 66\n17 39\n13 22\n94 33\n92 46\n63 78\n26 48\n44 61\n3 19\n41 84\n62 31\n65 89\n23 28\n58 57\n19 85\n26 60\n75 66\n69 67\n76 15\n64 15\n36 72\n90 89\n42 69\n45 35", "output": "4" }, { "input": "2\n46 6\n6 46", "output": "2" }, { "input": "29\n8 18\n33 75\n69 22\n97 95\n1 97\n78 10\n88 18\n13 3\n19 64\n98 12\n79 92\n41 72\n69 15\n98 31\n57 74\n15 56\n36 37\n15 66\n63 100\n16 42\n47 56\n6 4\n73 15\n30 24\n27 71\n12 19\n88 69\n85 6\n50 11", "output": "10" }, { "input": "23\n43 78\n31 28\n58 80\n66 63\n20 4\n51 95\n40 20\n50 14\n5 34\n36 39\n77 42\n64 97\n62 89\n16 56\n8 34\n58 16\n37 35\n37 66\n8 54\n50 36\n24 8\n68 48\n85 33", "output": "6" }, { "input": "13\n76 58\n32 85\n99 79\n23 58\n96 59\n72 35\n53 43\n96 55\n41 78\n75 10\n28 11\n72 7\n52 73", "output": "0" }, { "input": "18\n6 90\n70 79\n26 52\n67 81\n29 95\n41 32\n94 88\n18 58\n59 65\n51 56\n64 68\n34 2\n6 98\n95 82\n34 2\n40 98\n83 78\n29 2", "output": "1" }, { "input": "18\n6 90\n100 79\n26 100\n67 100\n29 100\n100 32\n94 88\n18 58\n59 65\n51 56\n64 68\n34 2\n6 98\n95 82\n34 2\n40 98\n83 78\n29 100", "output": "8" }, { "input": "30\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1", "output": "450" }, { "input": "30\n100 99\n58 59\n56 57\n54 55\n52 53\n50 51\n48 49\n46 47\n44 45\n42 43\n40 41\n38 39\n36 37\n34 35\n32 33\n30 31\n28 29\n26 27\n24 25\n22 23\n20 21\n18 19\n16 17\n14 15\n12 13\n10 11\n8 9\n6 7\n4 5\n2 3", "output": "0" }, { "input": "15\n9 3\n2 6\n7 6\n5 10\n9 5\n8 1\n10 5\n2 8\n4 5\n9 8\n5 3\n3 8\n9 8\n4 10\n8 5", "output": "20" }, { "input": "15\n2 1\n1 2\n1 2\n1 2\n2 1\n2 1\n2 1\n1 2\n2 1\n2 1\n2 1\n1 2\n2 1\n2 1\n1 2", "output": "108" }, { "input": "25\n2 1\n1 2\n1 2\n1 2\n2 1\n1 2\n1 2\n1 2\n2 1\n2 1\n2 1\n1 2\n1 2\n1 2\n2 1\n2 1\n2 1\n1 2\n2 1\n1 2\n2 1\n2 1\n2 1\n2 1\n1 2", "output": "312" }, { "input": "25\n91 57\n2 73\n54 57\n2 57\n23 57\n2 6\n57 54\n57 23\n91 54\n91 23\n57 23\n91 57\n54 2\n6 91\n57 54\n2 57\n57 91\n73 91\n57 23\n91 57\n2 73\n91 2\n23 6\n2 73\n23 6", "output": "96" }, { "input": "28\n31 66\n31 91\n91 31\n97 66\n31 66\n31 66\n66 91\n91 31\n97 31\n91 97\n97 31\n66 31\n66 97\n91 31\n31 66\n31 66\n66 31\n31 97\n66 97\n97 31\n31 91\n66 91\n91 66\n31 66\n91 66\n66 31\n66 31\n91 97", "output": "210" }, { "input": "29\n78 27\n50 68\n24 26\n68 43\n38 78\n26 38\n78 28\n28 26\n27 24\n23 38\n24 26\n24 43\n61 50\n38 78\n27 23\n61 26\n27 28\n43 23\n28 78\n43 27\n43 78\n27 61\n28 38\n61 78\n50 26\n43 27\n26 78\n28 50\n43 78", "output": "73" }, { "input": "29\n80 27\n69 80\n27 80\n69 80\n80 27\n80 27\n80 27\n80 69\n27 69\n80 69\n80 27\n27 69\n69 27\n80 69\n27 69\n69 80\n27 69\n80 69\n80 27\n69 27\n27 69\n27 80\n80 27\n69 80\n27 69\n80 69\n69 80\n69 80\n27 80", "output": "277" }, { "input": "30\n19 71\n7 89\n89 71\n21 7\n19 21\n7 89\n19 71\n89 8\n89 21\n19 8\n21 7\n8 89\n19 89\n7 21\n19 8\n19 7\n7 19\n8 21\n71 21\n71 89\n7 19\n7 19\n21 7\n21 19\n21 19\n71 8\n21 8\n71 19\n19 71\n8 21", "output": "154" }, { "input": "30\n44 17\n44 17\n44 17\n17 44\n44 17\n44 17\n17 44\n17 44\n17 44\n44 17\n44 17\n44 17\n44 17\n44 17\n17 44\n17 44\n17 44\n44 17\n44 17\n17 44\n44 17\n44 17\n44 17\n17 44\n17 44\n44 17\n17 44\n44 17\n44 17\n44 17", "output": "418" }, { "input": "22\n78 92\n15 92\n92 78\n78 80\n92 16\n24 80\n92 16\n16 92\n78 16\n24 78\n80 78\n92 80\n16 80\n80 78\n15 78\n92 16\n24 15\n24 80\n80 16\n16 80\n92 80\n24 80", "output": "74" }, { "input": "24\n9 83\n90 31\n83 3\n83 3\n21 31\n83 3\n32 31\n12 21\n31 21\n90 32\n32 21\n12 9\n12 31\n9 83\n83 12\n32 3\n32 83\n90 31\n9 32\n31 21\n83 90\n32 21\n21 3\n32 9", "output": "59" }, { "input": "30\n67 21\n85 39\n85 87\n21 39\n66 85\n10 95\n10 21\n87 85\n82 21\n67 21\n95 10\n21 39\n82 21\n21 66\n66 39\n95 30\n67 85\n66 82\n85 82\n21 66\n10 39\n67 10\n21 85\n10 82\n85 95\n10 85\n21 39\n85 39\n39 10\n95 67", "output": "100" }, { "input": "4\n8 7\n8 7\n7 8\n7 8", "output": "8" }, { "input": "6\n1 2\n1 2\n1 2\n1 2\n1 2\n2 1", "output": "10" }, { "input": "12\n1 2\n1 2\n1 2\n1 2\n1 2\n1 2\n2 1\n2 1\n2 1\n2 1\n2 1\n2 1", "output": "72" }, { "input": "4\n1 2\n1 2\n2 1\n2 1", "output": "8" } ]

1,677,487,628

2,147,483,647

Python 3

OK

TESTS

31

92

0

n = int(input()) home = [] guest = {} for i in range(n): h,a = input().split() h = int(h) a = int(a) home.append(h) if guest.get(a) == None: guest[a] = 1 else: guest[a] += 1 count = 0 for i in home: if guest.get(i) != None: count += guest[i] print(count)

Title: Games Time Limit: None seconds Memory Limit: None megabytes Problem Description: Manao works on a sports TV. He's spent much time watching the football games of some country. After a while he began to notice different patterns. For example, each team has two sets of uniforms: home uniform and guest uniform. When a team plays a game at home, the players put on the home uniform. When a team plays as a guest on somebody else's stadium, the players put on the guest uniform. The only exception to that rule is: when the home uniform color of the host team matches the guests' uniform, the host team puts on its guest uniform as well. For each team the color of the home and guest uniform is different. There are *n* teams taking part in the national championship. The championship consists of *n*·(*n*<=-<=1) games: each team invites each other team to its stadium. At this point Manao wondered: how many times during the championship is a host team going to put on the guest uniform? Note that the order of the games does not affect this number. You know the colors of the home and guest uniform for each team. For simplicity, the colors are numbered by integers in such a way that no two distinct colors have the same number. Help Manao find the answer to his question. Input Specification: The first line contains an integer *n* (2<=≤<=*n*<=≤<=30). Each of the following *n* lines contains a pair of distinct space-separated integers *h**i*, *a**i* (1<=≤<=*h**i*,<=*a**i*<=≤<=100) — the colors of the *i*-th team's home and guest uniforms, respectively. Output Specification: In a single line print the number of games where the host team is going to play in the guest uniform. Demo Input: ['3\n1 2\n2 4\n3 4\n', '4\n100 42\n42 100\n5 42\n100 5\n', '2\n1 2\n1 2\n'] Demo Output: ['1\n', '5\n', '0\n'] Note: In the first test case the championship consists of 6 games. The only game with the event in question is the game between teams 2 and 1 on the stadium of team 2. In the second test sample the host team will have to wear guest uniform in the games between teams: 1 and 2, 2 and 1, 2 and 3, 3 and 4, 4 and 2 (the host team is written first).

```python n = int(input()) home = [] guest = {} for i in range(n): h,a = input().split() h = int(h) a = int(a) home.append(h) if guest.get(a) == None: guest[a] = 1 else: guest[a] += 1 count = 0 for i in home: if guest.get(i) != None: count += guest[i] print(count) ```

3

318

A

Even Odds

PROGRAMMING

900

[ "math" ]

null

Being a nonconformist, Volodya is displeased with the current state of things, particularly with the order of natural numbers (natural number is positive integer number). He is determined to rearrange them. But there are too many natural numbers, so Volodya decided to start with the first *n*. He writes down the following sequence of numbers: firstly all odd integers from 1 to *n* (in ascending order), then all even integers from 1 to *n* (also in ascending order). Help our hero to find out which number will stand at the position number *k*.

The only line of input contains integers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=1012). Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.

Print the number that will stand at the position number *k* after Volodya's manipulations.

[ "10 3\n", "7 7\n" ]

[ "5", "6" ]

In the first sample Volodya's sequence will look like this: {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}. The third place in the sequence is therefore occupied by the number 5.

500

[ { "input": "10 3", "output": "5" }, { "input": "7 7", "output": "6" }, { "input": "7 1", "output": "1" }, { "input": "7 2", "output": "3" }, { "input": "8 5", "output": "2" }, { "input": "8 3", "output": "5" }, { "input": "8 4", "output": "7" }, { "input": "1000000000000 500000000001", "output": "2" }, { "input": "999999999997 499999999999", "output": "999999999997" }, { "input": "999999999999 999999999999", "output": "999999999998" }, { "input": "1000000000000 1", "output": "1" }, { "input": "999999999999 1", "output": "1" }, { "input": "1 1", "output": "1" }, { "input": "1000000000000 1000000000000", "output": "1000000000000" }, { "input": "1000000000000 500000000000", "output": "999999999999" }, { "input": "1000000000000 499999999999", "output": "999999999997" }, { "input": "999999999997 499999999998", "output": "999999999995" }, { "input": "619234238 556154835", "output": "493075432" }, { "input": "38151981 36650624", "output": "35149266" }, { "input": "680402465 442571217", "output": "204739968" }, { "input": "109135284 9408714", "output": "18817427" }, { "input": "603701841 56038951", "output": "112077901" }, { "input": "356764822 321510177", "output": "286255532" }, { "input": "284911189 142190783", "output": "284381565" }, { "input": "91028405 61435545", "output": "31842684" } ]

1,696,044,005

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

4

62

0

limit, idx = input().split() limit, idx = int(limit), int(idx) if idx>limit/2: idx -= int(limit/2)+1 print(2*idx) else: print(2*idx-1)

Title: Even Odds Time Limit: None seconds Memory Limit: None megabytes Problem Description: Being a nonconformist, Volodya is displeased with the current state of things, particularly with the order of natural numbers (natural number is positive integer number). He is determined to rearrange them. But there are too many natural numbers, so Volodya decided to start with the first *n*. He writes down the following sequence of numbers: firstly all odd integers from 1 to *n* (in ascending order), then all even integers from 1 to *n* (also in ascending order). Help our hero to find out which number will stand at the position number *k*. Input Specification: The only line of input contains integers *n* and *k* (1<=≤<=*k*<=≤<=*n*<=≤<=1012). Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier. Output Specification: Print the number that will stand at the position number *k* after Volodya's manipulations. Demo Input: ['10 3\n', '7 7\n'] Demo Output: ['5', '6'] Note: In the first sample Volodya's sequence will look like this: {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}. The third place in the sequence is therefore occupied by the number 5.

```python limit, idx = input().split() limit, idx = int(limit), int(idx) if idx>limit/2: idx -= int(limit/2)+1 print(2*idx) else: print(2*idx-1) ```

0

322

A

Ciel and Dancing

PROGRAMMING

1,000

[ "greedy" ]

null

Fox Ciel and her friends are in a dancing room. There are *n* boys and *m* girls here, and they never danced before. There will be some songs, during each song, there must be exactly one boy and one girl are dancing. Besides, there is a special rule: - either the boy in the dancing pair must dance for the first time (so, he didn't dance with anyone before); - or the girl in the dancing pair must dance for the first time. Help Fox Ciel to make a schedule that they can dance as many songs as possible.

The first line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of boys and girls in the dancing room.

In the first line print *k* — the number of songs during which they can dance. Then in the following *k* lines, print the indexes of boys and girls dancing during songs chronologically. You can assume that the boys are indexed from 1 to *n*, and the girls are indexed from 1 to *m*.

[ "2 1\n", "2 2\n" ]

[ "2\n1 1\n2 1\n", "3\n1 1\n1 2\n2 2\n" ]

In test case 1, there are 2 boys and 1 girl. We can have 2 dances: the 1st boy and 1st girl (during the first song), the 2nd boy and 1st girl (during the second song). And in test case 2, we have 2 boys with 2 girls, the answer is 3.

500

[ { "input": "2 1", "output": "2\n1 1\n2 1" }, { "input": "2 2", "output": "3\n1 1\n1 2\n2 2" }, { "input": "1 1", "output": "1\n1 1" }, { "input": "2 3", "output": "4\n1 1\n1 2\n1 3\n2 3" }, { "input": "4 4", "output": "7\n1 1\n1 2\n1 3\n1 4\n4 4\n3 4\n2 4" }, { "input": "1 12", "output": "12\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12" }, { "input": "12 1", "output": "12\n1 1\n12 1\n11 1\n10 1\n9 1\n8 1\n7 1\n6 1\n5 1\n4 1\n3 1\n2 1" }, { "input": "100 100", "output": "199\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "24 6", "output": "29\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n24 6\n23 6\n22 6\n21 6\n20 6\n19 6\n18 6\n17 6\n16 6\n15 6\n14 6\n13 6\n12 6\n11 6\n10 6\n9 6\n8 6\n7 6\n6 6\n5 6\n4 6\n3 6\n2 6" }, { "input": "7 59", "output": "65\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n7 59\n6 59\n5 59\n4 59\n3 59\n2 59" }, { "input": "26 75", "output": "100\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n26 75\n25 75\n24 75\n23 75\n22 75\n21 75\n20 75\n19 75\n18 75\n17..." }, { "input": "32 87", "output": "118\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "42 51", "output": "92\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n42 51\n41 51\n40 51\n39 51\n38 51\n37 51\n36 51\n35 51\n34 51\n33 51\n32 51\n31 51\n30 51\n29 51\n28 51\n27 51\n26 51\n25 51\n24 51\n23 51\n22 51\n21 51\n20 51\n19 51\n18 51\n17 51\n16 51\n15 51\n14 51\n13 51\n..." }, { "input": "4 63", "output": "66\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n4 63\n3 63\n2 63" }, { "input": "10 79", "output": "88\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n10 79\n9 79\n8 79\n7 79\n6 79\n5 79\n4 79\n..." }, { "input": "20 95", "output": "114\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "35 55", "output": "89\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n35 55\n34 55\n33 55\n32 55\n31 55\n30 55\n29 55\n28 55\n27 55\n26 55\n25 55\n24 55\n23 55\n22 55\n21 55\n20 55\n19 55\n18 55\n17 55\n16 55\n15 55\n14 55\n13 55\n12 55\n11 55\n10 55\n9 55..." }, { "input": "45 71", "output": "115\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n45 71\n44 71\n43 71\n42 71\n41 71\n40 71\n39 71\n38 71\n37 71\n36 71\n35 71\n34 71\n33 71..." }, { "input": "7 83", "output": "89\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n7 83\n6 83\n5 83\n..." }, { "input": "32 100", "output": "131\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "42 17", "output": "58\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n42 17\n41 17\n40 17\n39 17\n38 17\n37 17\n36 17\n35 17\n34 17\n33 17\n32 17\n31 17\n30 17\n29 17\n28 17\n27 17\n26 17\n25 17\n24 17\n23 17\n22 17\n21 17\n20 17\n19 17\n18 17\n17 17\n16 17\n15 17\n14 17\n13 17\n12 17\n11 17\n10 17\n9 17\n8 17\n7 17\n6 17\n5 17\n4 17\n3 17\n2 17" }, { "input": "1 77", "output": "77\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77" }, { "input": "19 93", "output": "111\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "25 5", "output": "29\n1 1\n1 2\n1 3\n1 4\n1 5\n25 5\n24 5\n23 5\n22 5\n21 5\n20 5\n19 5\n18 5\n17 5\n16 5\n15 5\n14 5\n13 5\n12 5\n11 5\n10 5\n9 5\n8 5\n7 5\n6 5\n5 5\n4 5\n3 5\n2 5" }, { "input": "35 21", "output": "55\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n35 21\n34 21\n33 21\n32 21\n31 21\n30 21\n29 21\n28 21\n27 21\n26 21\n25 21\n24 21\n23 21\n22 21\n21 21\n20 21\n19 21\n18 21\n17 21\n16 21\n15 21\n14 21\n13 21\n12 21\n11 21\n10 21\n9 21\n8 21\n7 21\n6 21\n5 21\n4 21\n3 21\n2 21" }, { "input": "99 99", "output": "197\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "99 100", "output": "198\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." }, { "input": "100 99", "output": "198\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n1 11\n1 12\n1 13\n1 14\n1 15\n1 16\n1 17\n1 18\n1 19\n1 20\n1 21\n1 22\n1 23\n1 24\n1 25\n1 26\n1 27\n1 28\n1 29\n1 30\n1 31\n1 32\n1 33\n1 34\n1 35\n1 36\n1 37\n1 38\n1 39\n1 40\n1 41\n1 42\n1 43\n1 44\n1 45\n1 46\n1 47\n1 48\n1 49\n1 50\n1 51\n1 52\n1 53\n1 54\n1 55\n1 56\n1 57\n1 58\n1 59\n1 60\n1 61\n1 62\n1 63\n1 64\n1 65\n1 66\n1 67\n1 68\n1 69\n1 70\n1 71\n1 72\n1 73\n1 74\n1 75\n1 76\n1 77\n1 78\n1 79\n1 80\n1 81\n1 82\n1 83\n1 84\n1 85\n1 86\n..." } ]

1,569,616,023

2,147,483,647

Python 3

OK

TESTS

28

248

0

n,m=map(int,input().split()) print(m+n-1) for i in range(1,m+1): print(1,i) for i in range(2,n+1): print(i,1)

Title: Ciel and Dancing Time Limit: None seconds Memory Limit: None megabytes Problem Description: Fox Ciel and her friends are in a dancing room. There are *n* boys and *m* girls here, and they never danced before. There will be some songs, during each song, there must be exactly one boy and one girl are dancing. Besides, there is a special rule: - either the boy in the dancing pair must dance for the first time (so, he didn't dance with anyone before); - or the girl in the dancing pair must dance for the first time. Help Fox Ciel to make a schedule that they can dance as many songs as possible. Input Specification: The first line contains two integers *n* and *m* (1<=≤<=*n*,<=*m*<=≤<=100) — the number of boys and girls in the dancing room. Output Specification: In the first line print *k* — the number of songs during which they can dance. Then in the following *k* lines, print the indexes of boys and girls dancing during songs chronologically. You can assume that the boys are indexed from 1 to *n*, and the girls are indexed from 1 to *m*. Demo Input: ['2 1\n', '2 2\n'] Demo Output: ['2\n1 1\n2 1\n', '3\n1 1\n1 2\n2 2\n'] Note: In test case 1, there are 2 boys and 1 girl. We can have 2 dances: the 1st boy and 1st girl (during the first song), the 2nd boy and 1st girl (during the second song). And in test case 2, we have 2 boys with 2 girls, the answer is 3.

```python n,m=map(int,input().split()) print(m+n-1) for i in range(1,m+1): print(1,i) for i in range(2,n+1): print(i,1) ```

3

4

A

Watermelon

PROGRAMMING

800

[ "brute force", "math" ]

A. Watermelon

1

64

One hot summer day Pete and his friend Billy decided to buy a watermelon. They chose the biggest and the ripest one, in their opinion. After that the watermelon was weighed, and the scales showed *w* kilos. They rushed home, dying of thirst, and decided to divide the berry, however they faced a hard problem. Pete and Billy are great fans of even numbers, that's why they want to divide the watermelon in such a way that each of the two parts weighs even number of kilos, at the same time it is not obligatory that the parts are equal. The boys are extremely tired and want to start their meal as soon as possible, that's why you should help them and find out, if they can divide the watermelon in the way they want. For sure, each of them should get a part of positive weight.

The first (and the only) input line contains integer number *w* (1<=≤<=*w*<=≤<=100) — the weight of the watermelon bought by the boys.

Print YES, if the boys can divide the watermelon into two parts, each of them weighing even number of kilos; and NO in the opposite case.

[ "8\n" ]

[ "YES\n" ]

For example, the boys can divide the watermelon into two parts of 2 and 6 kilos respectively (another variant — two parts of 4 and 4 kilos).

0

[ { "input": "8", "output": "YES" }, { "input": "5", "output": "NO" }, { "input": "4", "output": "YES" }, { "input": "3", "output": "NO" }, { "input": "2", "output": "NO" }, { "input": "1", "output": "NO" }, { "input": "7", "output": "NO" }, { "input": "6", "output": "YES" }, { "input": "10", "output": "YES" }, { "input": "9", "output": "NO" }, { "input": "53", "output": "NO" }, { "input": "77", "output": "NO" }, { "input": "32", "output": "YES" }, { "input": "44", "output": "YES" }, { "input": "98", "output": "YES" }, { "input": "99", "output": "NO" }, { "input": "90", "output": "YES" }, { "input": "67", "output": "NO" }, { "input": "100", "output": "YES" }, { "input": "88", "output": "YES" } ]

1,694,517,768

2,147,483,647

Python 3

COMPILATION_ERROR

TESTS

0

weight = int(input()) chasti = int(input()) if chasti % 2 ==0: if weight % chasti == 0: print("Yes") else: print("No")

Title: Watermelon Time Limit: 1 seconds Memory Limit: 64 megabytes Problem Description: One hot summer day Pete and his friend Billy decided to buy a watermelon. They chose the biggest and the ripest one, in their opinion. After that the watermelon was weighed, and the scales showed *w* kilos. They rushed home, dying of thirst, and decided to divide the berry, however they faced a hard problem. Pete and Billy are great fans of even numbers, that's why they want to divide the watermelon in such a way that each of the two parts weighs even number of kilos, at the same time it is not obligatory that the parts are equal. The boys are extremely tired and want to start their meal as soon as possible, that's why you should help them and find out, if they can divide the watermelon in the way they want. For sure, each of them should get a part of positive weight. Input Specification: The first (and the only) input line contains integer number *w* (1<=≤<=*w*<=≤<=100) — the weight of the watermelon bought by the boys. Output Specification: Print YES, if the boys can divide the watermelon into two parts, each of them weighing even number of kilos; and NO in the opposite case. Demo Input: ['8\n'] Demo Output: ['YES\n'] Note: For example, the boys can divide the watermelon into two parts of 2 and 6 kilos respectively (another variant — two parts of 4 and 4 kilos).

```python weight = int(input()) chasti = int(input()) if chasti % 2 ==0: if weight % chasti == 0: print("Yes") else: print("No") ```

-1

602

B

Approximating a Constant Range

PROGRAMMING

1,400

[ "dp", "implementation", "two pointers" ]

null

When Xellos was doing a practice course in university, he once had to measure the intensity of an effect that slowly approached equilibrium. A good way to determine the equilibrium intensity would be choosing a sufficiently large number of consecutive data points that seems as constant as possible and taking their average. Of course, with the usual sizes of data, it's nothing challenging — but why not make a similar programming contest problem while we're at it? You're given a sequence of *n* data points *a*1,<=...,<=*a**n*. There aren't any big jumps between consecutive data points — for each 1<=≤<=*i*<=<<=*n*, it's guaranteed that |*a**i*<=+<=1<=-<=*a**i*|<=≤<=1. A range [*l*,<=*r*] of data points is said to be almost constant if the difference between the largest and the smallest value in that range is at most 1. Formally, let *M* be the maximum and *m* the minimum value of *a**i* for *l*<=≤<=*i*<=≤<=*r*; the range [*l*,<=*r*] is almost constant if *M*<=-<=*m*<=≤<=1. Find the length of the longest almost constant range.

The first line of the input contains a single integer *n* (2<=≤<=*n*<=≤<=100<=000) — the number of data points. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=100<=000).

Print a single number — the maximum length of an almost constant range of the given sequence.

[ "5\n1 2 3 3 2\n", "11\n5 4 5 5 6 7 8 8 8 7 6\n" ]

[ "4\n", "5\n" ]

In the first sample, the longest almost constant range is [2, 5]; its length (the number of data points in it) is 4. In the second sample, there are three almost constant ranges of length 4: [1, 4], [6, 9] and [7, 10]; the only almost constant range of the maximum length 5 is [6, 10].

1,000

[ { "input": "5\n1 2 3 3 2", "output": "4" }, { "input": "11\n5 4 5 5 6 7 8 8 8 7 6", "output": "5" }, { "input": "2\n3 2", "output": "2" }, { "input": "4\n1001 1000 1000 1001", "output": "4" }, { "input": "4\n1 1 2 3", "output": "3" }, { "input": "3\n1 2 1", "output": "3" }, { "input": "3\n1 2 3", "output": "2" }, { "input": "18\n10 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9", "output": "3" }, { "input": "3\n1 2 2", "output": "3" }, { "input": "4\n10 9 10 9", "output": "4" }, { "input": "4\n4 3 2 3", "output": "3" }, { "input": "4\n8 8 7 7", "output": "4" }, { "input": "3\n99998 99999 100000", "output": "2" }, { "input": "3\n100000 99999 99998", "output": "2" }, { "input": "3\n1 1 1", "output": "3" }, { "input": "2\n99999 100000", "output": "2" }, { "input": "2\n100000 100000", "output": "2" }, { "input": "2\n1 1", "output": "2" }, { "input": "15\n1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000", "output": "15" } ]

1,679,262,119

2,147,483,647

Python 3

OK

TESTS

107

264

7,065,600

n = int(input()) a = [int(x) for x in input().split()] d = {} for x in a: d[x] = 0 ans = 0 j = 0 m = 0 for i in range(n): while j < n and m <= 2: if d[a[j]] == 0 and m == 2: break elif d[a[j]] == 0: m += 1 d[a[j]] += 1 j += 1 ans = max(ans, j - i) d[a[i]] -= 1 if d[a[i]] == 0: m -= 1 print(ans)

Title: Approximating a Constant Range Time Limit: None seconds Memory Limit: None megabytes Problem Description: When Xellos was doing a practice course in university, he once had to measure the intensity of an effect that slowly approached equilibrium. A good way to determine the equilibrium intensity would be choosing a sufficiently large number of consecutive data points that seems as constant as possible and taking their average. Of course, with the usual sizes of data, it's nothing challenging — but why not make a similar programming contest problem while we're at it? You're given a sequence of *n* data points *a*1,<=...,<=*a**n*. There aren't any big jumps between consecutive data points — for each 1<=≤<=*i*<=<<=*n*, it's guaranteed that |*a**i*<=+<=1<=-<=*a**i*|<=≤<=1. A range [*l*,<=*r*] of data points is said to be almost constant if the difference between the largest and the smallest value in that range is at most 1. Formally, let *M* be the maximum and *m* the minimum value of *a**i* for *l*<=≤<=*i*<=≤<=*r*; the range [*l*,<=*r*] is almost constant if *M*<=-<=*m*<=≤<=1. Find the length of the longest almost constant range. Input Specification: The first line of the input contains a single integer *n* (2<=≤<=*n*<=≤<=100<=000) — the number of data points. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=100<=000). Output Specification: Print a single number — the maximum length of an almost constant range of the given sequence. Demo Input: ['5\n1 2 3 3 2\n', '11\n5 4 5 5 6 7 8 8 8 7 6\n'] Demo Output: ['4\n', '5\n'] Note: In the first sample, the longest almost constant range is [2, 5]; its length (the number of data points in it) is 4. In the second sample, there are three almost constant ranges of length 4: [1, 4], [6, 9] and [7, 10]; the only almost constant range of the maximum length 5 is [6, 10].

```python n = int(input()) a = [int(x) for x in input().split()] d = {} for x in a: d[x] = 0 ans = 0 j = 0 m = 0 for i in range(n): while j < n and m <= 2: if d[a[j]] == 0 and m == 2: break elif d[a[j]] == 0: m += 1 d[a[j]] += 1 j += 1 ans = max(ans, j - i) d[a[i]] -= 1 if d[a[i]] == 0: m -= 1 print(ans) ```

3

899

C

Dividing the numbers

PROGRAMMING

1,300

[ "constructive algorithms", "graphs", "math" ]

null

Petya has *n* integers: 1,<=2,<=3,<=...,<=*n*. He wants to split these integers in two non-empty groups in such a way that the absolute difference of sums of integers in each group is as small as possible. Help Petya to split the integers. Each of *n* integers should be exactly in one group.

The first line contains a single integer *n* (2<=≤<=*n*<=≤<=60<=000) — the number of integers Petya has.

Print the smallest possible absolute difference in the first line. In the second line print the size of the first group, followed by the integers in that group. You can print these integers in arbitrary order. If there are multiple answers, print any of them.

[ "4\n", "2\n" ]

[ "0\n2 1 4 \n", "1\n1 1 \n" ]

In the first example you have to put integers 1 and 4 in the first group, and 2 and 3 in the second. This way the sum in each group is 5, and the absolute difference is 0. In the second example there are only two integers, and since both groups should be non-empty, you have to put one integer in the first group and one in the second. This way the absolute difference of sums of integers in each group is 1.

1,500

[ { "input": "4", "output": "0\n2 1 4 " }, { "input": "2", "output": "1\n1 1 " }, { "input": "3", "output": "0\n1\n3 " }, { "input": "5", "output": "1\n3\n1 2 5 " }, { "input": "59998", "output": "1\n29999 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 ..." }, { "input": "60000", "output": "0\n30000 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 ..." }, { "input": "59991", "output": "0\n29995\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "59989", "output": "1\n29995\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "6", "output": "1\n3 1 4 5 " }, { "input": "7", "output": "0\n3\n1 6 7 " }, { "input": "8", "output": "0\n4 1 4 5 8 " }, { "input": "9", "output": "1\n5\n1 2 3 8 9 " }, { "input": "10", "output": "1\n5 1 4 5 8 9 " }, { "input": "11", "output": "0\n5\n1 2 9 10 11 " }, { "input": "12", "output": "0\n6 1 4 5 8 9 12 " }, { "input": "13", "output": "1\n7\n1 2 3 4 11 12 13 " }, { "input": "14", "output": "1\n7 1 4 5 8 9 12 13 " }, { "input": "15", "output": "0\n7\n1 2 3 12 13 14 15 " }, { "input": "16", "output": "0\n8 1 4 5 8 9 12 13 16 " }, { "input": "17", "output": "1\n9\n1 2 3 4 5 14 15 16 17 " }, { "input": "18", "output": "1\n9 1 4 5 8 9 12 13 16 17 " }, { "input": "19", "output": "0\n9\n1 2 3 4 15 16 17 18 19 " }, { "input": "20", "output": "0\n10 1 4 5 8 9 12 13 16 17 20 " }, { "input": "21", "output": "1\n11\n1 2 3 4 5 6 17 18 19 20 21 " }, { "input": "22", "output": "1\n11 1 4 5 8 9 12 13 16 17 20 21 " }, { "input": "23", "output": "0\n11\n1 2 3 4 5 18 19 20 21 22 23 " }, { "input": "24", "output": "0\n12 1 4 5 8 9 12 13 16 17 20 21 24 " }, { "input": "59999", "output": "0\n29999\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "59997", "output": "1\n29999\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "59996", "output": "0\n29998 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 ..." }, { "input": "59995", "output": "0\n29997\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "59994", "output": "1\n29997 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 ..." }, { "input": "59993", "output": "1\n29997\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "59992", "output": "0\n29996 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 ..." }, { "input": "59990", "output": "1\n29995 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 ..." }, { "input": "100", "output": "0\n50 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 " }, { "input": "1000", "output": "0\n500 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 28..." }, { "input": "10001", "output": "1\n5001\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 15..." }, { "input": "103", "output": "0\n51\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 " }, { "input": "1002", "output": "1\n501 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 28..." }, { "input": "31724", "output": "0\n15862 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 ..." }, { "input": "2032", "output": "0\n1016 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 2..." }, { "input": "42620", "output": "0\n21310 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 ..." }, { "input": "18076", "output": "0\n9038 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 2..." }, { "input": "53520", "output": "0\n26760 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 ..." }, { "input": "37193", "output": "1\n18597\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "12645", "output": "1\n6323\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 15..." }, { "input": "53237", "output": "1\n26619\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "28693", "output": "1\n14347\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "4145", "output": "1\n2073\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 15..." }, { "input": "36042", "output": "1\n18021 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 ..." }, { "input": "16646", "output": "1\n8323 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 2..." }, { "input": "57238", "output": "1\n28619 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 ..." }, { "input": "27542", "output": "1\n13771 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 ..." }, { "input": "8146", "output": "1\n4073 1 4 5 8 9 12 13 16 17 20 21 24 25 28 29 32 33 36 37 40 41 44 45 48 49 52 53 56 57 60 61 64 65 68 69 72 73 76 77 80 81 84 85 88 89 92 93 96 97 100 101 104 105 108 109 112 113 116 117 120 121 124 125 128 129 132 133 136 137 140 141 144 145 148 149 152 153 156 157 160 161 164 165 168 169 172 173 176 177 180 181 184 185 188 189 192 193 196 197 200 201 204 205 208 209 212 213 216 217 220 221 224 225 228 229 232 233 236 237 240 241 244 245 248 249 252 253 256 257 260 261 264 265 268 269 272 273 276 277 2..." }, { "input": "46659", "output": "0\n23329\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "27259", "output": "0\n13629\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "2715", "output": "0\n1357\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 15..." }, { "input": "38159", "output": "0\n19079\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 1..." }, { "input": "18759", "output": "0\n9379\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 15..." } ]

1,685,465,445

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

2

31

0

import sys input = sys.stdin.readline for _ in range(1):#int(input())): n = int(input()) a = [] if (n % 4 == 0 or n % 4 == 2): for i in range(1,n+1): if (i % 4 == 0 or i % 4 == 1): a.append(i) if (n % 4 == 0): print(0) else: print(1) elif (n % 2 == 3): for i in range(n-int(n/4), n-1, -1): a.append(i) print(0) else: for i in range(n-int(n/4)+1, n-1, -1): a.append(i) print(1) print(len(a), *a)

Title: Dividing the numbers Time Limit: None seconds Memory Limit: None megabytes Problem Description: Petya has *n* integers: 1,<=2,<=3,<=...,<=*n*. He wants to split these integers in two non-empty groups in such a way that the absolute difference of sums of integers in each group is as small as possible. Help Petya to split the integers. Each of *n* integers should be exactly in one group. Input Specification: The first line contains a single integer *n* (2<=≤<=*n*<=≤<=60<=000) — the number of integers Petya has. Output Specification: Print the smallest possible absolute difference in the first line. In the second line print the size of the first group, followed by the integers in that group. You can print these integers in arbitrary order. If there are multiple answers, print any of them. Demo Input: ['4\n', '2\n'] Demo Output: ['0\n2 1 4 \n', '1\n1 1 \n'] Note: In the first example you have to put integers 1 and 4 in the first group, and 2 and 3 in the second. This way the sum in each group is 5, and the absolute difference is 0. In the second example there are only two integers, and since both groups should be non-empty, you have to put one integer in the first group and one in the second. This way the absolute difference of sums of integers in each group is 1.

```python import sys input = sys.stdin.readline for _ in range(1):#int(input())): n = int(input()) a = [] if (n % 4 == 0 or n % 4 == 2): for i in range(1,n+1): if (i % 4 == 0 or i % 4 == 1): a.append(i) if (n % 4 == 0): print(0) else: print(1) elif (n % 2 == 3): for i in range(n-int(n/4), n-1, -1): a.append(i) print(0) else: for i in range(n-int(n/4)+1, n-1, -1): a.append(i) print(1) print(len(a), *a) ```

0

340

A

The Wall

PROGRAMMING

1,200

[ "math" ]

null

Iahub and his friend Floyd have started painting a wall. Iahub is painting the wall red and Floyd is painting it pink. You can consider the wall being made of a very large number of bricks, numbered 1, 2, 3 and so on. Iahub has the following scheme of painting: he skips *x*<=-<=1 consecutive bricks, then he paints the *x*-th one. That is, he'll paint bricks *x*, 2·*x*, 3·*x* and so on red. Similarly, Floyd skips *y*<=-<=1 consecutive bricks, then he paints the *y*-th one. Hence he'll paint bricks *y*, 2·*y*, 3·*y* and so on pink. After painting the wall all day, the boys observed that some bricks are painted both red and pink. Iahub has a lucky number *a* and Floyd has a lucky number *b*. Boys wonder how many bricks numbered no less than *a* and no greater than *b* are painted both red and pink. This is exactly your task: compute and print the answer to the question.

The input will have a single line containing four integers in this order: *x*, *y*, *a*, *b*. (1<=≤<=*x*,<=*y*<=≤<=1000, 1<=≤<=*a*,<=*b*<=≤<=2·109, *a*<=≤<=*b*).

Output a single integer — the number of bricks numbered no less than *a* and no greater than *b* that are painted both red and pink.

[ "2 3 6 18\n" ]

[ "3" ]

Let's look at the bricks from *a* to *b* (*a* = 6, *b* = 18). The bricks colored in red are numbered 6, 8, 10, 12, 14, 16, 18. The bricks colored in pink are numbered 6, 9, 12, 15, 18. The bricks colored in both red and pink are numbered with 6, 12 and 18.

500

[ { "input": "2 3 6 18", "output": "3" }, { "input": "4 6 20 201", "output": "15" }, { "input": "15 27 100 10000", "output": "74" }, { "input": "105 60 3456 78910", "output": "179" }, { "input": "1 1 1000 100000", "output": "99001" }, { "input": "3 2 5 5", "output": "0" }, { "input": "555 777 1 1000000", "output": "257" }, { "input": "1000 1000 1 32323", "output": "32" }, { "input": "45 125 93451125 100000000", "output": "5821" }, { "input": "101 171 1 1000000000", "output": "57900" }, { "input": "165 255 69696 1000000000", "output": "356482" }, { "input": "555 777 666013 1000000000", "output": "257229" }, { "input": "23 46 123321 900000000", "output": "19562537" }, { "input": "321 123 15 1000000", "output": "75" }, { "input": "819 1000 9532 152901000", "output": "186" }, { "input": "819 1000 10000 1000000", "output": "1" }, { "input": "1 1 1 1", "output": "1" }, { "input": "1 2 2 1000003", "output": "500001" }, { "input": "1 1 1 1000000000", "output": "1000000000" }, { "input": "10 15 69 195610342", "output": "6520342" }, { "input": "2 1 1 1000000000", "output": "500000000" }, { "input": "1000 1000 1 20", "output": "0" }, { "input": "1 1 1 2000000000", "output": "2000000000" }, { "input": "1 2 1 2000000000", "output": "1000000000" }, { "input": "2 1 1 2000000000", "output": "1000000000" }, { "input": "2 3 1 1000000000", "output": "166666666" }, { "input": "2 3 1 2000000000", "output": "333333333" }, { "input": "3 7 1 1000000000", "output": "47619047" }, { "input": "1 1 1000000000 2000000000", "output": "1000000001" }, { "input": "2 2 1 2000000000", "output": "1000000000" }, { "input": "1 1 2 2000000000", "output": "1999999999" }, { "input": "3 2 1 2000000000", "output": "333333333" }, { "input": "1 1 2000000000 2000000000", "output": "1" }, { "input": "2 3 7 7", "output": "0" }, { "input": "3 3 3 7", "output": "2" } ]

1,477,086,194

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

60

0

x,y,a,b = map(int,input().split()) if a % x == 0 : start = a else : start = (a//x +1)*x n = 0 while start <= b : if start % y == 0 : n += 1 start += x print(b)

Title: The Wall Time Limit: None seconds Memory Limit: None megabytes Problem Description: Iahub and his friend Floyd have started painting a wall. Iahub is painting the wall red and Floyd is painting it pink. You can consider the wall being made of a very large number of bricks, numbered 1, 2, 3 and so on. Iahub has the following scheme of painting: he skips *x*<=-<=1 consecutive bricks, then he paints the *x*-th one. That is, he'll paint bricks *x*, 2·*x*, 3·*x* and so on red. Similarly, Floyd skips *y*<=-<=1 consecutive bricks, then he paints the *y*-th one. Hence he'll paint bricks *y*, 2·*y*, 3·*y* and so on pink. After painting the wall all day, the boys observed that some bricks are painted both red and pink. Iahub has a lucky number *a* and Floyd has a lucky number *b*. Boys wonder how many bricks numbered no less than *a* and no greater than *b* are painted both red and pink. This is exactly your task: compute and print the answer to the question. Input Specification: The input will have a single line containing four integers in this order: *x*, *y*, *a*, *b*. (1<=≤<=*x*,<=*y*<=≤<=1000, 1<=≤<=*a*,<=*b*<=≤<=2·109, *a*<=≤<=*b*). Output Specification: Output a single integer — the number of bricks numbered no less than *a* and no greater than *b* that are painted both red and pink. Demo Input: ['2 3 6 18\n'] Demo Output: ['3'] Note: Let's look at the bricks from *a* to *b* (*a* = 6, *b* = 18). The bricks colored in red are numbered 6, 8, 10, 12, 14, 16, 18. The bricks colored in pink are numbered 6, 9, 12, 15, 18. The bricks colored in both red and pink are numbered with 6, 12 and 18.

```python x,y,a,b = map(int,input().split()) if a % x == 0 : start = a else : start = (a//x +1)*x n = 0 while start <= b : if start % y == 0 : n += 1 start += x print(b) ```

0

992

A

Nastya and an Array

PROGRAMMING

800

[ "implementation", "sortings" ]

null

Nastya owns too many arrays now, so she wants to delete the least important of them. However, she discovered that this array is magic! Nastya now knows that the array has the following properties: - In one second we can add an arbitrary (possibly negative) integer to all elements of the array that are not equal to zero. - When all elements of the array become equal to zero, the array explodes. Nastya is always busy, so she wants to explode the array as fast as possible. Compute the minimum time in which the array can be exploded.

The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105) — the size of the array. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=105<=≤<=*a**i*<=≤<=105) — the elements of the array.

Print a single integer — the minimum number of seconds needed to make all elements of the array equal to zero.

[ "5\n1 1 1 1 1\n", "3\n2 0 -1\n", "4\n5 -6 -5 1\n" ]

[ "1\n", "2\n", "4\n" ]

In the first example you can add - 1 to all non-zero elements in one second and make them equal to zero. In the second example you can add - 2 on the first second, then the array becomes equal to [0, 0, - 3]. On the second second you can add 3 to the third (the only non-zero) element.

500

[ { "input": "5\n1 1 1 1 1", "output": "1" }, { "input": "3\n2 0 -1", "output": "2" }, { "input": "4\n5 -6 -5 1", "output": "4" }, { "input": "1\n0", "output": "0" }, { "input": "2\n21794 -79194", "output": "2" }, { "input": "3\n-63526 95085 -5239", "output": "3" }, { "input": "3\n0 53372 -20572", "output": "2" }, { "input": "13\n-2075 -32242 27034 -37618 -96962 82203 64846 48249 -71761 28908 -21222 -61370 46899", "output": "13" }, { "input": "5\n806 0 1308 1954 683", "output": "4" }, { "input": "8\n-26 0 -249 -289 -126 -206 288 -11", "output": "7" }, { "input": "10\n2 2 2 1 2 -1 0 2 -1 1", "output": "3" }, { "input": "1\n8", "output": "1" }, { "input": "3\n0 0 0", "output": "0" }, { "input": "10\n1 2 3 4 5 6 7 8 9 10", "output": "10" }, { "input": "5\n2 0 -1 0 0", "output": "2" }, { "input": "2\n0 0", "output": "0" }, { "input": "5\n0 0 0 0 0", "output": "0" }, { "input": "2\n1 0", "output": "1" }, { "input": "2\n-1 0", "output": "1" }, { "input": "4\n0 0 0 0", "output": "0" }, { "input": "8\n10 9 -1 0 0 3 2 3", "output": "5" }, { "input": "5\n5 0 1 2 3", "output": "4" }, { "input": "3\n1 1 0", "output": "1" }, { "input": "1\n-1", "output": "1" }, { "input": "5\n1 2 0 0 0", "output": "2" }, { "input": "5\n1 0 0 0 0", "output": "1" }, { "input": "5\n4 5 6 0 0", "output": "3" }, { "input": "4\n-1 0 0 1", "output": "2" }, { "input": "5\n3 0 0 4 5", "output": "3" }, { "input": "3\n0 0 2", "output": "1" }, { "input": "3\n1 0 0", "output": "1" }, { "input": "4\n0 0 0 4", "output": "1" }, { "input": "5\n-1 0 0 0 0", "output": "1" }, { "input": "2\n0 1", "output": "1" }, { "input": "3\n1 2 3", "output": "3" }, { "input": "1\n5", "output": "1" }, { "input": "10\n0 0 0 0 0 1 2 3 0 0", "output": "3" }, { "input": "4\n0 1 2 3", "output": "3" }, { "input": "3\n0 1 2", "output": "2" }, { "input": "4\n2 0 0 -1", "output": "2" } ]

1,619,520,922

2,147,483,647

Python 3

OK

TESTS

79

156

7,782,400

n=int(input()) li=list(map(int,input().split())) li.sort() if(len(set(li))==1 and li[0]!=0): print(1) elif(len(set(li))==1 and li[0]==0): print(0) else: c=0 for i in set(li): if i!=0: c=c+1 print(c)

Title: Nastya and an Array Time Limit: None seconds Memory Limit: None megabytes Problem Description: Nastya owns too many arrays now, so she wants to delete the least important of them. However, she discovered that this array is magic! Nastya now knows that the array has the following properties: - In one second we can add an arbitrary (possibly negative) integer to all elements of the array that are not equal to zero. - When all elements of the array become equal to zero, the array explodes. Nastya is always busy, so she wants to explode the array as fast as possible. Compute the minimum time in which the array can be exploded. Input Specification: The first line contains a single integer *n* (1<=≤<=*n*<=≤<=105) — the size of the array. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (<=-<=105<=≤<=*a**i*<=≤<=105) — the elements of the array. Output Specification: Print a single integer — the minimum number of seconds needed to make all elements of the array equal to zero. Demo Input: ['5\n1 1 1 1 1\n', '3\n2 0 -1\n', '4\n5 -6 -5 1\n'] Demo Output: ['1\n', '2\n', '4\n'] Note: In the first example you can add - 1 to all non-zero elements in one second and make them equal to zero. In the second example you can add - 2 on the first second, then the array becomes equal to [0, 0, - 3]. On the second second you can add 3 to the third (the only non-zero) element.

```python n=int(input()) li=list(map(int,input().split())) li.sort() if(len(set(li))==1 and li[0]!=0): print(1) elif(len(set(li))==1 and li[0]==0): print(0) else: c=0 for i in set(li): if i!=0: c=c+1 print(c) ```

3

451

B

Sort the Array

PROGRAMMING

1,300

[ "implementation", "sortings" ]

null

Being a programmer, you like arrays a lot. For your birthday, your friends have given you an array *a* consisting of *n* distinct integers. Unfortunately, the size of *a* is too small. You want a bigger array! Your friends agree to give you a bigger array, but only if you are able to answer the following question correctly: is it possible to sort the array *a* (in increasing order) by reversing exactly one segment of *a*? See definitions of segment and reversing in the notes.

The first line of the input contains an integer *n* (1<=≤<=*n*<=≤<=105) — the size of array *a*. The second line contains *n* distinct space-separated integers: *a*[1],<=*a*[2],<=...,<=*a*[*n*] (1<=≤<=*a*[*i*]<=≤<=109).

Print "yes" or "no" (without quotes), depending on the answer. If your answer is "yes", then also print two space-separated integers denoting start and end (start must not be greater than end) indices of the segment to be reversed. If there are multiple ways of selecting these indices, print any of them.

[ "3\n3 2 1\n", "4\n2 1 3 4\n", "4\n3 1 2 4\n", "2\n1 2\n" ]

[ "yes\n1 3\n", "yes\n1 2\n", "no\n", "yes\n1 1\n" ]

Sample 1. You can reverse the entire array to get [1, 2, 3], which is sorted. Sample 3. No segment can be reversed such that the array will be sorted. Definitions A segment [*l*, *r*] of array *a* is the sequence *a*[*l*], *a*[*l* + 1], ..., *a*[*r*]. If you have an array *a* of size *n* and you reverse its segment [*l*, *r*], the array will become: *a*[1], *a*[2], ..., *a*[*l* - 2], *a*[*l* - 1], *a*[*r*], *a*[*r* - 1], ..., *a*[*l* + 1], *a*[*l*], *a*[*r* + 1], *a*[*r* + 2], ..., *a*[*n* - 1], *a*[*n*].

1,000

[ { "input": "3\n3 2 1", "output": "yes\n1 3" }, { "input": "4\n2 1 3 4", "output": "yes\n1 2" }, { "input": "4\n3 1 2 4", "output": "no" }, { "input": "2\n1 2", "output": "yes\n1 1" }, { "input": "2\n58 4", "output": "yes\n1 2" }, { "input": "5\n69 37 27 4 2", "output": "yes\n1 5" }, { "input": "9\n6 78 63 59 28 24 8 96 99", "output": "yes\n2 7" }, { "input": "6\n19517752 43452931 112792556 68417469 779722934 921694415", "output": "yes\n3 4" }, { "input": "6\n169793171 335736854 449917902 513287332 811627074 938727967", "output": "yes\n1 1" }, { "input": "6\n509329 173849943 297546987 591032670 796346199 914588283", "output": "yes\n1 1" }, { "input": "25\n46 45 37 35 26 25 21 19 11 3 1 51 54 55 57 58 59 62 66 67 76 85 88 96 100", "output": "yes\n1 11" }, { "input": "46\n10 12 17 19 20 21 22 24 25 26 27 28 29 30 32 37 42 43 47 48 50 51 52 56 87 86 81 79 74 71 69 67 66 65 60 59 57 89 91 92 94 96 97 98 99 100", "output": "yes\n25 37" }, { "input": "96\n1 2 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 68 69 70 71 72 73 74 75 76 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100", "output": "yes\n3 22" }, { "input": "2\n404928771 698395106", "output": "yes\n1 1" }, { "input": "2\n699573624 308238132", "output": "yes\n1 2" }, { "input": "5\n75531609 242194958 437796493 433259361 942142185", "output": "yes\n3 4" }, { "input": "5\n226959376 840957605 833410429 273566427 872976052", "output": "yes\n2 4" }, { "input": "5\n373362086 994096202 767275079 734424844 515504383", "output": "yes\n2 5" }, { "input": "5\n866379155 593548704 259097686 216134784 879911740", "output": "yes\n1 4" }, { "input": "5\n738083041 719956102 420866851 307749161 257917459", "output": "yes\n1 5" }, { "input": "5\n90786760 107075352 139104198 424911569 858427981", "output": "yes\n1 1" }, { "input": "6\n41533825 525419745 636375901 636653266 879043107 967434399", "output": "yes\n1 1" }, { "input": "40\n22993199 75843013 76710455 99749069 105296587 122559115 125881005 153961749 163646706 175409222 185819807 214465092 264449243 278246513 295514446 322935239 370349154 375773209 390474983 775646826 767329655 740310077 718820037 708508595 693119912 680958422 669537382 629123011 607511013 546574974 546572137 511951383 506996390 493995578 458256840 815612821 881161983 901337648 962275390 986568907", "output": "yes\n20 35" }, { "input": "40\n3284161 23121669 24630274 33434127 178753820 231503277 271972002 272578266 346450638 355655265 372217434 376132047 386622863 387235708 389799554 427160037 466577363 491873718 492746058 502535866 535768673 551570285 557477055 583643014 586216753 588981593 592960633 605923775 611051145 643142759 632768011 634888864 736715552 750574599 867737742 924365786 927179496 934453020 954090860 977765165", "output": "no" }, { "input": "40\n42131757 49645896 49957344 78716964 120937785 129116222 172128600 211446903 247833196 779340466 717548386 709969818 696716905 636153997 635635467 614115746 609201167 533608141 521874836 273044950 291514539 394083281 399369419 448830087 485128983 487192341 488673105 497678164 501864738 265305156 799595875 831638598 835155840 845617770 847736630 851436542 879757553 885618675 964068808 969215471", "output": "no" }, { "input": "40\n25722567 28250400 47661056 108729970 119887370 142272261 145287693 178946020 182917658 187405805 209478929 278713296 312035195 393514697 403876943 410188367 413061616 420619615 477231590 511200584 560288373 571690007 603093961 615463729 631624043 723138759 726089658 728151980 756393077 785590533 809755752 823601179 828357990 866942019 869575503 877310377 881382070 901314141 929048602 947139655", "output": "yes\n1 1" }, { "input": "40\n17927221 33153935 60257083 110553879 114654567 119809916 163899753 167741765 182812464 188486743 220036903 220127072 227545828 229552200 244963635 248298934 299478582 354141058 371400641 430054473 452548736 458695269 466968129 469000714 478004472 478693873 509342093 750631027 609759323 669427158 688490225 690701652 696893030 704668825 749028408 557906039 545356441 926901326 955586118 972642992", "output": "no" }, { "input": "4\n1 4 2 3", "output": "no" }, { "input": "6\n1 2 5 4 3 6", "output": "yes\n3 5" }, { "input": "1\n1", "output": "yes\n1 1" }, { "input": "6\n1 5 3 4 2 6", "output": "no" }, { "input": "4\n3 4 1 2", "output": "no" }, { "input": "5\n2 5 4 3 1", "output": "no" }, { "input": "4\n2 1 4 3", "output": "no" }, { "input": "6\n2 1 4 3 5 6", "output": "no" } ]

1,689,410,456

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

0

62

0

from collections import deque t = 1#int(input()) for _ in range(t): n = int(input()) d = list(map(int,input().split())) cnt = 0 ok = 0 l,r = 0,0 for i in range(1,n): if d[i - 1] > d[i]: if ok: print('No') exit() cnt += 1 else: if cnt: l, r = i - cnt,i cnt = 0 ok = 1 if cnt:l,r = i - cnt,i print('Yes',cnt) print(l + 1,r + 1)

Title: Sort the Array Time Limit: None seconds Memory Limit: None megabytes Problem Description: Being a programmer, you like arrays a lot. For your birthday, your friends have given you an array *a* consisting of *n* distinct integers. Unfortunately, the size of *a* is too small. You want a bigger array! Your friends agree to give you a bigger array, but only if you are able to answer the following question correctly: is it possible to sort the array *a* (in increasing order) by reversing exactly one segment of *a*? See definitions of segment and reversing in the notes. Input Specification: The first line of the input contains an integer *n* (1<=≤<=*n*<=≤<=105) — the size of array *a*. The second line contains *n* distinct space-separated integers: *a*[1],<=*a*[2],<=...,<=*a*[*n*] (1<=≤<=*a*[*i*]<=≤<=109). Output Specification: Print "yes" or "no" (without quotes), depending on the answer. If your answer is "yes", then also print two space-separated integers denoting start and end (start must not be greater than end) indices of the segment to be reversed. If there are multiple ways of selecting these indices, print any of them. Demo Input: ['3\n3 2 1\n', '4\n2 1 3 4\n', '4\n3 1 2 4\n', '2\n1 2\n'] Demo Output: ['yes\n1 3\n', 'yes\n1 2\n', 'no\n', 'yes\n1 1\n'] Note: Sample 1. You can reverse the entire array to get [1, 2, 3], which is sorted. Sample 3. No segment can be reversed such that the array will be sorted. Definitions A segment [*l*, *r*] of array *a* is the sequence *a*[*l*], *a*[*l* + 1], ..., *a*[*r*]. If you have an array *a* of size *n* and you reverse its segment [*l*, *r*], the array will become: *a*[1], *a*[2], ..., *a*[*l* - 2], *a*[*l* - 1], *a*[*r*], *a*[*r* - 1], ..., *a*[*l* + 1], *a*[*l*], *a*[*r* + 1], *a*[*r* + 2], ..., *a*[*n* - 1], *a*[*n*].

```python from collections import deque t = 1#int(input()) for _ in range(t): n = int(input()) d = list(map(int,input().split())) cnt = 0 ok = 0 l,r = 0,0 for i in range(1,n): if d[i - 1] > d[i]: if ok: print('No') exit() cnt += 1 else: if cnt: l, r = i - cnt,i cnt = 0 ok = 1 if cnt:l,r = i - cnt,i print('Yes',cnt) print(l + 1,r + 1) ```

0

932

B

Recursive Queries

PROGRAMMING

1,300

[ "binary search", "data structures", "dfs and similar" ]

null

Let us define two functions *f* and *g* on positive integer numbers. You need to process *Q* queries. In each query, you will be given three integers *l*, *r* and *k*. You need to print the number of integers *x* between *l* and *r* inclusive, such that *g*(*x*)<==<=*k*.

The first line of the input contains an integer *Q* (1<=≤<=*Q*<=≤<=2<=×<=105) representing the number of queries. *Q* lines follow, each of which contains 3 integers *l*, *r* and *k* (1<=≤<=*l*<=≤<=*r*<=≤<=106,<=1<=≤<=*k*<=≤<=9).

For each query, print a single line containing the answer for that query.

[ "4\n22 73 9\n45 64 6\n47 55 7\n2 62 4\n", "4\n82 94 6\n56 67 4\n28 59 9\n39 74 4\n" ]

[ "1\n4\n0\n8\n", "3\n1\n1\n5\n" ]

In the first example: - *g*(33) = 9 as *g*(33) = *g*(3 × 3) = *g*(9) = 9 - *g*(47) = *g*(48) = *g*(60) = *g*(61) = 6 - There are no such integers between 47 and 55. - *g*(4) = *g*(14) = *g*(22) = *g*(27) = *g*(39) = *g*(40) = *g*(41) = *g*(58) = 4

1,000

[ { "input": "4\n22 73 9\n45 64 6\n47 55 7\n2 62 4", "output": "1\n4\n0\n8" }, { "input": "4\n82 94 6\n56 67 4\n28 59 9\n39 74 4", "output": "3\n1\n1\n5" } ]

1,518,709,235

3,935

Python 3

TIME_LIMIT_EXCEEDED

PRETESTS

4

2,000

5,632,000

def proiz(a): t = 1 a=str(a) for i in range(len(a)): if a[i]!='0': t=t*int(a[i]) return t def rsult(a): a=int(a) if a<10: return a else: return rsult(proiz(a)) q=int(input()) for i in range(q): l, r, k=input().split() l =int(l) r = int(r) k = int(k) kol=0 for j in range(l, r+1): if rsult(str(j))==k: kol+=1 print(kol)

Title: Recursive Queries Time Limit: None seconds Memory Limit: None megabytes Problem Description: Let us define two functions *f* and *g* on positive integer numbers. You need to process *Q* queries. In each query, you will be given three integers *l*, *r* and *k*. You need to print the number of integers *x* between *l* and *r* inclusive, such that *g*(*x*)<==<=*k*. Input Specification: The first line of the input contains an integer *Q* (1<=≤<=*Q*<=≤<=2<=×<=105) representing the number of queries. *Q* lines follow, each of which contains 3 integers *l*, *r* and *k* (1<=≤<=*l*<=≤<=*r*<=≤<=106,<=1<=≤<=*k*<=≤<=9). Output Specification: For each query, print a single line containing the answer for that query. Demo Input: ['4\n22 73 9\n45 64 6\n47 55 7\n2 62 4\n', '4\n82 94 6\n56 67 4\n28 59 9\n39 74 4\n'] Demo Output: ['1\n4\n0\n8\n', '3\n1\n1\n5\n'] Note: In the first example: - *g*(33) = 9 as *g*(33) = *g*(3 × 3) = *g*(9) = 9 - *g*(47) = *g*(48) = *g*(60) = *g*(61) = 6 - There are no such integers between 47 and 55. - *g*(4) = *g*(14) = *g*(22) = *g*(27) = *g*(39) = *g*(40) = *g*(41) = *g*(58) = 4

```python def proiz(a): t = 1 a=str(a) for i in range(len(a)): if a[i]!='0': t=t*int(a[i]) return t def rsult(a): a=int(a) if a<10: return a else: return rsult(proiz(a)) q=int(input()) for i in range(q): l, r, k=input().split() l =int(l) r = int(r) k = int(k) kol=0 for j in range(l, r+1): if rsult(str(j))==k: kol+=1 print(kol) ```

0

411

A

Password Check

PROGRAMMING

800

[ "*special", "implementation" ]

null

You have probably registered on Internet sites many times. And each time you should enter your invented password. Usually the registration form automatically checks the password's crypt resistance. If the user's password isn't complex enough, a message is displayed. Today your task is to implement such an automatic check. Web-developers of the company Q assume that a password is complex enough, if it meets all of the following conditions: - the password length is at least 5 characters; - the password contains at least one large English letter; - the password contains at least one small English letter; - the password contains at least one digit. You are given a password. Please implement the automatic check of its complexity for company Q.

The first line contains a non-empty sequence of characters (at most 100 characters). Each character is either a large English letter, or a small English letter, or a digit, or one of characters: "!", "?", ".", ",", "_".

If the password is complex enough, print message "Correct" (without the quotes), otherwise print message "Too weak" (without the quotes).

[ "abacaba\n", "X12345\n", "CONTEST_is_STARTED!!11\n" ]

[ "Too weak\n", "Too weak\n", "Correct\n" ]

none

0

[ { "input": "abacaba", "output": "Too weak" }, { "input": "X12345", "output": "Too weak" }, { "input": "CONTEST_is_STARTED!!11", "output": "Correct" }, { "input": "1zA__", "output": "Correct" }, { "input": "1zA_", "output": "Too weak" }, { "input": "zA___", "output": "Too weak" }, { "input": "1A___", "output": "Too weak" }, { "input": "z1___", "output": "Too weak" }, { "input": "0", "output": "Too weak" }, { "input": "_", "output": "Too weak" }, { "input": "a", "output": "Too weak" }, { "input": "D", "output": "Too weak" }, { "input": "_", "output": "Too weak" }, { "input": "?", "output": "Too weak" }, { "input": "?", "output": "Too weak" }, { "input": "._,.!.,...?_,!.", "output": "Too weak" }, { "input": "!_?_,?,?.,.,_!!!.!,.__,?!!,_!,?_,!??,?!..._!?_,?_!,?_.,._,,_.,.", "output": "Too weak" }, { "input": "?..!.,,?,__.,...????_???__!,?...?.,,,,___!,.!,_,,_,??!_?_,!!?_!_??.?,.!!?_?_.,!", "output": "Too weak" }, { "input": "XZX", "output": "Too weak" }, { "input": "R", "output": "Too weak" }, { "input": "H.FZ", "output": "Too weak" }, { "input": "KSHMICWPK,LSBM_JVZ!IPDYDG_GOPCHXFJTKJBIFY,FPHMY,CB?PZEAG..,X,.GFHPIDBB,IQ?MZ", "output": "Too weak" }, { "input": "EFHI,,Y?HMMUI,,FJGAY?FYPBJQMYM!DZHLFCTFWT?JOPDW,S_!OR?ATT?RWFBMAAKUHIDMHSD?LCZQY!UD_CGYGBAIRDPICYS", "output": "Too weak" }, { "input": "T,NDMUYCCXH_L_FJHMCCAGX_XSCPGOUZSY?D?CNDSYRITYS,VAT!PJVKNTBMXGGRYKACLYU.RJQ_?UWKXYIDE_AE", "output": "Too weak" }, { "input": "y", "output": "Too weak" }, { "input": "qgw", "output": "Too weak" }, { "input": "g", "output": "Too weak" }, { "input": "loaray", "output": "Too weak" }, { "input": "d_iymyvxolmjayhwpedocopqwmy.oalrdg!_n?.lrxpamhygps?kkzxydsbcaihfs.j?eu!oszjsy.vzu?!vs.bprz_j", "output": "Too weak" }, { "input": "txguglvclyillwnono", "output": "Too weak" }, { "input": "FwX", "output": "Too weak" }, { "input": "Zi", "output": "Too weak" }, { "input": "PodE", "output": "Too weak" }, { "input": "SdoOuJ?nj_wJyf", "output": "Too weak" }, { "input": "MhnfZjsUyXYw?f?ubKA", "output": "Too weak" }, { "input": "CpWxDVzwHfYFfoXNtXMFuAZr", "output": "Too weak" }, { "input": "9.,0", "output": "Too weak" }, { "input": "5,8", "output": "Too weak" }, { "input": "7", "output": "Too weak" }, { "input": "34__39_02!,!,82!129!2!566", "output": "Too weak" }, { "input": "96156027.65935663!_87!,44,..7914_!0_1,.4!!62!.8350!17_282!!9.2584,!!7__51.526.7", "output": "Too weak" }, { "input": "90328_", "output": "Too weak" }, { "input": "B9", "output": "Too weak" }, { "input": "P1H", "output": "Too weak" }, { "input": "J2", "output": "Too weak" }, { "input": "M6BCAKW!85OSYX1D?.53KDXP42F", "output": "Too weak" }, { "input": "C672F429Y8X6XU7S,.K9111UD3232YXT81S4!729ER7DZ.J7U1R_7VG6.FQO,LDH", "output": "Too weak" }, { "input": "W2PI__!.O91H8OFY6AB__R30L9XOU8800?ZUD84L5KT99818NFNE35V.8LJJ5P2MM.B6B", "output": "Too weak" }, { "input": "z1", "output": "Too weak" }, { "input": "p1j", "output": "Too weak" }, { "input": "j9", "output": "Too weak" }, { "input": "v8eycoylzv0qkix5mfs_nhkn6k!?ovrk9!b69zy!4frc?k", "output": "Too weak" }, { "input": "l4!m_44kpw8.jg!?oh,?y5oraw1tg7_x1.osl0!ny?_aihzhtt0e2!mr92tnk0es!1f,9he40_usa6c50l", "output": "Too weak" }, { "input": "d4r!ak.igzhnu!boghwd6jl", "output": "Too weak" }, { "input": "It0", "output": "Too weak" }, { "input": "Yb1x", "output": "Too weak" }, { "input": "Qf7", "output": "Too weak" }, { "input": "Vu7jQU8.!FvHBYTsDp6AphaGfnEmySP9te", "output": "Correct" }, { "input": "Ka4hGE,vkvNQbNolnfwp", "output": "Correct" }, { "input": "Ee9oluD?amNItsjeQVtOjwj4w_ALCRh7F3eaZah", "output": "Correct" }, { "input": "Um3Fj?QLhNuRE_Gx0cjMLOkGCm", "output": "Correct" }, { "input": "Oq2LYmV9HmlaW", "output": "Correct" }, { "input": "Cq7r3Wrb.lDb_0wsf7!ruUUGSf08RkxD?VsBEDdyE?SHK73TFFy0f8gmcATqGafgTv8OOg8or2HyMPIPiQ2Hsx8q5rn3_WZe", "output": "Correct" }, { "input": "Wx4p1fOrEMDlQpTlIx0p.1cnFD7BnX2K8?_dNLh4cQBx_Zqsv83BnL5hGKNcBE9g3QB,!fmSvgBeQ_qiH7", "output": "Correct" }, { "input": "k673,", "output": "Too weak" }, { "input": "LzuYQ", "output": "Too weak" }, { "input": "Pasq!", "output": "Too weak" }, { "input": "x5hve", "output": "Too weak" }, { "input": "b27fk", "output": "Too weak" }, { "input": "h6y1l", "output": "Too weak" }, { "input": "i9nij", "output": "Too weak" }, { "input": "Gf5Q6", "output": "Correct" }, { "input": "Uf24o", "output": "Correct" }, { "input": "Oj9vu", "output": "Correct" }, { "input": "c7jqaudcqmv8o7zvb5x_gp6zcgl6nwr7tz5or!28.tj8s1m2.wxz5a4id03!rq07?662vy.7.p5?vk2f2mc7ag8q3861rgd0rmbr", "output": "Too weak" }, { "input": "i6a.,8jb,n0kv4.1!7h?p.96pnhhgy6cl7dg7e4o6o384ys3z.t71kkq,,w,oqi4?u,,m5!rzu6wym_4hm,ohjy!.vvksl?pt,,1", "output": "Too weak" }, { "input": "M10V_MN_1K8YX2LA!89EYV7!5V9?,.IDHDP6JEC.OGLY.180LMZ6KW3Z5E17IT94ZNHS!79GN09Q6LH0,F3AYNKP?KM,QP_?XRD6", "output": "Too weak" }, { "input": "Hi7zYuVXCPhaho68YgCMzzgLILM6toQTJq8akMqqrnUn6ZCD36iA1yVVpvlsIiMpCu!1QZd4ycIrQ5Kcrhk5k0jTrwdAAEEP_T2f", "output": "Correct" }, { "input": "Bk2Q38vDSW5JqYu.077iYC.9YoiPc!Dh6FJWOVze6?YXiFjPNa4F1RG?154m9mY2jQobBnbxM,cDV8l1UX1?v?p.tTYIyJO!NYmE", "output": "Correct" }, { "input": "Ro1HcZ.piN,JRR88DLh,WtW!pbFM076?wCSbqfK7N2s5zUySFBtzk7HV,BxHXR0zALAr016z5jvvB.WUdEcKgYFav5TygwHQC..C", "output": "Correct" }, { "input": "!?.,_", "output": "Too weak" } ]

1,665,143,199

2,147,483,647

PyPy 3-64

WRONG_ANSWER

TESTS

3

46

0

c = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] u = [x.upper() for x in c] n = [str(x) for x in range(10)] sp = ["!", "?", ".", ",", "_"] s = str(input()) nc = 0 nu = 0 nn = 0 nsp = 0 for i in range(len(s)): if s[i] in c: nc += 1 elif s[i] in u: nu += 1 elif s[i] in n: nn += 1 else: nsp += 1 if nc + nu >= 5 and nc >= 1 and nu >= 1 and nn >= 1 and nsp >= 1: print("Correct") else: print("Too weak")

Title: Password Check Time Limit: None seconds Memory Limit: None megabytes Problem Description: You have probably registered on Internet sites many times. And each time you should enter your invented password. Usually the registration form automatically checks the password's crypt resistance. If the user's password isn't complex enough, a message is displayed. Today your task is to implement such an automatic check. Web-developers of the company Q assume that a password is complex enough, if it meets all of the following conditions: - the password length is at least 5 characters; - the password contains at least one large English letter; - the password contains at least one small English letter; - the password contains at least one digit. You are given a password. Please implement the automatic check of its complexity for company Q. Input Specification: The first line contains a non-empty sequence of characters (at most 100 characters). Each character is either a large English letter, or a small English letter, or a digit, or one of characters: "!", "?", ".", ",", "_". Output Specification: If the password is complex enough, print message "Correct" (without the quotes), otherwise print message "Too weak" (without the quotes). Demo Input: ['abacaba\n', 'X12345\n', 'CONTEST_is_STARTED!!11\n'] Demo Output: ['Too weak\n', 'Too weak\n', 'Correct\n'] Note: none

```python c = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] u = [x.upper() for x in c] n = [str(x) for x in range(10)] sp = ["!", "?", ".", ",", "_"] s = str(input()) nc = 0 nu = 0 nn = 0 nsp = 0 for i in range(len(s)): if s[i] in c: nc += 1 elif s[i] in u: nu += 1 elif s[i] in n: nn += 1 else: nsp += 1 if nc + nu >= 5 and nc >= 1 and nu >= 1 and nn >= 1 and nsp >= 1: print("Correct") else: print("Too weak") ```

0

255

A

Greg's Workout

PROGRAMMING

800

[ "implementation" ]

null

Greg is a beginner bodybuilder. Today the gym coach gave him the training plan. All it had was *n* integers *a*1,<=*a*2,<=...,<=*a**n*. These numbers mean that Greg needs to do exactly *n* exercises today. Besides, Greg should repeat the *i*-th in order exercise *a**i* times. Greg now only does three types of exercises: "chest" exercises, "biceps" exercises and "back" exercises. Besides, his training is cyclic, that is, the first exercise he does is a "chest" one, the second one is "biceps", the third one is "back", the fourth one is "chest", the fifth one is "biceps", and so on to the *n*-th exercise. Now Greg wonders, which muscle will get the most exercise during his training. We know that the exercise Greg repeats the maximum number of times, trains the corresponding muscle the most. Help Greg, determine which muscle will get the most training.

The first line contains integer *n* (1<=≤<=*n*<=≤<=20). The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=25) — the number of times Greg repeats the exercises.

Print word "chest" (without the quotes), if the chest gets the most exercise, "biceps" (without the quotes), if the biceps gets the most exercise and print "back" (without the quotes) if the back gets the most exercise. It is guaranteed that the input is such that the answer to the problem is unambiguous.

[ "2\n2 8\n", "3\n5 1 10\n", "7\n3 3 2 7 9 6 8\n" ]

[ "biceps\n", "back\n", "chest\n" ]

In the first sample Greg does 2 chest, 8 biceps and zero back exercises, so the biceps gets the most exercises. In the second sample Greg does 5 chest, 1 biceps and 10 back exercises, so the back gets the most exercises. In the third sample Greg does 18 chest, 12 biceps and 8 back exercises, so the chest gets the most exercise.

500

[ { "input": "2\n2 8", "output": "biceps" }, { "input": "3\n5 1 10", "output": "back" }, { "input": "7\n3 3 2 7 9 6 8", "output": "chest" }, { "input": "4\n5 6 6 2", "output": "chest" }, { "input": "5\n8 2 2 6 3", "output": "chest" }, { "input": "6\n8 7 2 5 3 4", "output": "chest" }, { "input": "8\n7 2 9 10 3 8 10 6", "output": "chest" }, { "input": "9\n5 4 2 3 4 4 5 2 2", "output": "chest" }, { "input": "10\n4 9 8 5 3 8 8 10 4 2", "output": "biceps" }, { "input": "11\n10 9 7 6 1 3 9 7 1 3 5", "output": "chest" }, { "input": "12\n24 22 6 16 5 21 1 7 2 19 24 5", "output": "chest" }, { "input": "13\n24 10 5 7 16 17 2 7 9 20 15 2 24", "output": "chest" }, { "input": "14\n13 14 19 8 5 17 9 16 15 9 5 6 3 7", "output": "back" }, { "input": "15\n24 12 22 21 25 23 21 5 3 24 23 13 12 16 12", "output": "chest" }, { "input": "16\n12 6 18 6 25 7 3 1 1 17 25 17 6 8 17 8", "output": "biceps" }, { "input": "17\n13 8 13 4 9 21 10 10 9 22 14 23 22 7 6 14 19", "output": "chest" }, { "input": "18\n1 17 13 6 11 10 25 13 24 9 21 17 3 1 17 12 25 21", "output": "back" }, { "input": "19\n22 22 24 25 19 10 7 10 4 25 19 14 1 14 3 18 4 19 24", "output": "chest" }, { "input": "20\n9 8 22 11 18 14 15 10 17 11 2 1 25 20 7 24 4 25 9 20", "output": "chest" }, { "input": "1\n10", "output": "chest" }, { "input": "2\n15 3", "output": "chest" }, { "input": "3\n21 11 19", "output": "chest" }, { "input": "4\n19 24 13 15", "output": "chest" }, { "input": "5\n4 24 1 9 19", "output": "biceps" }, { "input": "6\n6 22 24 7 15 24", "output": "back" }, { "input": "7\n10 8 23 23 14 18 14", "output": "chest" }, { "input": "8\n5 16 8 9 17 16 14 7", "output": "biceps" }, { "input": "9\n12 3 10 23 6 4 22 13 12", "output": "chest" }, { "input": "10\n1 9 20 18 20 17 7 24 23 2", "output": "back" }, { "input": "11\n22 25 8 2 18 15 1 13 1 11 4", "output": "biceps" }, { "input": "12\n20 12 14 2 15 6 24 3 11 8 11 14", "output": "chest" }, { "input": "13\n2 18 8 8 8 20 5 22 15 2 5 19 18", "output": "back" }, { "input": "14\n1 6 10 25 17 13 21 11 19 4 15 24 5 22", "output": "biceps" }, { "input": "15\n13 5 25 13 17 25 19 21 23 17 12 6 14 8 6", "output": "back" }, { "input": "16\n10 15 2 17 22 12 14 14 6 11 4 13 9 8 21 14", "output": "chest" }, { "input": "17\n7 22 9 22 8 7 20 22 23 5 12 11 1 24 17 20 10", "output": "biceps" }, { "input": "18\n18 15 4 25 5 11 21 25 12 14 25 23 19 19 13 6 9 17", "output": "chest" }, { "input": "19\n3 1 3 15 15 25 10 25 23 10 9 21 13 23 19 3 24 21 14", "output": "back" }, { "input": "20\n19 18 11 3 6 14 3 3 25 3 1 19 25 24 23 12 7 4 8 6", "output": "back" }, { "input": "1\n19", "output": "chest" }, { "input": "2\n1 7", "output": "biceps" }, { "input": "3\n18 18 23", "output": "back" }, { "input": "4\n12 15 1 13", "output": "chest" }, { "input": "5\n11 14 25 21 21", "output": "biceps" }, { "input": "6\n11 9 12 11 22 18", "output": "biceps" }, { "input": "7\n11 1 16 20 21 25 20", "output": "chest" }, { "input": "8\n1 2 20 9 3 22 17 4", "output": "back" }, { "input": "9\n19 2 10 19 15 20 3 1 13", "output": "back" }, { "input": "10\n11 2 11 8 21 16 2 3 19 9", "output": "back" }, { "input": "20\n25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 24", "output": "chest" }, { "input": "12\n4 24 21 3 13 24 22 13 12 21 1 15", "output": "back" }, { "input": "13\n14 14 16 2 13 5 1 14 9 4 16 8 3", "output": "biceps" }, { "input": "14\n1 9 15 4 11 8 25 3 9 14 13 2 1 11", "output": "biceps" }, { "input": "15\n4 19 10 6 16 12 5 11 7 23 1 24 11 7 17", "output": "back" }, { "input": "16\n2 8 2 8 13 22 20 12 22 23 18 13 18 22 11 17", "output": "chest" }, { "input": "17\n24 5 5 16 10 8 22 6 4 13 10 10 5 23 8 20 8", "output": "chest" }, { "input": "18\n14 8 9 12 11 18 24 1 14 24 18 5 12 17 1 10 1 22", "output": "chest" }, { "input": "19\n21 2 10 6 9 1 24 5 2 19 10 13 10 7 19 2 6 13 24", "output": "chest" }, { "input": "20\n7 1 14 17 6 6 18 13 12 3 25 4 3 19 22 24 16 14 1 23", "output": "biceps" }, { "input": "1\n19", "output": "chest" }, { "input": "20\n2 1 2 2 1 2 2 1 2 1 1 1 1 1 1 1 1 1 1 22", "output": "biceps" } ]

1,627,482,649

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

12

124

6,963,200

n = int(input()) s = list(map(int, input().split())) ba = 0 bi = 0 ch = 0 for i in range(0,n): if i % 3 == 0: ch += s[i] elif i % 2 == 0: ba += s[i] else: bi += s[i] if max(ba, bi, ch) == ba: print('back') elif max(ba, bi, ch) == bi: print('biceps') else: print('chest')

Title: Greg's Workout Time Limit: None seconds Memory Limit: None megabytes Problem Description: Greg is a beginner bodybuilder. Today the gym coach gave him the training plan. All it had was *n* integers *a*1,<=*a*2,<=...,<=*a**n*. These numbers mean that Greg needs to do exactly *n* exercises today. Besides, Greg should repeat the *i*-th in order exercise *a**i* times. Greg now only does three types of exercises: "chest" exercises, "biceps" exercises and "back" exercises. Besides, his training is cyclic, that is, the first exercise he does is a "chest" one, the second one is "biceps", the third one is "back", the fourth one is "chest", the fifth one is "biceps", and so on to the *n*-th exercise. Now Greg wonders, which muscle will get the most exercise during his training. We know that the exercise Greg repeats the maximum number of times, trains the corresponding muscle the most. Help Greg, determine which muscle will get the most training. Input Specification: The first line contains integer *n* (1<=≤<=*n*<=≤<=20). The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=25) — the number of times Greg repeats the exercises. Output Specification: Print word "chest" (without the quotes), if the chest gets the most exercise, "biceps" (without the quotes), if the biceps gets the most exercise and print "back" (without the quotes) if the back gets the most exercise. It is guaranteed that the input is such that the answer to the problem is unambiguous. Demo Input: ['2\n2 8\n', '3\n5 1 10\n', '7\n3 3 2 7 9 6 8\n'] Demo Output: ['biceps\n', 'back\n', 'chest\n'] Note: In the first sample Greg does 2 chest, 8 biceps and zero back exercises, so the biceps gets the most exercises. In the second sample Greg does 5 chest, 1 biceps and 10 back exercises, so the back gets the most exercises. In the third sample Greg does 18 chest, 12 biceps and 8 back exercises, so the chest gets the most exercise.

```python n = int(input()) s = list(map(int, input().split())) ba = 0 bi = 0 ch = 0 for i in range(0,n): if i % 3 == 0: ch += s[i] elif i % 2 == 0: ba += s[i] else: bi += s[i] if max(ba, bi, ch) == ba: print('back') elif max(ba, bi, ch) == bi: print('biceps') else: print('chest') ```

0

none

0

[ "none" ]

null

It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin. We can think Central Perk as coordinate plane. There are *n* bottles on the ground, the *i*-th bottle is located at position (*x**i*,<=*y**i*). Both Adil and Bera can carry only one bottle at once each. For both Adil and Bera the process looks as follows: 1. Choose to stop or to continue to collect bottles. 1. If the choice was to continue then choose some bottle and walk towards it. 1. Pick this bottle and walk to the recycling bin. 1. Go to step 1. Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles. They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin.

First line of the input contains six integers *a**x*, *a**y*, *b**x*, *b**y*, *t**x* and *t**y* (0<=≤<=*a**x*,<=*a**y*,<=*b**x*,<=*b**y*,<=*t**x*,<=*t**y*<=≤<=109) — initial positions of Adil, Bera and recycling bin respectively. The second line contains a single integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of bottles on the ground. Then follow *n* lines, each of them contains two integers *x**i* and *y**i* (0<=≤<=*x**i*,<=*y**i*<=≤<=109) — position of the *i*-th bottle. It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct.

Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10<=-<=6. Namely: let's assume that your answer is *a*, and the answer of the jury is *b*. The checker program will consider your answer correct if .

[ "3 1 1 2 0 0\n3\n1 1\n2 1\n2 3\n", "5 0 4 2 2 0\n5\n5 2\n3 0\n5 5\n3 5\n3 3\n" ]

[ "11.084259940083\n", "33.121375178000\n" ]

Consider the first sample. Adil will use the following path: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/37eea809c04afe04f2670475cc5b21df4a90afd1.png" style="max-width: 100.0%;max-height: 100.0%;"/>. Bera will use the following path: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/08e917ff238fec015f897516a95529b6d9aed5c7.png" style="max-width: 100.0%;max-height: 100.0%;"/>. Adil's path will be <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/f58aa00f71a0b723b5de3c8e56ce41dc8afec7f8.png" style="max-width: 100.0%;max-height: 100.0%;"/> units long, while Bera's path will be <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/3615db76a2cdd77d711b73d2894f03bdd52af736.png" style="max-width: 100.0%;max-height: 100.0%;"/> units long.

0

[ { "input": "3 1 1 2 0 0\n3\n1 1\n2 1\n2 3", "output": "11.084259940083" }, { "input": "5 0 4 2 2 0\n5\n5 2\n3 0\n5 5\n3 5\n3 3", "output": "33.121375178000" }, { "input": "107 50 116 37 104 118\n12\n16 78\n95 113\n112 84\n5 88\n54 85\n112 80\n19 98\n25 14\n48 76\n95 70\n77 94\n38 32", "output": "1576.895607473206" }, { "input": "446799 395535 281981 494983 755701 57488\n20\n770380 454998\n147325 211816\n818964 223521\n408463 253399\n49120 253709\n478114 283776\n909705 631953\n303154 889956\n126532 258846\n597028 708070\n147061 192478\n39515 879057\n911737 878857\n26966 701951\n616099 715301\n998385 735514\n277633 346417\n642301 188888\n617247 256225\n668067 352814", "output": "22423982.398765542000" }, { "input": "0 0 214409724 980408402 975413181 157577991\n4\n390610378 473484159\n920351980 785918656\n706277914 753279807\n159291646 213569247", "output": "4854671149.842136400000" }, { "input": "214409724 980408402 0 0 975413181 157577991\n4\n390610378 473484159\n920351980 785918656\n706277914 753279807\n159291646 213569247", "output": "4854671149.842136400000" }, { "input": "383677880 965754167 658001115 941943959 0 0\n10\n9412 5230\n4896 7518\n3635 6202\n2365 1525\n241 1398\n7004 5166\n1294 9162\n3898 6706\n6135 8199\n4195 4410", "output": "1039303750.884648200000" }, { "input": "825153337 326797826 774256604 103765336 0 0\n21\n6537 9734\n3998 8433\n560 7638\n1937 2557\n3487 244\n8299 4519\n73 9952\n2858 3719\n9267 5675\n9584 7636\n9234 1049\n7415 6018\n7653 9345\n7752 9628\n7476 8917\n7207 2352\n2602 4612\n1971 3307\n5530 3694\n2393 8573\n7506 9810", "output": "781520533.726828810000" }, { "input": "214409724 980408402 975413181 157577991 0 0\n4\n3721 6099\n5225 4247\n940 340\n8612 7341", "output": "988090959.937532070000" }, { "input": "235810013 344493922 0 0 975204641 211157253\n18\n977686151 621301932\n408277582 166435161\n595105725 194278844\n967498841 705149530\n551735395 659209387\n492239556 317614998\n741520864 843275770\n585383143 903832112\n272581169 285871890\n339100580 134101148\n920610054 824829107\n657996186 852771589\n948065129 573712142\n615254670 698346010\n365251531 883011553\n304877602 625498272\n418150850 280945187\n731399551 643859052", "output": "20756961047.556908000000" }, { "input": "0 0 1 1 2 2\n1\n1 3", "output": "3.414213562373" }, { "input": "10000 1000 151 121 10 10\n2\n1 1\n2 2", "output": "227.449066182313" }, { "input": "5 5 10 10 15 15\n2\n1 1\n11 11", "output": "32.526911934581" }, { "input": "1000000 1000000 1 1 0 0\n1\n2 2", "output": "4.242640687119" }, { "input": "100 0 0 1 0 0\n2\n1 1\n1 2", "output": "6.478708664619" }, { "input": "0 0 1000000000 1000000000 1 1\n2\n0 1\n1 0", "output": "4.000000000000" }, { "input": "1000 1000 0 0 1 1\n1\n2 2", "output": "4.242640687119" }, { "input": "1 0 1000000 0 0 0\n2\n1 1\n2 2", "output": "7.892922226992" }, { "input": "3 0 100 100 0 0\n2\n1 0\n2 0", "output": "5.000000000000" }, { "input": "0 100 0 101 0 0\n1\n0 99", "output": "100.000000000000" }, { "input": "1000 1000 3 3 0 0\n2\n1 0\n0 1", "output": "6.605551275464" }, { "input": "0 5 0 6 0 7\n1\n0 100", "output": "187.000000000000" }, { "input": "1 1 1000000 1000000 0 0\n2\n1 2\n2 1", "output": "7.708203932499" }, { "input": "1 0 10000000 1000000 0 0\n2\n1 1\n2 2", "output": "7.892922226992" }, { "input": "2 2 10 2 6 5\n2\n6 2\n5 5", "output": "9.000000000000" }, { "input": "100000001 100000001 100000000 100000000 1 1\n1\n1 0", "output": "141421356.530202720000" }, { "input": "1000 1000 1001 1001 0 0\n2\n1 1\n2 2", "output": "1417.041989497841" }, { "input": "1000000000 1000000000 999999999 999999999 1 1\n4\n1 2\n1 3\n2 2\n2 3", "output": "1414213568.487842800000" }, { "input": "0 100 1 1 1 0\n2\n2 1\n0 1", "output": "5.242640687119" }, { "input": "0 100 0 1 0 0\n5\n0 2\n0 3\n0 4\n0 5\n0 6", "output": "39.000000000000" }, { "input": "100 0 0 100 0 0\n2\n0 1\n1 0", "output": "102.000000000000" }, { "input": "0 0 1000000 1000000 0 1\n2\n1 1\n2 2", "output": "6.886349517373" }, { "input": "0 0 1000 1000 1 0\n2\n1 1\n1 2", "output": "6.236067977500" }, { "input": "1 0 100000 100000 0 0\n1\n2 0", "output": "3.000000000000" }, { "input": "5 5 5 4 4 5\n2\n3 4\n3 5", "output": "5.414213562373" }, { "input": "10000 10000 9000 9000 0 0\n3\n1 1\n2 2\n3 3", "output": "12736.407342732093" }, { "input": "1 1 1000 1000 0 0\n3\n2 2\n3 3\n4 4", "output": "24.041630560343" }, { "input": "7 0 8 0 0 0\n2\n1 0\n1 1", "output": "9.496976092671" }, { "input": "1 3 3 3 2 1\n2\n2 3\n3 1", "output": "5.000000000000" }, { "input": "1 2 3 4 5 6\n1\n1 1", "output": "7.403124237433" }, { "input": "1000000000 1000000000 0 0 1 1\n5\n2 2\n2 3\n2 4\n2 5\n2 6", "output": "33.294904485247" }, { "input": "2 1 1 2 0 0\n1\n1 1", "output": "2.414213562373" }, { "input": "1 0 100000 0 0 0\n2\n1 1\n2 2", "output": "7.892922226992" }, { "input": "0 100 1 100 1 0\n2\n2 1\n0 1", "output": "103.242640687119" }, { "input": "0 0 2 0 1 5\n2\n1 0\n1 20", "output": "36.000000000000" }, { "input": "1000 1000 999 999 0 0\n2\n1 0\n0 1", "output": "1415.092419071783" }, { "input": "5 0 1000 1000 2 0\n2\n4 0\n6 7", "output": "19.124515496597" }, { "input": "10000 0 1000000 0 0 0\n2\n1 1\n2 2", "output": "10003.657054289499" }, { "input": "0 100 0 101 0 0\n2\n0 1\n0 2", "output": "102.000000000000" }, { "input": "0 0 10000 10000 1 0\n2\n2 0\n3 0", "output": "7.000000000000" }, { "input": "3 1 1 2 0 0\n1\n1 1", "output": "2.414213562373" }, { "input": "1000 0 0 1000 0 0\n2\n1 0\n0 1", "output": "1002.000000000000" }, { "input": "1 1 1000000 1000000 0 0\n2\n2 1\n1 2", "output": "7.708203932499" }, { "input": "1000 1000 2000 2000 1 1\n3\n2 2\n1 2\n3 3", "output": "1417.627775935468" }, { "input": "0 0 1000000000 1000000000 1 1\n4\n2 2\n3 3\n4 4\n5 5", "output": "29.698484809835" }, { "input": "10000000 1 2 1 1 1\n3\n1 3\n1 4\n1 5", "output": "18.123105625618" }, { "input": "3 7 5 7 4 4\n2\n4 6\n4 0", "output": "11.414213562373" }, { "input": "0 0 3 0 1 5\n2\n1 0\n1 20", "output": "36.000000000000" }, { "input": "0 0 0 1 1000 3\n2\n1000 2\n1000 1", "output": "1004.000000000000" }, { "input": "1000000000 0 0 1 0 0\n2\n0 2\n0 3", "output": "9.000000000000" }, { "input": "0 1000000000 1000000000 0 0 0\n1\n1 1", "output": "1000000000.414213500000" }, { "input": "1000 1000 1000 1001 0 0\n2\n0 1\n1 1", "output": "1416.213562373095" }, { "input": "1002 0 1001 0 0 0\n1\n1000 0", "output": "1001.000000000000" }, { "input": "1002 0 1001 0 0 0\n2\n2 0\n1 0", "output": "1003.000000000000" }, { "input": "3 0 0 100 0 0\n2\n1 0\n2 0", "output": "5.000000000000" }, { "input": "10 10 0 0 0 1\n2\n1 0\n1 1", "output": "4.414213562373" }, { "input": "1000 1000 1001 1001 0 0\n2\n0 1\n1 1", "output": "1416.213562373095" }, { "input": "0 100 0 200 0 0\n2\n0 1\n0 2", "output": "102.000000000000" }, { "input": "100 100 0 0 1 1\n1\n2 2", "output": "4.242640687119" }, { "input": "123123 154345 123123 123123 2 2\n3\n3 3\n4 4\n5 5", "output": "174127.873294312070" }, { "input": "0 1 0 2 0 0\n1\n1 0", "output": "2.414213562373" }, { "input": "1 2 3 4 1000 1000\n1\n156 608", "output": "1553.668251715911" }, { "input": "0 0 10 0 5 0\n3\n4 1\n5 1\n6 1", "output": "10.365746312737" }, { "input": "0 0 0 1 1000000000 999999999\n1\n1000000000 1000000000", "output": "1414213562.665988200000" }, { "input": "1231231 2342342 123124 123151 12315 12312\n1\n354345 234234", "output": "664238.053973730540" }, { "input": "0 0 1000000 0 1 1\n2\n0 1\n3 0", "output": "6.472135955000" }, { "input": "1000 1000 2000 2000 1 1\n1\n2 2", "output": "1412.799348810722" }, { "input": "10 20 10 0 10 10\n2\n10 11\n10 9", "output": "12.000000000000" }, { "input": "1000000000 1 1 1000000000 0 0\n1\n2 2", "output": "1000000000.828427200000" }, { "input": "0 0 1000 1000 1 0\n2\n2 0\n3 0", "output": "7.000000000000" }, { "input": "1000 0 100000000 100000000 0 0\n2\n999 0\n1100 0", "output": "3198.000000000000" }, { "input": "2 2 1000000000 1000000000 0 0\n3\n1 1\n5 5\n100 100", "output": "296.984848098350" }, { "input": "2 0 4 0 0 0\n1\n3 0", "output": "4.000000000000" }, { "input": "2 2 1000 1000 0 0\n2\n1 1\n1 2", "output": "6.064495102246" }, { "input": "0 0 1000000000 1000000000 0 1\n3\n1 0\n2 0\n3 0", "output": "13.210904837709" }, { "input": "1 10000 10000 1 0 0\n2\n1 100\n100 1", "output": "10200.014999625020" }, { "input": "5 0 6 0 0 0\n2\n2 0\n0 2", "output": "9.000000000000" }, { "input": "2 4 1000000000 1000000000 0 0\n4\n2 3\n2 1\n3 2\n1 2", "output": "20.760925736391" }, { "input": "0 100 1 1 0 0\n2\n0 1\n3 1", "output": "7.162277660168" }, { "input": "0 0 10 0 8 2\n1\n6 0", "output": "6.828427124746" }, { "input": "0 9 0 8 0 1\n1\n0 0", "output": "9.000000000000" }, { "input": "100 0 0 100 0 0\n2\n40 0\n0 40", "output": "180.000000000000" }, { "input": "0 0 0 1 1000 3\n2\n1000 1\n1000 2", "output": "1004.000000000000" }, { "input": "1 1 123123 123123 2 2\n3\n3 3\n4 4\n5 5", "output": "18.384776310850" }, { "input": "999999999 999999999 1000000000 1000000000 1 1\n1\n1 0", "output": "1414213561.251774800000" }, { "input": "3 2 1 1 0 0\n1\n2 2", "output": "3.828427124746" }, { "input": "0 0 1 1 100 100\n2\n101 101\n102 102", "output": "148.492424049175" }, { "input": "1 15 4 10 1 1\n2\n1 10\n4 5", "output": "22.000000000000" }, { "input": "100 0 0 100 0 0\n2\n60 0\n0 40", "output": "180.000000000000" }, { "input": "0 0 0 1000 1 0\n4\n0 1\n0 2\n0 3\n0 4", "output": "21.457116088945" }, { "input": "0 0 100 0 3 0\n1\n2 0", "output": "3.000000000000" }, { "input": "0 0 100 0 98 2\n1\n98 0", "output": "4.000000000000" }, { "input": "1 1 2 2 3 3\n1\n0 0", "output": "5.656854249492" }, { "input": "2 2 1 1 0 0\n1\n1 2", "output": "3.236067977500" }, { "input": "10000000 1 2 1 1 1\n3\n1 40\n1 20\n1 5", "output": "124.012818406262" }, { "input": "1000 1000 1001 1000 0 0\n3\n1 1\n1 2\n1 3", "output": "1421.848684511914" }, { "input": "10000 10000 9999 9999 0 0\n3\n0 1\n0 2\n0 3", "output": "14147.600248963827" } ]

1,627,328,876

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

24

780

31,948,800

import math def getdist(x,y,a,c): return math.sqrt((x-a)**2+(c-y)**2) def main(n,points,start): x1,y1=start[0],start[1] x2,y2=start[2],start[3] x3,y3=start[4],start[5] dist=[] dist_p1=[] dist_p2=[] for i in range(len(points)): x4,y4=points[i] dist.append(getdist(x4,y4,x3,y3)) dist_p1.append((i,getdist(x4,y4,x1,y1)-dist[i])) dist_p2.append((i,getdist(x4,y4,x2,y2)-dist[i])) dist_p2.sort(key=lambda x:x[1]) val1=dist_p2[0] if len(dist_p2)>1: val2=dist_p2[1] else: val2=(None,float('inf')) sum_dist=sum(dist) ans=float('inf') for i in range(len(dist_p1)): i1,d1=dist_p1[i] i2,d2=val1 i3,d3=val2 if i1!=i2: ans=min(ans,d1+d2+2*sum_dist) elif i3!=None: ans=min(ans,d1+d3+2*sum_dist) i1,d1=dist_p1[i] i2,d2=val1 ans=min(ans,d1+2*sum_dist) ans=min(ans,d2+2*sum_dist) return ans start=list(map(int,input().split())) n=int(input()) arr=[] for i in range(n): arr.append(list(map(int,input().split()))) print(main(n,arr,start))

Title: none Time Limit: None seconds Memory Limit: None megabytes Problem Description: It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin. We can think Central Perk as coordinate plane. There are *n* bottles on the ground, the *i*-th bottle is located at position (*x**i*,<=*y**i*). Both Adil and Bera can carry only one bottle at once each. For both Adil and Bera the process looks as follows: 1. Choose to stop or to continue to collect bottles. 1. If the choice was to continue then choose some bottle and walk towards it. 1. Pick this bottle and walk to the recycling bin. 1. Go to step 1. Adil and Bera may move independently. They are allowed to pick bottles simultaneously, all bottles may be picked by any of the two, it's allowed that one of them stays still while the other one continues to pick bottles. They want to organize the process such that the total distance they walk (the sum of distance walked by Adil and distance walked by Bera) is minimum possible. Of course, at the end all bottles should lie in the recycling bin. Input Specification: First line of the input contains six integers *a**x*, *a**y*, *b**x*, *b**y*, *t**x* and *t**y* (0<=≤<=*a**x*,<=*a**y*,<=*b**x*,<=*b**y*,<=*t**x*,<=*t**y*<=≤<=109) — initial positions of Adil, Bera and recycling bin respectively. The second line contains a single integer *n* (1<=≤<=*n*<=≤<=100<=000) — the number of bottles on the ground. Then follow *n* lines, each of them contains two integers *x**i* and *y**i* (0<=≤<=*x**i*,<=*y**i*<=≤<=109) — position of the *i*-th bottle. It's guaranteed that positions of Adil, Bera, recycling bin and all bottles are distinct. Output Specification: Print one real number — the minimum possible total distance Adil and Bera need to walk in order to put all bottles into recycling bin. Your answer will be considered correct if its absolute or relative error does not exceed 10<=-<=6. Namely: let's assume that your answer is *a*, and the answer of the jury is *b*. The checker program will consider your answer correct if . Demo Input: ['3 1 1 2 0 0\n3\n1 1\n2 1\n2 3\n', '5 0 4 2 2 0\n5\n5 2\n3 0\n5 5\n3 5\n3 3\n'] Demo Output: ['11.084259940083\n', '33.121375178000\n'] Note: Consider the first sample. Adil will use the following path: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/37eea809c04afe04f2670475cc5b21df4a90afd1.png" style="max-width: 100.0%;max-height: 100.0%;"/>. Bera will use the following path: <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/08e917ff238fec015f897516a95529b6d9aed5c7.png" style="max-width: 100.0%;max-height: 100.0%;"/>. Adil's path will be <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/f58aa00f71a0b723b5de3c8e56ce41dc8afec7f8.png" style="max-width: 100.0%;max-height: 100.0%;"/> units long, while Bera's path will be <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/3615db76a2cdd77d711b73d2894f03bdd52af736.png" style="max-width: 100.0%;max-height: 100.0%;"/> units long.

```python import math def getdist(x,y,a,c): return math.sqrt((x-a)**2+(c-y)**2) def main(n,points,start): x1,y1=start[0],start[1] x2,y2=start[2],start[3] x3,y3=start[4],start[5] dist=[] dist_p1=[] dist_p2=[] for i in range(len(points)): x4,y4=points[i] dist.append(getdist(x4,y4,x3,y3)) dist_p1.append((i,getdist(x4,y4,x1,y1)-dist[i])) dist_p2.append((i,getdist(x4,y4,x2,y2)-dist[i])) dist_p2.sort(key=lambda x:x[1]) val1=dist_p2[0] if len(dist_p2)>1: val2=dist_p2[1] else: val2=(None,float('inf')) sum_dist=sum(dist) ans=float('inf') for i in range(len(dist_p1)): i1,d1=dist_p1[i] i2,d2=val1 i3,d3=val2 if i1!=i2: ans=min(ans,d1+d2+2*sum_dist) elif i3!=None: ans=min(ans,d1+d3+2*sum_dist) i1,d1=dist_p1[i] i2,d2=val1 ans=min(ans,d1+2*sum_dist) ans=min(ans,d2+2*sum_dist) return ans start=list(map(int,input().split())) n=int(input()) arr=[] for i in range(n): arr.append(list(map(int,input().split()))) print(main(n,arr,start)) ```

0

508

A

Pasha and Pixels

PROGRAMMING

1,100

[ "brute force" ]

null

Pasha loves his phone and also putting his hair up... But the hair is now irrelevant. Pasha has installed a new game to his phone. The goal of the game is following. There is a rectangular field consisting of *n* row with *m* pixels in each row. Initially, all the pixels are colored white. In one move, Pasha can choose any pixel and color it black. In particular, he can choose the pixel that is already black, then after the boy's move the pixel does not change, that is, it remains black. Pasha loses the game when a 2<=×<=2 square consisting of black pixels is formed. Pasha has made a plan of *k* moves, according to which he will paint pixels. Each turn in his plan is represented as a pair of numbers *i* and *j*, denoting respectively the row and the column of the pixel to be colored on the current move. Determine whether Pasha loses if he acts in accordance with his plan, and if he does, on what move the 2<=×<=2 square consisting of black pixels is formed.

The first line of the input contains three integers *n*,<=*m*,<=*k* (1<=≤<=*n*,<=*m*<=≤<=1000, 1<=≤<=*k*<=≤<=105) — the number of rows, the number of columns and the number of moves that Pasha is going to perform. The next *k* lines contain Pasha's moves in the order he makes them. Each line contains two integers *i* and *j* (1<=≤<=*i*<=≤<=*n*, 1<=≤<=*j*<=≤<=*m*), representing the row number and column number of the pixel that was painted during a move.

If Pasha loses, print the number of the move when the 2<=×<=2 square consisting of black pixels is formed. If Pasha doesn't lose, that is, no 2<=×<=2 square consisting of black pixels is formed during the given *k* moves, print 0.

[ "2 2 4\n1 1\n1 2\n2 1\n2 2\n", "2 3 6\n2 3\n2 2\n1 3\n2 2\n1 2\n1 1\n", "5 3 7\n2 3\n1 2\n1 1\n4 1\n3 1\n5 3\n3 2\n" ]

[ "4\n", "5\n", "0\n" ]

none

500

[ { "input": "2 2 4\n1 1\n1 2\n2 1\n2 2", "output": "4" }, { "input": "2 3 6\n2 3\n2 2\n1 3\n2 2\n1 2\n1 1", "output": "5" }, { "input": "5 3 7\n2 3\n1 2\n1 1\n4 1\n3 1\n5 3\n3 2", "output": "0" }, { "input": "3 3 11\n2 1\n3 1\n1 1\n1 3\n1 2\n2 3\n3 3\n3 2\n2 2\n1 3\n3 3", "output": "9" }, { "input": "2 2 5\n1 1\n2 1\n2 1\n1 2\n2 2", "output": "5" }, { "input": "518 518 10\n37 97\n47 278\n17 467\n158 66\n483 351\n83 123\n285 219\n513 187\n380 75\n304 352", "output": "0" }, { "input": "1 1 5\n1 1\n1 1\n1 1\n1 1\n1 1", "output": "0" }, { "input": "1 5 5\n1 1\n1 2\n1 3\n1 4\n1 5", "output": "0" }, { "input": "5 1 5\n1 1\n2 1\n3 1\n4 1\n5 1", "output": "0" }, { "input": "1 1 1\n1 1", "output": "0" }, { "input": "10 10 4\n5 9\n6 9\n6 10\n5 10", "output": "4" }, { "input": "1000 1000 4\n999 999\n999 1000\n1000 999\n1000 1000", "output": "4" }, { "input": "2 3 5\n2 3\n1 3\n1 2\n1 1\n2 2", "output": "5" }, { "input": "1000 1000 4\n1000 1000\n999 999\n1000 999\n999 1000", "output": "4" } ]

1,668,439,180

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

3

30

0

n, m, k = [int(x) for x in input().split()] Matrix = [[0 for i in range(m)] for j in range(n)] for u in range(1, k+1): r, c = [int(x) for x in input().split()] Matrix[r-1][c-1] = u run = [[0, 0], [1, 0], [0, 1], [1, 1]] step = 99999999 for i in range(m-1): for j in range(n-1): z = 0 for p in run: a = Matrix[j + p[0]][i + p[1]] if a == 0: break z = max(z, Matrix[j + p[0]][i + p[1]]) m = min(step, z) if m == 99999999: print('0') else: print(m)

Title: Pasha and Pixels Time Limit: None seconds Memory Limit: None megabytes Problem Description: Pasha loves his phone and also putting his hair up... But the hair is now irrelevant. Pasha has installed a new game to his phone. The goal of the game is following. There is a rectangular field consisting of *n* row with *m* pixels in each row. Initially, all the pixels are colored white. In one move, Pasha can choose any pixel and color it black. In particular, he can choose the pixel that is already black, then after the boy's move the pixel does not change, that is, it remains black. Pasha loses the game when a 2<=×<=2 square consisting of black pixels is formed. Pasha has made a plan of *k* moves, according to which he will paint pixels. Each turn in his plan is represented as a pair of numbers *i* and *j*, denoting respectively the row and the column of the pixel to be colored on the current move. Determine whether Pasha loses if he acts in accordance with his plan, and if he does, on what move the 2<=×<=2 square consisting of black pixels is formed. Input Specification: The first line of the input contains three integers *n*,<=*m*,<=*k* (1<=≤<=*n*,<=*m*<=≤<=1000, 1<=≤<=*k*<=≤<=105) — the number of rows, the number of columns and the number of moves that Pasha is going to perform. The next *k* lines contain Pasha's moves in the order he makes them. Each line contains two integers *i* and *j* (1<=≤<=*i*<=≤<=*n*, 1<=≤<=*j*<=≤<=*m*), representing the row number and column number of the pixel that was painted during a move. Output Specification: If Pasha loses, print the number of the move when the 2<=×<=2 square consisting of black pixels is formed. If Pasha doesn't lose, that is, no 2<=×<=2 square consisting of black pixels is formed during the given *k* moves, print 0. Demo Input: ['2 2 4\n1 1\n1 2\n2 1\n2 2\n', '2 3 6\n2 3\n2 2\n1 3\n2 2\n1 2\n1 1\n', '5 3 7\n2 3\n1 2\n1 1\n4 1\n3 1\n5 3\n3 2\n'] Demo Output: ['4\n', '5\n', '0\n'] Note: none

```python n, m, k = [int(x) for x in input().split()] Matrix = [[0 for i in range(m)] for j in range(n)] for u in range(1, k+1): r, c = [int(x) for x in input().split()] Matrix[r-1][c-1] = u run = [[0, 0], [1, 0], [0, 1], [1, 1]] step = 99999999 for i in range(m-1): for j in range(n-1): z = 0 for p in run: a = Matrix[j + p[0]][i + p[1]] if a == 0: break z = max(z, Matrix[j + p[0]][i + p[1]]) m = min(step, z) if m == 99999999: print('0') else: print(m) ```

0

709

A

Juicer

PROGRAMMING

900

[ "implementation" ]

null

Kolya is going to make fresh orange juice. He has *n* oranges of sizes *a*1,<=*a*2,<=...,<=*a**n*. Kolya will put them in the juicer in the fixed order, starting with orange of size *a*1, then orange of size *a*2 and so on. To be put in the juicer the orange must have size not exceeding *b*, so if Kolya sees an orange that is strictly greater he throws it away and continues with the next one. The juicer has a special section to collect waste. It overflows if Kolya squeezes oranges of the total size strictly greater than *d*. When it happens Kolya empties the waste section (even if there are no more oranges) and continues to squeeze the juice. How many times will he have to empty the waste section?

The first line of the input contains three integers *n*, *b* and *d* (1<=≤<=*n*<=≤<=100<=000, 1<=≤<=*b*<=≤<=*d*<=≤<=1<=000<=000) — the number of oranges, the maximum size of the orange that fits in the juicer and the value *d*, which determines the condition when the waste section should be emptied. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=1<=000<=000) — sizes of the oranges listed in the order Kolya is going to try to put them in the juicer.

Print one integer — the number of times Kolya will have to empty the waste section.

[ "2 7 10\n5 6\n", "1 5 10\n7\n", "3 10 10\n5 7 7\n", "1 1 1\n1\n" ]

[ "1\n", "0\n", "1\n", "0\n" ]

In the first sample, Kolya will squeeze the juice from two oranges and empty the waste section afterwards. In the second sample, the orange won't fit in the juicer so Kolya will have no juice at all.

500

[ { "input": "2 7 10\n5 6", "output": "1" }, { "input": "1 5 10\n7", "output": "0" }, { "input": "3 10 10\n5 7 7", "output": "1" }, { "input": "1 1 1\n1", "output": "0" }, { "input": "2 951637 951638\n44069 951637", "output": "1" }, { "input": "50 100 129\n55 130 91 19 116 3 63 52 104 76 75 27 151 99 149 147 39 148 84 9 132 49 40 112 124 141 144 93 36 32 146 74 48 38 150 55 94 32 107 69 77 81 33 57 62 98 78 127 154 126", "output": "12" }, { "input": "100 1000 1083\n992 616 818 359 609 783 263 989 501 929 362 394 919 1081 870 830 1097 975 62 346 531 367 323 457 707 360 949 334 867 116 478 417 961 963 1029 114 867 1008 988 916 983 1077 959 942 572 961 579 318 721 337 488 717 111 70 416 685 987 130 353 107 61 191 827 849 106 815 211 953 111 398 889 860 801 71 375 320 395 1059 116 222 931 444 582 74 677 655 88 173 686 491 661 186 114 832 615 814 791 464 517 850", "output": "36" }, { "input": "2 6 8\n2 1", "output": "0" }, { "input": "5 15 16\n7 11 5 12 8", "output": "2" }, { "input": "15 759966 759967\n890397 182209 878577 548548 759966 812923 759966 860479 200595 381358 299175 339368 759966 907668 69574", "output": "4" }, { "input": "5 234613 716125\n642626 494941 234613 234613 234613", "output": "0" }, { "input": "50 48547 567054\n529808 597004 242355 559114 78865 537318 631455 733020 655072 645093 309010 855034 306058 625046 524574 834944 27330 664392 443637 821584 338013 490702 289520 675471 885846 258814 134220 571301 84875 94132 200425 928833 375166 521232 317961 175315 947093 89971 322071 174033 48547 998535 954205 704114 943163 438900 48547 538422 48547 48547", "output": "0" }, { "input": "5 10 20\n10 10 10 10 1", "output": "1" }, { "input": "5 10 11\n10 10 10 10 1", "output": "2" }, { "input": "3 10 10\n4 3 3", "output": "0" }, { "input": "3 5 5\n5 5 5", "output": "1" }, { "input": "3 4 14\n5 5 5", "output": "0" }, { "input": "2 7 10\n1234 1234", "output": "0" }, { "input": "1 5 6\n10", "output": "0" }, { "input": "3 4 6\n1 2 3", "output": "0" }, { "input": "5 10 12\n13 13 13 13 13", "output": "0" }, { "input": "3 4 5\n5 7 9", "output": "0" }, { "input": "3 10 100\n5 5 5", "output": "0" }, { "input": "5 1 2\n2 2 2 2 2", "output": "0" }, { "input": "5 5 5\n5 5 5 5 5", "output": "2" }, { "input": "2 2 5\n5 5", "output": "0" }, { "input": "3 1 4\n2 2 2", "output": "0" } ]

1,612,548,942

2,147,483,647

PyPy 3

WRONG_ANSWER

TESTS

6

124

10,444,800

n, b, d = map(int, input().split()) a = [int(i) for i in input().split()] ans = 0 now = 0 for u in range(n): now += a[u] if now > d: ans += 1 now = 0 print(ans)

Title: Juicer Time Limit: None seconds Memory Limit: None megabytes Problem Description: Kolya is going to make fresh orange juice. He has *n* oranges of sizes *a*1,<=*a*2,<=...,<=*a**n*. Kolya will put them in the juicer in the fixed order, starting with orange of size *a*1, then orange of size *a*2 and so on. To be put in the juicer the orange must have size not exceeding *b*, so if Kolya sees an orange that is strictly greater he throws it away and continues with the next one. The juicer has a special section to collect waste. It overflows if Kolya squeezes oranges of the total size strictly greater than *d*. When it happens Kolya empties the waste section (even if there are no more oranges) and continues to squeeze the juice. How many times will he have to empty the waste section? Input Specification: The first line of the input contains three integers *n*, *b* and *d* (1<=≤<=*n*<=≤<=100<=000, 1<=≤<=*b*<=≤<=*d*<=≤<=1<=000<=000) — the number of oranges, the maximum size of the orange that fits in the juicer and the value *d*, which determines the condition when the waste section should be emptied. The second line contains *n* integers *a*1,<=*a*2,<=...,<=*a**n* (1<=≤<=*a**i*<=≤<=1<=000<=000) — sizes of the oranges listed in the order Kolya is going to try to put them in the juicer. Output Specification: Print one integer — the number of times Kolya will have to empty the waste section. Demo Input: ['2 7 10\n5 6\n', '1 5 10\n7\n', '3 10 10\n5 7 7\n', '1 1 1\n1\n'] Demo Output: ['1\n', '0\n', '1\n', '0\n'] Note: In the first sample, Kolya will squeeze the juice from two oranges and empty the waste section afterwards. In the second sample, the orange won't fit in the juicer so Kolya will have no juice at all.

```python n, b, d = map(int, input().split()) a = [int(i) for i in input().split()] ans = 0 now = 0 for u in range(n): now += a[u] if now > d: ans += 1 now = 0 print(ans) ```

0

78

A

Haiku

PROGRAMMING

800

[ "implementation", "strings" ]

A. Haiku

2

256

Haiku is a genre of Japanese traditional poetry. A haiku poem consists of 17 syllables split into three phrases, containing 5, 7 and 5 syllables correspondingly (the first phrase should contain exactly 5 syllables, the second phrase should contain exactly 7 syllables, and the third phrase should contain exactly 5 syllables). A haiku masterpiece contains a description of a moment in those three phrases. Every word is important in a small poem, which is why haiku are rich with symbols. Each word has a special meaning, a special role. The main principle of haiku is to say much using a few words. To simplify the matter, in the given problem we will consider that the number of syllable in the phrase is equal to the number of vowel letters there. Only the following letters are regarded as vowel letters: "a", "e", "i", "o" and "u". Three phases from a certain poem are given. Determine whether it is haiku or not.

The input data consists of three lines. The length of each line is between 1 and 100, inclusive. The *i*-th line contains the *i*-th phrase of the poem. Each phrase consists of one or more words, which are separated by one or more spaces. A word is a non-empty sequence of lowercase Latin letters. Leading and/or trailing spaces in phrases are allowed. Every phrase has at least one non-space character. See the example for clarification.

Print "YES" (without the quotes) if the poem is a haiku. Otherwise, print "NO" (also without the quotes).

[ "on codeforces \nbeta round is running\n a rustling of keys \n", "how many gallons\nof edo s rain did you drink\n cuckoo\n" ]

[ "YES", "NO" ]

none

500

[ { "input": "on codeforces \nbeta round is running\n a rustling of keys ", "output": "YES" }, { "input": "how many gallons\nof edo s rain did you drink\n cuckoo", "output": "NO" }, { "input": " hatsu shigure\n saru mo komino wo\nhoshige nari", "output": "YES" }, { "input": "o vetus stagnum\n rana de ripa salit\n ac sonant aquae", "output": "NO" }, { "input": " furuike ya\nkawazu tobikomu\nmizu no oto ", "output": "YES" }, { "input": " noch da leich\na stamperl zum aufwaerma\n da pfarrer kimmt a ", "output": "NO" }, { "input": " sommerfuglene \n hvorfor bruge mange ord\n et kan gore det", "output": "YES" }, { "input": " ab der mittagszeit\n ist es etwas schattiger\n ein wolkenhimmel", "output": "NO" }, { "input": "tornando a vederli\ni fiori di ciliegio la sera\nson divenuti frutti", "output": "NO" }, { "input": "kutaburete\nyado karu koro ya\nfuji no hana", "output": "YES" }, { "input": " beginnings of poetry\n the rice planting songs \n of the interior", "output": "NO" }, { "input": " door zomerregens\n zijn de kraanvogelpoten\n korter geworden", "output": "NO" }, { "input": " derevo na srub\na ptitsi bezzabotno\n gnezdishko tam vyut", "output": "YES" }, { "input": "writing in the dark\nunaware that my pen\nhas run out of ink", "output": "NO" }, { "input": "kusaaiu\nuieueua\nuo efaa", "output": "YES" }, { "input": "v\nh\np", "output": "NO" }, { "input": "i\ni\nu", "output": "NO" }, { "input": "awmio eoj\nabdoolceegood\nwaadeuoy", "output": "YES" }, { "input": "xzpnhhnqsjpxdboqojixmofawhdjcfbscq\nfoparnxnbzbveycoltwdrfbwwsuobyoz hfbrszy\nimtqryscsahrxpic agfjh wvpmczjjdrnwj mcggxcdo", "output": "YES" }, { "input": "wxjcvccp cppwsjpzbd dhizbcnnllckybrnfyamhgkvkjtxxfzzzuyczmhedhztugpbgpvgh\nmdewztdoycbpxtp bsiw hknggnggykdkrlihvsaykzfiiw\ndewdztnngpsnn lfwfbvnwwmxoojknygqb hfe ibsrxsxr", "output": "YES" }, { "input": "nbmtgyyfuxdvrhuhuhpcfywzrbclp znvxw synxmzymyxcntmhrjriqgdjh xkjckydbzjbvtjurnf\nhhnhxdknvamywhsrkprofnyzlcgtdyzzjdsfxyddvilnzjziz qmwfdvzckgcbrrxplxnxf mpxwxyrpesnewjrx ajxlfj\nvcczq hddzd cvefmhxwxxyqcwkr fdsndckmesqeq zyjbwbnbyhybd cta nsxzidl jpcvtzkldwd", "output": "YES" }, { "input": "rvwdsgdsrutgjwscxz pkd qtpmfbqsmctuevxdj kjzknzghdvxzlaljcntg jxhvzn yciktbsbyscfypx x xhkxnfpdp\nwdfhvqgxbcts mnrwbr iqttsvigwdgvlxwhsmnyxnttedonxcfrtmdjjmacvqtkbmsnwwvvrlxwvtggeowtgsqld qj\nvsxcdhbzktrxbywpdvstr meykarwtkbm pkkbhvwvelclfmpngzxdmblhcvf qmabmweldplmczgbqgzbqnhvcdpnpjtch ", "output": "YES" }, { "input": "brydyfsmtzzkpdsqvvztmprhqzbzqvgsblnz naait tdtiprjsttwusdykndwcccxfmzmrmfmzjywkpgbfnjpypgcbcfpsyfj k\nucwdfkfyxxxht lxvnovqnnsqutjsyagrplb jhvtwdptrwcqrovncdvqljjlrpxcfbxqgsfylbgmcjpvpl ccbcybmigpmjrxpu\nfgwtpcjeywgnxgbttgx htntpbk tkkpwbgxwtbxvcpkqbzetjdkcwad tftnjdxxjdvbpfibvxuglvx llyhgjvggtw jtjyphs", "output": "YES" }, { "input": "nyc aqgqzjjlj mswgmjfcxlqdscheskchlzljlsbhyn iobxymwzykrsnljj\nnnebeaoiraga\nqpjximoqzswhyyszhzzrhfwhf iyxysdtcpmikkwpugwlxlhqfkn", "output": "NO" }, { "input": "lzrkztgfe mlcnq ay ydmdzxh cdgcghxnkdgmgfzgahdjjmqkpdbskreswpnblnrc fmkwziiqrbskp\np oukeaz gvvy kghtrjlczyl qeqhgfgfej\nwfolhkmktvsjnrpzfxcxzqmfidtlzmuhxac wsncjgmkckrywvxmnjdpjpfydhk qlmdwphcvyngansqhl", "output": "NO" }, { "input": "yxcboqmpwoevrdhvpxfzqmammak\njmhphkxppkqkszhqqtkvflarsxzla pbxlnnnafqbsnmznfj qmhoktgzix qpmrgzxqvmjxhskkksrtryehfnmrt dtzcvnvwp\nscwymuecjxhw rdgsffqywwhjpjbfcvcrnisfqllnbplpadfklayjguyvtrzhwblftclfmsr", "output": "NO" }, { "input": "qfdwsr jsbrpfmn znplcx nhlselflytndzmgxqpgwhpi ghvbbxrkjdirfghcybhkkqdzmyacvrrcgsneyjlgzfvdmxyjmph\nylxlyrzs drbktzsniwcbahjkgohcghoaczsmtzhuwdryjwdijmxkmbmxv yyfrokdnsx\nyw xtwyzqlfxwxghugoyscqlx pljtz aldfskvxlsxqgbihzndhxkswkxqpwnfcxzfyvncstfpqf", "output": "NO" }, { "input": "g rguhqhcrzmuqthtmwzhfyhpmqzzosa\nmhjimzvchkhejh irvzejhtjgaujkqfxhpdqjnxr dvqallgssktqvsxi\npcwbliftjcvuzrsqiswohi", "output": "NO" }, { "input": " ngxtlq iehiise vgffqcpnmsoqzyseuqqtggokymol zn\nvjdjljazeujwoubkcvtsbepooxqzrueaauokhepiquuopfild\ngoabauauaeotoieufueeknudiilupouaiaexcoapapu", "output": "NO" }, { "input": "ycnvnnqk mhrmhctpkfbc qbyvtjznmndqjzgbcxmvrpkfcll zwspfptmbxgrdv dsgkk nfytsqjrnfbhh pzdldzymvkdxxwh\nvnhjfwgdnyjptsmblyxmpzylsbjlmtkkwjcbqwjctqvrlqqkdsrktxlnslspvnn mdgsmzblhbnvpczmqkcffwhwljqkzmk hxcm\nrghnjvzcpprrgmtgytpkzyc mrdnnhpkwypwqbtzjyfwvrdwyjltbzxtbstzs xdjzdmx yjsqtzlrnvyssvglsdjrmsrfrcdpqt", "output": "NO" }, { "input": "ioeeaioeiuoeaeieuuieooaouiuouiioaueeaiaiuoaoiioeeaauooiuuieeuaeeoauieeaiuoieiaieuoauaaoioooieueueuai\nuooaoeeaoiuuoeioaoouaououoeioiaeueoioaiouaeaoioiuuaueeuaiuoiueoiuaoeeieeouaeeaeeieioeoiiieuuueuuieuo\naeeouieeieoueaioeoioooiouaeeeiaaioueauaueiouuuaieuuioiaeiueauueaoieauauoeueuaiueuuaueeoueauaeaoieeoo", "output": "NO" }, { "input": "mkgycgmrqtmlwj vddlbsgdptyfrcj nmrddjchydvbsyhgzytfzvwbhqmmhkpsyrcnknpsqrr wcnf wfvgskrnsmnrcqgcnc q\npn cclcyjjdp rqkpgyrvyyd hhynrochfa pthyffqvskazfshvzcmvhmsrxvquzkdvivlbfypwbgltfbjmhzljvgzmxjlrjdjq\nauuouieuaaauoooeoiuoaueuueauiuuuiaeuwuoiaeoeaieauieouoaeiiieiioiuuuiuauioiiuoeauueieaueiaioeuaoaaau", "output": "NO" }, { "input": "ab\na\na", "output": "NO" }, { "input": "on codeforcs\nbeta round is runnineg\na rustling of keys", "output": "NO" }, { "input": "coooooooooooooooood\nd\nd", "output": "NO" }, { "input": "on codeforces \nbeta round is runninog\n a rustling of keys", "output": "NO" }, { "input": "aaaaaaaaaaaaaaa\na\na", "output": "NO" }, { "input": "aaaaaccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\naaaaaaaccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\naaaaaccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", "output": "YES" }, { "input": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\ncccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\ncccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", "output": "NO" }, { "input": "aaaaaa\naaaaaa\naaaaa", "output": "NO" } ]

1,650,597,993

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

0

60

0

inp = [input(), input(), input()] inp = [sum(1 for i in j if i in 'aeiou') for j in inp] print(inp == [5,7,5])

Title: Haiku Time Limit: 2 seconds Memory Limit: 256 megabytes Problem Description: Haiku is a genre of Japanese traditional poetry. A haiku poem consists of 17 syllables split into three phrases, containing 5, 7 and 5 syllables correspondingly (the first phrase should contain exactly 5 syllables, the second phrase should contain exactly 7 syllables, and the third phrase should contain exactly 5 syllables). A haiku masterpiece contains a description of a moment in those three phrases. Every word is important in a small poem, which is why haiku are rich with symbols. Each word has a special meaning, a special role. The main principle of haiku is to say much using a few words. To simplify the matter, in the given problem we will consider that the number of syllable in the phrase is equal to the number of vowel letters there. Only the following letters are regarded as vowel letters: "a", "e", "i", "o" and "u". Three phases from a certain poem are given. Determine whether it is haiku or not. Input Specification: The input data consists of three lines. The length of each line is between 1 and 100, inclusive. The *i*-th line contains the *i*-th phrase of the poem. Each phrase consists of one or more words, which are separated by one or more spaces. A word is a non-empty sequence of lowercase Latin letters. Leading and/or trailing spaces in phrases are allowed. Every phrase has at least one non-space character. See the example for clarification. Output Specification: Print "YES" (without the quotes) if the poem is a haiku. Otherwise, print "NO" (also without the quotes). Demo Input: ['on codeforces \nbeta round is running\n a rustling of keys \n', 'how many gallons\nof edo s rain did you drink\n cuckoo\n'] Demo Output: ['YES', 'NO'] Note: none

```python inp = [input(), input(), input()] inp = [sum(1 for i in j if i in 'aeiou') for j in inp] print(inp == [5,7,5]) ```

0

711

A

Bus to Udayland

PROGRAMMING

800

[ "brute force", "implementation" ]

null

ZS the Coder and Chris the Baboon are travelling to Udayland! To get there, they have to get on the special IOI bus. The IOI bus has *n* rows of seats. There are 4 seats in each row, and the seats are separated into pairs by a walkway. When ZS and Chris came, some places in the bus was already occupied. ZS and Chris are good friends. They insist to get a pair of neighbouring empty seats. Two seats are considered neighbouring if they are in the same row and in the same pair. Given the configuration of the bus, can you help ZS and Chris determine where they should sit?

The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=1000) — the number of rows of seats in the bus. Then, *n* lines follow. Each line contains exactly 5 characters, the first two of them denote the first pair of seats in the row, the third character denotes the walkway (it always equals '|') and the last two of them denote the second pair of seats in the row. Each character, except the walkway, equals to 'O' or to 'X'. 'O' denotes an empty seat, 'X' denotes an occupied seat. See the sample cases for more details.

If it is possible for Chris and ZS to sit at neighbouring empty seats, print "YES" (without quotes) in the first line. In the next *n* lines print the bus configuration, where the characters in the pair of seats for Chris and ZS is changed with characters '+'. Thus the configuration should differ from the input one by exactly two charaters (they should be equal to 'O' in the input and to '+' in the output). If there is no pair of seats for Chris and ZS, print "NO" (without quotes) in a single line. If there are multiple solutions, you may print any of them.

500

[ { "input": "6\nOO|OX\nXO|XX\nOX|OO\nXX|OX\nOO|OO\nOO|XX", "output": "YES\n++|OX\nXO|XX\nOX|OO\nXX|OX\nOO|OO\nOO|XX" }, { "input": "4\nXO|OX\nXO|XX\nOX|OX\nXX|OX", "output": "NO" }, { "input": "5\nXX|XX\nXX|XX\nXO|OX\nXO|OO\nOX|XO", "output": "YES\nXX|XX\nXX|XX\nXO|OX\nXO|++\nOX|XO" }, { "input": "1\nXO|OX", "output": "NO" }, { "input": "1\nOO|OO", "output": "YES\n++|OO" }, { "input": "4\nXO|XX\nXX|XO\nOX|XX\nXO|XO", "output": "NO" }, { "input": "9\nOX|XO\nOX|XO\nXO|OX\nOX|OX\nXO|OX\nXX|OO\nOX|OX\nOX|XO\nOX|OX", "output": "YES\nOX|XO\nOX|XO\nXO|OX\nOX|OX\nXO|OX\nXX|++\nOX|OX\nOX|XO\nOX|OX" }, { "input": "61\nOX|XX\nOX|XX\nOX|XX\nXO|XO\nXX|XO\nXX|XX\nXX|XX\nOX|XX\nXO|XO\nOX|XO\nXO|OX\nXX|XX\nXX|XX\nOX|OX\nXX|OX\nOX|XO\nOX|XO\nXO|OX\nXO|XX\nOX|XX\nOX|XX\nXO|OX\nXO|XX\nXO|XX\nOX|XX\nXX|XX\nXX|XO\nXO|XX\nXX|XX\nXO|OX\nXX|XO\nXO|XX\nXO|XO\nXO|OX\nXX|OX\nXO|OX\nOX|XX\nXX|OX\nXX|XX\nOX|XO\nOX|XX\nXO|OX\nOX|XX\nOX|XX\nXO|XO\nXO|XX\nOX|XX\nXO|XO\nOX|XX\nXX|XX\nOX|XO\nXO|XO\nXO|XO\nOX|OX\nXX|OX\nXX|OX\nOX|XO\nOX|XX\nOX|OX\nXO|XX\nOX|XX", "output": "NO" }, { "input": "1\nOO|XX", "output": "YES\n++|XX" }, { "input": "10\nOO|XX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXX|XX", "output": "YES\n++|XX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXX|XX" }, { "input": "10\nXX|XX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXX|OO", "output": "YES\nXX|XX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXO|OX\nXX|++" }, { "input": "5\nXX|XX\nXX|XX\nXO|OX\nOO|OX\nOX|XO", "output": "YES\nXX|XX\nXX|XX\nXO|OX\n++|OX\nOX|XO" }, { "input": "6\nOO|XX\nXO|XX\nOX|OO\nXX|OX\nOO|XX\nOX|XX", "output": "YES\n++|XX\nXO|XX\nOX|OO\nXX|OX\nOO|XX\nOX|XX" } ]

1,697,831,071

2,147,483,647

Python 3

OK

TESTS

71

46

102,400

n = int(input()) a = [] flag = 1 for i in range(n): row = list(input()) a.append(row) if row[0] == 'O' and row[1] == 'O' and flag: flag = 0 row[0] = row[1] = '+' elif row[3] == 'O' and row[4] == 'O' and flag: flag = 0 row[3] = row[4] = '+' if flag: print("NO") else: print("YES") for i in range(n): print("".join(a[i]))

Title: Bus to Udayland Time Limit: None seconds Memory Limit: None megabytes Problem Description: ZS the Coder and Chris the Baboon are travelling to Udayland! To get there, they have to get on the special IOI bus. The IOI bus has *n* rows of seats. There are 4 seats in each row, and the seats are separated into pairs by a walkway. When ZS and Chris came, some places in the bus was already occupied. ZS and Chris are good friends. They insist to get a pair of neighbouring empty seats. Two seats are considered neighbouring if they are in the same row and in the same pair. Given the configuration of the bus, can you help ZS and Chris determine where they should sit? Input Specification: The first line of the input contains a single integer *n* (1<=≤<=*n*<=≤<=1000) — the number of rows of seats in the bus. Then, *n* lines follow. Each line contains exactly 5 characters, the first two of them denote the first pair of seats in the row, the third character denotes the walkway (it always equals '|') and the last two of them denote the second pair of seats in the row. Each character, except the walkway, equals to 'O' or to 'X'. 'O' denotes an empty seat, 'X' denotes an occupied seat. See the sample cases for more details. Output Specification: If it is possible for Chris and ZS to sit at neighbouring empty seats, print "YES" (without quotes) in the first line. In the next *n* lines print the bus configuration, where the characters in the pair of seats for Chris and ZS is changed with characters '+'. Thus the configuration should differ from the input one by exactly two charaters (they should be equal to 'O' in the input and to '+' in the output). If there is no pair of seats for Chris and ZS, print "NO" (without quotes) in a single line. If there are multiple solutions, you may print any of them. Demo Input: ['6\nOO|OX\nXO|XX\nOX|OO\nXX|OX\nOO|OO\nOO|XX\n', '4\nXO|OX\nXO|XX\nOX|OX\nXX|OX\n', '5\nXX|XX\nXX|XX\nXO|OX\nXO|OO\nOX|XO\n'] Demo Output: ['YES\n++|OX\nXO|XX\nOX|OO\nXX|OX\nOO|OO\nOO|XX\n', 'NO\n', 'YES\nXX|XX\nXX|XX\nXO|OX\nXO|++\nOX|XO\n'] Note: Note that the following is an incorrect configuration for the first sample case because the seats must be in the same pair. O+|+X XO|XX OX|OO XX|OX OO|OO OO|XX

```python n = int(input()) a = [] flag = 1 for i in range(n): row = list(input()) a.append(row) if row[0] == 'O' and row[1] == 'O' and flag: flag = 0 row[0] = row[1] = '+' elif row[3] == 'O' and row[4] == 'O' and flag: flag = 0 row[3] = row[4] = '+' if flag: print("NO") else: print("YES") for i in range(n): print("".join(a[i])) ```

3

322

B

Ciel and Flowers

PROGRAMMING

1,600

[ "combinatorics", "math" ]

null

Fox Ciel has some flowers: *r* red flowers, *g* green flowers and *b* blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets: - To make a "red bouquet", it needs 3 red flowers. - To make a "green bouquet", it needs 3 green flowers. - To make a "blue bouquet", it needs 3 blue flowers. - To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower. Help Fox Ciel to find the maximal number of bouquets she can make.

The first line contains three integers *r*, *g* and *b* (0<=≤<=*r*,<=*g*,<=*b*<=≤<=109) — the number of red, green and blue flowers.

Print the maximal number of bouquets Fox Ciel can make.

[ "3 6 9\n", "4 4 4\n", "0 0 0\n" ]

[ "6\n", "4\n", "0\n" ]

In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets. In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.

1,000

[ { "input": "3 6 9", "output": "6" }, { "input": "4 4 4", "output": "4" }, { "input": "0 0 0", "output": "0" }, { "input": "0 3 6", "output": "3" }, { "input": "7 8 9", "output": "7" }, { "input": "8 8 9", "output": "8" }, { "input": "15 3 999", "output": "339" }, { "input": "32 62 92", "output": "62" }, { "input": "123456789 123456789 123456789", "output": "123456789" }, { "input": "3 5 5", "output": "4" }, { "input": "666806767 385540591 357848286", "output": "470065214" }, { "input": "80010646 727118126 817880463", "output": "541669744" }, { "input": "829651016 732259171 572879931", "output": "711596705" }, { "input": "242854896 442432924 180395753", "output": "288561190" }, { "input": "139978911 5123031 935395222", "output": "360165721" }, { "input": "553182792 10264076 395427398", "output": "319624755" }, { "input": "597790453 720437830 855459575", "output": "724562619" }, { "input": "494914467 356982656 757942689", "output": "536613270" }, { "input": "908118348 67156409 217974865", "output": "397749873" }, { "input": "952726009 629846517 972974334", "output": "851848953" }, { "input": "775140200 616574841 630329230", "output": "674014756" }, { "input": "524780569 326748594 90361407", "output": "313963523" }, { "input": "937984449 184405994 992844522", "output": "705078321" }, { "input": "835108464 525983528 452876698", "output": "604656229" }, { "input": "879716125 531124573 207876166", "output": "539572288" }, { "input": "292920005 241298326 667908343", "output": "400708891" }, { "input": "1000000000 1000000000 1000000000", "output": "1000000000" }, { "input": "1000000000 999999999 999999998", "output": "999999998" }, { "input": "999999998 999999998 999999999", "output": "999999998" }, { "input": "0 1 1", "output": "0" }, { "input": "0 1000000000 0", "output": "333333333" }, { "input": "0 1 0", "output": "0" }, { "input": "1 0 0", "output": "0" }, { "input": "0 2 2", "output": "0" }, { "input": "3 3 5", "output": "3" }, { "input": "2 2 0", "output": "0" }, { "input": "0 5 5", "output": "2" }, { "input": "2 0 11", "output": "3" }, { "input": "9 9 7", "output": "8" }, { "input": "65 30 74", "output": "56" } ]

1,558,534,406

2,147,483,647

Python 3

WRONG_ANSWER

TESTS

9

218

0

r,b,g=[int(x) for x in input().split()] su=int(0) m=min(r,g,b) su+=m r=r-m g=g-m b=b-m su+=r//3 su+=g//3 su+=b//3 print(su)

Title: Ciel and Flowers Time Limit: None seconds Memory Limit: None megabytes Problem Description: Fox Ciel has some flowers: *r* red flowers, *g* green flowers and *b* blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets: - To make a "red bouquet", it needs 3 red flowers. - To make a "green bouquet", it needs 3 green flowers. - To make a "blue bouquet", it needs 3 blue flowers. - To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower. Help Fox Ciel to find the maximal number of bouquets she can make. Input Specification: The first line contains three integers *r*, *g* and *b* (0<=≤<=*r*,<=*g*,<=*b*<=≤<=109) — the number of red, green and blue flowers. Output Specification: Print the maximal number of bouquets Fox Ciel can make. Demo Input: ['3 6 9\n', '4 4 4\n', '0 0 0\n'] Demo Output: ['6\n', '4\n', '0\n'] Note: In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets. In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.

```python r,b,g=[int(x) for x in input().split()] su=int(0) m=min(r,g,b) su+=m r=r-m g=g-m b=b-m su+=r//3 su+=g//3 su+=b//3 print(su) ```

0

424

A

Squats

PROGRAMMING

900

[ "implementation" ]

null

Pasha has many hamsters and he makes them work out. Today, *n* hamsters (*n* is even) came to work out. The hamsters lined up and each hamster either sat down or stood up. For another exercise, Pasha needs exactly hamsters to stand up and the other hamsters to sit down. In one minute, Pasha can make some hamster ether sit down or stand up. How many minutes will he need to get what he wants if he acts optimally well?

The first line contains integer *n* (2<=≤<=*n*<=≤<=200; *n* is even). The next line contains *n* characters without spaces. These characters describe the hamsters' position: the *i*-th character equals 'X', if the *i*-th hamster in the row is standing, and 'x', if he is sitting.

In the first line, print a single integer — the minimum required number of minutes. In the second line, print a string that describes the hamsters' position after Pasha makes the required changes. If there are multiple optimal positions, print any of them.

[ "4\nxxXx\n", "2\nXX\n", "6\nxXXxXx\n" ]

[ "1\nXxXx\n", "1\nxX\n", "0\nxXXxXx\n" ]

none

500

[ { "input": "4\nxxXx", "output": "1\nXxXx" }, { "input": "2\nXX", "output": "1\nxX" }, { "input": "6\nxXXxXx", "output": "0\nxXXxXx" }, { "input": "4\nxXXX", "output": "1\nxxXX" }, { "input": "2\nXx", "output": "0\nXx" }, { "input": "22\nXXxXXxxXxXxXXXXXXXXXxx", "output": "4\nxxxxxxxXxXxXXXXXXXXXxx" }, { "input": "30\nXXxXxxXXXXxxXXxxXXxxxxXxxXXXxx", "output": "0\nXXxXxxXXXXxxXXxxXXxxxxXxxXXXxx" }, { "input": "104\nxxXxXxxXXXxxXxXxxXXXxxxXxxXXXxxXXXxXxXxXXxxXxxxxxXXXXxXXXXxXXXxxxXxxxxxxxXxxXxXXxxXXXXxXXXxxXXXXXXXXXxXX", "output": "4\nxxxxxxxxxXxxXxXxxXXXxxxXxxXXXxxXXXxXxXxXXxxXxxxxxXXXXxXXXXxXXXxxxXxxxxxxxXxxXxXXxxXXXXxXXXxxXXXXXXXXXxXX" }, { "input": "78\nxxxXxxXxXxxXxxxxxXxXXXxXXXXxxxxxXxXXXxxXxXXXxxxxXxxXXXxxxxxxxxXXXXxXxXXxXXXxXX", "output": "3\nXXXXxxXxXxxXxxxxxXxXXXxXXXXxxxxxXxXXXxxXxXXXxxxxXxxXXXxxxxxxxxXXXXxXxXXxXXXxXX" }, { "input": "200\nxxXXxxXXxXxxXxxXxXxxXxXxXxXxxxxxXXxXXxxXXXXxXXXxXXxXxXxxxxXxxXXXxxxXxXxxxXxxXXxXxXxxxxxxxXxxXxXxxXxXXXxxXxXXXXxxXxxxXxXXXXXXxXxXXxxxxXxxxXxxxXxXXXxXxXXXXxXXxxxXxXXxxXXxxxXxXxXXxXXXxXxXxxxXXxxxxXXxXXXX", "output": "4\nXXXXXXXXxXxxXxxXxXxxXxXxXxXxxxxxXXxXXxxXXXXxXXXxXXxXxXxxxxXxxXXXxxxXxXxxxXxxXXxXxXxxxxxxxXxxXxXxxXxXXXxxXxXXXXxxXxxxXxXXXXXXxXxXXxxxxXxxxXxxxXxXXXxXxXXXXxXXxxxXxXXxxXXxxxXxXxXXxXXXxXxXxxxXXxxxxXXxXXXX" }, { "input": "198\nxXxxXxxXxxXXxXxXxXxxXXXxxXxxxxXXXXxxXxxxxXXXXxXxXXxxxXXXXXXXxXXXxxxxXXxXXxXxXXxxxxXxXXXXXXxXxxXxXxxxXxXXXXxxXXxxXxxxXXxXxXXxXxXXxXXXXxxxxxXxXXxxxXxXXXXxXxXXxxXxXXxXxXXxxxXxXXXXxXxxXxXXXxxxxXxXXXXxXx", "output": "5\nxxxxxxxxxxxxxXxXxXxxXXXxxXxxxxXXXXxxXxxxxXXXXxXxXXxxxXXXXXXXxXXXxxxxXXxXXxXxXXxxxxXxXXXXXXxXxxXxXxxxXxXXXXxxXXxxXxxxXXxXxXXxXxXXxXXXXxxxxxXxXXxxxXxXXXXxXxXXxxXxXXxXxXXxxxXxXXXXxXxxXxXXXxxxxXxXXXXxXx" }, { "input": "200\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "output": "100\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" }, { "input": "198\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "output": "99\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" }, { "input": "200\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "output": "100\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" }, { "input": "198\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "output": "99\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" }, { "input": "2\nxx", "output": "1\nXx" }, { "input": "2\nXx", "output": "0\nXx" }, { "input": "2\nxX", "output": "0\nxX" }, { "input": "4\nXXXX", "output": "2\nxxXX" }, { "input": "4\nxxxx", "output": "2\nXXxx" }, { "input": "4\nxxXX", "output": "0\nxxXX" }, { "input": "4\nXXxx", "output": "0\nXXxx" }, { "input": "4\nxXxx", "output": "1\nXXxx" }, { "input": "4\nXxxx", "output": "1\nXXxx" }, { "input": "4\nxxxX", "output": "1\nXxxX" }, { "input": "4\nxxXx", "output": "1\nXxXx" }, { "input": "4\nXXXx", "output": "1\nxXXx" }, { "input": "4\nxXXX", "output": "1\nxxXX" }, { "input": "4\nXxXX", "output": "1\nxxXX" }, { "input": "4\nXXxX", "output": "1\nxXxX" }, { "input": "4\nXxXx", "output": "0\nXxXx" }, { "input": "6\nxXXxXX", "output": "1\nxxXxXX" } ]

1,458,416,531

2,147,483,647

Python 3

RUNTIME_ERROR

TESTS

0

46

4,608,000

import sys import itertools n, m = map(int, input('').split()) newlist = [] lst = list(map(int ,input().split())) for i in range(1,n+1): for combin in itertools.combinations(lst, i): combin = list(combin) if sum(combin) % m == 0 and combin != []: print('YES') sys.exit() print('NO')

Title: Squats Time Limit: None seconds Memory Limit: None megabytes Problem Description: Pasha has many hamsters and he makes them work out. Today, *n* hamsters (*n* is even) came to work out. The hamsters lined up and each hamster either sat down or stood up. For another exercise, Pasha needs exactly hamsters to stand up and the other hamsters to sit down. In one minute, Pasha can make some hamster ether sit down or stand up. How many minutes will he need to get what he wants if he acts optimally well? Input Specification: The first line contains integer *n* (2<=≤<=*n*<=≤<=200; *n* is even). The next line contains *n* characters without spaces. These characters describe the hamsters' position: the *i*-th character equals 'X', if the *i*-th hamster in the row is standing, and 'x', if he is sitting. Output Specification: In the first line, print a single integer — the minimum required number of minutes. In the second line, print a string that describes the hamsters' position after Pasha makes the required changes. If there are multiple optimal positions, print any of them. Demo Input: ['4\nxxXx\n', '2\nXX\n', '6\nxXXxXx\n'] Demo Output: ['1\nXxXx\n', '1\nxX\n', '0\nxXXxXx\n'] Note: none

```python import sys import itertools n, m = map(int, input('').split()) newlist = [] lst = list(map(int ,input().split())) for i in range(1,n+1): for combin in itertools.combinations(lst, i): combin = list(combin) if sum(combin) % m == 0 and combin != []: print('YES') sys.exit() print('NO') ```

-1

476

B

Dreamoon and WiFi

PROGRAMMING

1,300

[ "bitmasks", "brute force", "combinatorics", "dp", "math", "probabilities" ]

null

Dreamoon is standing at the position 0 on a number line. Drazil is sending a list of commands through Wi-Fi to Dreamoon's smartphone and Dreamoon follows them. Each command is one of the following two types: 1. Go 1 unit towards the positive direction, denoted as '+' 1. Go 1 unit towards the negative direction, denoted as '-' But the Wi-Fi condition is so poor that Dreamoon's smartphone reports some of the commands can't be recognized and Dreamoon knows that some of them might even be wrong though successfully recognized. Dreamoon decides to follow every recognized command and toss a fair coin to decide those unrecognized ones (that means, he moves to the 1 unit to the negative or positive direction with the same probability 0.5). You are given an original list of commands sent by Drazil and list received by Dreamoon. What is the probability that Dreamoon ends in the position originally supposed to be final by Drazil's commands?

The first line contains a string *s*1 — the commands Drazil sends to Dreamoon, this string consists of only the characters in the set {'+', '-'}. The second line contains a string *s*2 — the commands Dreamoon's smartphone recognizes, this string consists of only the characters in the set {'+', '-', '?'}. '?' denotes an unrecognized command. Lengths of two strings are equal and do not exceed 10.

Output a single real number corresponding to the probability. The answer will be considered correct if its relative or absolute error doesn't exceed 10<=-<=9.

[ "++-+-\n+-+-+\n", "+-+-\n+-??\n", "+++\n??-\n" ]

[ "1.000000000000\n", "0.500000000000\n", "0.000000000000\n" ]

For the first sample, both *s*1 and *s*2 will lead Dreamoon to finish at the same position + 1. For the second sample, *s*1 will lead Dreamoon to finish at position 0, while there are four possibilites for *s*2: {"+-++", "+-+-", "+--+", "+---"} with ending position {+2, 0, 0, -2} respectively. So there are 2 correct cases out of 4, so the probability of finishing at the correct position is 0.5. For the third sample, *s*2 could only lead us to finish at positions {+1, -1, -3}, so the probability to finish at the correct position + 3 is 0.

1,500

[ { "input": "++-+-\n+-+-+", "output": "1.000000000000" }, { "input": "+-+-\n+-??", "output": "0.500000000000" }, { "input": "+++\n??-", "output": "0.000000000000" }, { "input": "++++++++++\n+++??++?++", "output": "0.125000000000" }, { "input": "--+++---+-\n??????????", "output": "0.205078125000" }, { "input": "+--+++--+-\n??????????", "output": "0.246093750000" }, { "input": "+\n+", "output": "1.000000000000" }, { "input": "-\n?", "output": "0.500000000000" }, { "input": "+\n-", "output": "0.000000000000" }, { "input": "-\n-", "output": "1.000000000000" }, { "input": "-\n+", "output": "0.000000000000" }, { "input": "+\n?", "output": "0.500000000000" }, { "input": "++++++++++\n++++++++++", "output": "1.000000000000" }, { "input": "++++++++++\n++++-+++++", "output": "0.000000000000" }, { "input": "----------\n++++++++++", "output": "0.000000000000" }, { "input": "++++++++++\n++++??++++", "output": "0.250000000000" }, { "input": "----------\n+++?++++-+", "output": "0.000000000000" }, { "input": "++++++++++\n++++++++?+", "output": "0.500000000000" }, { "input": "--++++--+\n?-+?-??+-", "output": "0.250000000000" }, { "input": "----------\n??????????", "output": "0.000976562500" }, { "input": "+--++\n+--+-", "output": "0.000000000000" }, { "input": "-----++---\n????????+?", "output": "0.017578125000" }, { "input": "------+--+\n??????????", "output": "0.043945312500" }, { "input": "---++--\n???????", "output": "0.164062500000" }, { "input": "-----++\n???????", "output": "0.164062500000" }, { "input": "+---+--\n???????", "output": "0.164062500000" }, { "input": "---+-+\n??????", "output": "0.234375000000" }, { "input": "+++-+\n---++", "output": "0.000000000000" }, { "input": "++-+--+\n?-?+??+", "output": "0.375000000000" }, { "input": "----+++--\n-+?+++?--", "output": "0.000000000000" }, { "input": "+-----\n+?----", "output": "0.500000000000" } ]

1,698,717,071

2,147,483,647

Python 3

OK

TESTS

31

46

0

def go(i, pos): cnt = 0 if i == len(t): return int(pos == endpos) if t[i] == '+': cnt += go(i + 1, pos + 1) elif t[i] == '-': cnt += go(i + 1, pos - 1) else: cnt += go(i + 1, pos + 1) cnt += go(i + 1, pos - 1) return cnt s = input() t = input() endpos = 0 for i in range(len(s)): endpos += 1 if s[i] == '+' else -1 n = 0 for i in range(len(t)): if t[i] == '?': n += 1 result = go(0, 0) / (2 ** n) print(f"{result:.9f}")

Title: Dreamoon and WiFi Time Limit: None seconds Memory Limit: None megabytes Problem Description: Dreamoon is standing at the position 0 on a number line. Drazil is sending a list of commands through Wi-Fi to Dreamoon's smartphone and Dreamoon follows them. Each command is one of the following two types: 1. Go 1 unit towards the positive direction, denoted as '+' 1. Go 1 unit towards the negative direction, denoted as '-' But the Wi-Fi condition is so poor that Dreamoon's smartphone reports some of the commands can't be recognized and Dreamoon knows that some of them might even be wrong though successfully recognized. Dreamoon decides to follow every recognized command and toss a fair coin to decide those unrecognized ones (that means, he moves to the 1 unit to the negative or positive direction with the same probability 0.5). You are given an original list of commands sent by Drazil and list received by Dreamoon. What is the probability that Dreamoon ends in the position originally supposed to be final by Drazil's commands? Input Specification: The first line contains a string *s*1 — the commands Drazil sends to Dreamoon, this string consists of only the characters in the set {'+', '-'}. The second line contains a string *s*2 — the commands Dreamoon's smartphone recognizes, this string consists of only the characters in the set {'+', '-', '?'}. '?' denotes an unrecognized command. Lengths of two strings are equal and do not exceed 10. Output Specification: Output a single real number corresponding to the probability. The answer will be considered correct if its relative or absolute error doesn't exceed 10<=-<=9. Demo Input: ['++-+-\n+-+-+\n', '+-+-\n+-??\n', '+++\n??-\n'] Demo Output: ['1.000000000000\n', '0.500000000000\n', '0.000000000000\n'] Note: For the first sample, both *s*1 and *s*2 will lead Dreamoon to finish at the same position + 1. For the second sample, *s*1 will lead Dreamoon to finish at position 0, while there are four possibilites for *s*2: {"+-++", "+-+-", "+--+", "+---"} with ending position {+2, 0, 0, -2} respectively. So there are 2 correct cases out of 4, so the probability of finishing at the correct position is 0.5. For the third sample, *s*2 could only lead us to finish at positions {+1, -1, -3}, so the probability to finish at the correct position + 3 is 0.

```python def go(i, pos): cnt = 0 if i == len(t): return int(pos == endpos) if t[i] == '+': cnt += go(i + 1, pos + 1) elif t[i] == '-': cnt += go(i + 1, pos - 1) else: cnt += go(i + 1, pos + 1) cnt += go(i + 1, pos - 1) return cnt s = input() t = input() endpos = 0 for i in range(len(s)): endpos += 1 if s[i] == '+' else -1 n = 0 for i in range(len(t)): if t[i] == '?': n += 1 result = go(0, 0) / (2 ** n) print(f"{result:.9f}") ```

3