description stringlengths 171 4k | code stringlengths 94 3.98k | normalized_code stringlengths 57 4.99k |
|---|---|---|
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | def main():
n, k = map(int, input().split())
c = [int(input(), 2) for _ in range(n)]
num = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
num = [(int(s, 2), i) for i, s in enumerate(num)]
d = [[] for _ in range(128)]
for i in range(128):
for s, j in reversed(num):
if i & s == i:
x = bin(i ^ s).count("1")
d[i].append((x, str(j)))
dp = [([None] * (k + 1)) for _ in range(n + 1)]
dp[n][0] = ""
for i in range(n - 1, -1, -1):
t = dp[i + 1]
u = dp[i]
for j in range(k + 1):
for x, ch in d[c[i]]:
if j >= x and t[j - x] is not None:
u[j] = x, ch
break
if dp[0][k] is None:
print(-1)
return
x = k
ans = []
for i in range(n):
if dp[i][k] is not None:
ans.append(dp[i][k][1])
k -= dp[i][k][0]
print("".join(ans))
main() | FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR FUNC_CALL VAR VAR NUMBER VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR LIST VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR IF BIN_OP VAR VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR STRING EXPR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NONE BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER STRING FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR VAR VAR VAR VAR IF VAR VAR VAR BIN_OP VAR VAR NONE ASSIGN VAR VAR VAR VAR IF VAR NUMBER VAR NONE EXPR FUNC_CALL VAR NUMBER RETURN ASSIGN VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR NONE EXPR FUNC_CALL VAR VAR VAR VAR NUMBER VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL STRING VAR EXPR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | def popcount(x):
x -= x >> 1 & 85
x = (x & 51) + (x >> 2 & 51)
x = x + (x >> 4) & 15
return x & 15
D = [119, 18, 93, 91, 58, 107, 111, 82, 127, 123]
N, K = map(int, input().split())
X = [int(input(), 2) for _ in range(N)][::-1]
S = [1]
for i, x in enumerate(X):
pre = S[-1]
s = 0
for j, d in enumerate(D):
if d | x == d:
a = popcount(d) - popcount(x)
s |= pre << a
S.append(s)
if S[-1] >> K & 1 == 0:
print(-1)
exit()
ANS = []
for i in range(N, 0, -1):
x = X[i - 1]
for j in range(9, -1, -1):
d = D[j]
if d | x == d:
a = popcount(d) - popcount(x)
if K >= a and S[i - 1] >> K - a & 1:
ANS.append(j)
K -= a
break
print("".join(map(str, ANS))) | FUNC_DEF VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER RETURN BIN_OP VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR LIST NUMBER FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR IF BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR IF BIN_OP BIN_OP VAR NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR IF BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL VAR VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | digits_b = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
counts = [s.count("1") for s in digits_b]
digits_num = [int(s, 2) for s in digits_b]
nn, kk = map(int, input().split())
poss = [[] for i in range(nn)]
for i in range(nn):
s = input()
count = s.count("1")
num = int(s, 2)
for d in range(9, -1, -1):
if num & digits_num[d] == num:
poss[i].append((d, counts[d] - count))
dp = [[(0) for __ in range(kk + 1)] for _ in range(nn + 1)]
dp[0][0] = 1
for n in range(nn):
for k in range(kk + 1):
if not dp[n][k]:
continue
for _, c in poss[nn - n - 1]:
if c + k > kk:
continue
dp[n + 1][k + c] = 1
out = []
if dp[nn][kk]:
for n in range(nn):
for nx, c in poss[n]:
if c > kk or not dp[nn - 1 - n][kk - c]:
continue
kk -= c
out.append(nx)
break
print("".join(map(str, out)))
else:
print(-1) | ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR FUNC_CALL VAR STRING VAR VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF BIN_OP VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR FOR VAR VAR VAR BIN_OP BIN_OP VAR VAR NUMBER IF BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER ASSIGN VAR LIST IF VAR VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR VAR VAR VAR IF VAR VAR VAR BIN_OP BIN_OP VAR NUMBER VAR BIN_OP VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR NUMBER |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | def a2b(a, b):
if a & (a ^ b) != 0:
return -1
else:
return sum(d == "1" for d in bin(b & (a ^ b))[2:])
n, k = map(int, input().split())
arr = []
for _ in range(n):
arr.append(int(input(), 2))
num_txt = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
numbers = list(map(lambda x: int(x, 2), num_txt))
cost = [([0] * 10) for _ in range(n)]
for i in range(n):
for d in range(10):
cost[i][d] = a2b(arr[i], numbers[d])
dp = [([0] * (k + 1)) for _ in range(n + 1)]
dp[n][0] = 1
for i in range(n, 0, -1):
for j in range(k + 1):
if dp[i][j] == 1:
for d in range(10):
if cost[i - 1][d] != -1 and cost[i - 1][d] <= k - j:
dp[i - 1][j + cost[i - 1][d]] = 1
if dp[0][k] == 0:
print(-1)
else:
ans = ""
for i in range(n):
for d in range(9, -1, -1):
if 0 <= cost[i][d] <= k and dp[i + 1][k - cost[i][d]] == 1:
ans += str(d)
k -= cost[i][d]
break
print(ans) | FUNC_DEF IF BIN_OP VAR BIN_OP VAR VAR NUMBER RETURN NUMBER RETURN FUNC_CALL VAR VAR STRING VAR FUNC_CALL VAR BIN_OP VAR BIN_OP VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR STRING FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF NUMBER VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR NUMBER VAR FUNC_CALL VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | def calc(a1, a2):
if (a1 ^ a2) & a1 == 0:
d = a1 ^ a2
return sum([(d >> i & 1) for i in range(7)])
else:
return -1
D = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
n, k = list(map(int, input().split()))
x = [input() for _ in range(n)]
r = [([-1] * (k + 1)) for _ in range(n + 1)]
r[n][0] = 0
for i in range(n - 1, -1, -1):
for d in range(10):
dc = calc(int(x[i], 2), int(D[d], 2))
if dc != -1:
z = dc * 10 + d
for c in range(k + 1 - dc):
if r[i + 1][c] >= 0:
r[i][c + dc] = z
if r[0][k] >= 0:
for i in range(n):
print(r[i][k] % 10, end="")
k -= r[i][k] // 10
print()
else:
print(-1) | FUNC_DEF IF BIN_OP BIN_OP VAR VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR RETURN FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER VAR FUNC_CALL VAR NUMBER RETURN NUMBER ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR NUMBER FUNC_CALL VAR VAR VAR NUMBER IF VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER VAR IF VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR BIN_OP VAR VAR VAR IF VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR NUMBER STRING VAR BIN_OP VAR VAR VAR NUMBER EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR NUMBER |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | from sys import stdin, stdout
arr = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
d = {}
dr = {}
for i in range(len(arr)):
d[i] = int(arr[i], 2)
dr[int(arr[i], 2)] = i
trans = [[] for i in range(1 << 7)]
for i in range(1 << 7):
for j in range(9, -1, -1):
target = d[j]
if target | i == target:
trans[i].append(target)
trans[i].append(bin(target ^ i).count("1"))
n, k = stdin.readline().strip().split(" ")
n, k = int(n), int(k)
arr = []
for i in range(n):
arr.append(int(stdin.readline().strip(), 2))
arr = arr[::-1]
dp = [[None for i in range(2001)] for j in range(2001)]
dp[0][0] = 0, 0
for i in range(1, n + 1):
for j in range(k + 1):
curr_mask = arr[i - 1]
for k1 in range(0, len(trans[curr_mask]), 2):
new_mask = trans[curr_mask][k1]
cost = trans[curr_mask][k1 + 1]
if j - cost >= 0:
if dp[i - 1][j - cost] != None:
dp[i][j] = cost, dr[new_mask]
break
if dp[n][k] == None:
stdout.write("-1\n")
else:
ans = ""
while n != 0:
ans += str(dp[n][k][1])
k -= dp[n][k][0]
n -= 1
stdout.write(ans + "\n") | ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR DICT ASSIGN VAR DICT FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER VAR ASSIGN VAR LIST VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR IF BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR STRING ASSIGN VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NONE VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR BIN_OP VAR NUMBER IF BIN_OP VAR VAR NUMBER IF VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NONE ASSIGN VAR VAR VAR VAR VAR VAR IF VAR VAR VAR NONE EXPR FUNC_CALL VAR STRING ASSIGN VAR STRING WHILE VAR NUMBER VAR FUNC_CALL VAR VAR VAR VAR NUMBER VAR VAR VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR STRING |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
input = sys.stdin.readline
T = [119, 18, 93, 91, 58, 107, 111, 82, 127, 123]
N, K = map(int, input().split())
dp = [([0] * (K + 1)) for _ in range(N + 1)]
dp[N][0] = 1
X = []
for _ in range(N):
x = int(input().strip(), 2)
X.append(x)
for i in range(N - 1, -1, -1):
x = X[i]
for t in T:
rt = -1 if t | x != t else bin(t ^ x).count("1")
if rt < 0:
continue
for k in range(K, -1, -1):
if k - rt < 0:
continue
dp[i][k] = dp[i + 1][k - rt] | dp[i][k]
if dp[0][K] == 0:
print(-1)
sys.exit()
R = ""
for i in range(N):
x = X[i]
for j in range(9, -1, -1):
t = T[j]
rt = -1 if t | x != t else bin(t ^ x).count("1")
if rt < 0 or K - rt < 0:
continue
if dp[i + 1][K - rt]:
K -= rt
R += str(j)
break
print(R) | IMPORT ASSIGN VAR VAR ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR FOR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR NUMBER FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR STRING IF VAR NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF BIN_OP VAR VAR NUMBER ASSIGN VAR VAR VAR BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR VAR IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR STRING FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR NUMBER FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR STRING IF VAR NUMBER BIN_OP VAR VAR NUMBER IF VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | def inp():
x = int(input())
return x
def linp():
x = [int(i) for i in input().split()]
return x
nums = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
n, k = linp()
d = []
for i in range(n):
d.append(input())
dp = [([0] * (k + 1)) for i in range(n + 1)]
can = [([1] * 10) for i in range(n)]
for q in range(n):
for i in range(10):
j = 0
cnt = 0
while j < 7 and can[q][i] >= 0:
if d[q][j] == "1" and nums[i][j] == "0":
can[q][i] = -1
elif d[q][j] == "0" and nums[i][j] == "1":
cnt += 1
j += 1
if can[q][i] >= 0:
can[q][i] = cnt
dp[n][0] = 1
for i in range(n, 0, -1):
for j in range(k + 1):
if dp[i][j]:
for w in range(10):
if can[i - 1][w] != -1 and j + can[i - 1][w] <= k:
dp[i - 1][j + can[i - 1][w]] = 1
ans = ""
if dp[0][k] == 0:
ans = -1
else:
for i in range(n):
now = -1
for w in range(9, -1, -1):
if can[i][w] != -1 and k >= can[i][w] and dp[i + 1][k - can[i][w]]:
now = w
k -= can[i][w]
break
if now >= 0:
ans += str(now)
else:
ans = -1
break
print(ans) | FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR RETURN VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR NUMBER VAR VAR VAR NUMBER IF VAR VAR VAR STRING VAR VAR VAR STRING ASSIGN VAR VAR VAR NUMBER IF VAR VAR VAR STRING VAR VAR VAR STRING VAR NUMBER VAR NUMBER IF VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR STRING IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR NUMBER VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR IF VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | def D():
numdict = {
(0): "1110111",
(1): "0010010",
(2): "1011101",
(3): "1011011",
(4): "0111010",
(5): "1101011",
(6): "1101111",
(7): "1010010",
(8): "1111111",
(9): "1111011",
}
n, k = map(int, input().split())
sb = list()
for i in range(0, n):
sb.append(str(input()))
covb = list()
sdict = dict()
slis = [0] * (k + 1)
dp = [slis.copy() for i in range(0, n + 1)]
for i in sb:
stckarr = list()
for j in range(0, 10):
sticks = cov(i, numdict[j], sdict)
stckarr.append(sticks)
covb.append(stckarr)
dp[n][0] = 1
for i in range(n, 0, -1):
for j in range(0, k + 1):
if dp[i][j] == 1:
for d in range(0, 10):
if covb[i - 1][d] != -1 and j + covb[i - 1][d] <= k:
dp[i - 1][j + covb[i - 1][d]] = 1
if dp[0][k] == 0:
print(-1)
return
for i in range(0, n):
maxd = -1
for d in range(9, -1, -1):
if covb[i][d] != -1 and k >= covb[i][d] and dp[i + 1][k - covb[i][d]] == 1:
maxd = d
k = k - covb[i][d]
break
print(maxd, end="")
print()
def slvr(sb, covb, i, sticks, Ar, Cur):
if sticks == 0 and i == len(sb):
x = int(Cur)
Ar.append(x)
return
if i >= len(sb):
return
if sticks > 0 and i == len(sb):
return
if sticks < 0 and i < len(sb):
return
lenc = len(Cur)
for s in range(0, len(covb[i])):
if covb[i][s] != -1:
if covb[i][s] <= sticks:
Cur = Cur + str(s)
f = slvr(sb, covb, i + 1, sticks - covb[i][s], Ar, Cur)
Cur = Cur[:lenc]
return
def cov(str1, str2, sd):
stcks = 0
if (str1, str2) in sd:
return sd[str1, str2]
for i in range(0, 7):
if str1[i] == "1" and str2[i] == "0":
return -1
elif str1[i] == "0" and str2[i] == "1":
stcks += 1
sd[str1, str2] = stcks
return stcks
D() | FUNC_DEF ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER RETURN FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR NUMBER VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR NUMBER ASSIGN VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR STRING EXPR FUNC_CALL VAR FUNC_DEF IF VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR RETURN IF VAR FUNC_CALL VAR VAR RETURN IF VAR NUMBER VAR FUNC_CALL VAR VAR RETURN IF VAR NUMBER VAR FUNC_CALL VAR VAR RETURN ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR VAR IF VAR VAR VAR NUMBER IF VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN FUNC_DEF ASSIGN VAR NUMBER IF VAR VAR VAR RETURN VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER IF VAR VAR STRING VAR VAR STRING RETURN NUMBER IF VAR VAR STRING VAR VAR STRING VAR NUMBER ASSIGN VAR VAR VAR VAR RETURN VAR EXPR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
readline = sys.stdin.readline
inf = 10**18
digits = [119, 18, 93, 91, 58, 107, 111, 82, 127, 123]
popcount = [
[(bin(x - y).count("1") if x & y == x else inf) for y in range(2**7)]
for x in range(2**7)
]
N, K = map(int, input().split())
a = [int(readline().strip(), 2) for _ in range(N)]
dp = [([0] * (K + 1)) for _ in range(N + 1)]
dp[0][K] = 1
for i, x in zip(range(N), reversed(a)):
for j in range(K, -1, -1):
if not dp[i][j]:
continue
for y in digits:
if popcount[x][y] <= j:
dp[i + 1][j - popcount[x][y]] = 1
if not dp[N][0]:
print(-1)
exit()
j = 0
ans = []
for i, x in zip(range(N, 0, -1), a):
for k, y in zip(range(9, -1, -1), reversed(digits)):
if j + popcount[x][y] <= K and dp[i - 1][j + popcount[x][y]]:
ans.append(k)
j += popcount[x][y]
break
print(*ans, sep="") | IMPORT ASSIGN VAR VAR ASSIGN VAR BIN_OP NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR VAR FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR STRING VAR VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR VAR FOR VAR VAR IF VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR NUMBER IF VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR LIST FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER VAR FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER NUMBER NUMBER FUNC_CALL VAR VAR IF BIN_OP VAR VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR STRING |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
def f():
n, k = map(int, input().split())
ch = {
(0): "1110111",
(1): "0010010",
(2): "1011101",
(3): "1011011",
(4): "0111010",
(5): "1101011",
(6): "1101111",
(7): "1010010",
(8): "1111111",
(9): "1111011",
}
l = []
for _ in range(n):
l.append(sys.stdin.readline().rstrip())
def tr(s1, s2):
tot = 0
for i in range(7):
if s1[i] == "1" and s2[i] == "0":
return 10000000
elif s1[i] == "0" and s2[i] == "1":
tot += 1
return tot
trd = {}
acc = {}
for i in range(2**7):
s1 = bin(i)[2:].zfill(7)
trd[s1] = {}
acc[s1] = set()
for j in range(10):
s2 = ch[j]
cout = tr(s1, s2)
trd[s1][s2] = cout
if cout < 8:
acc[s1].add(cout)
poss = True
remp = [[(False) for i in range(k + 1)] for j in range(n)]
usable = [0]
for ind in range(n - 1, -1, -1):
new_usable = set()
for modif in usable:
for diff in acc[l[ind]]:
if diff + modif <= k:
remp[ind][modif + diff] = True
new_usable.add(modif + diff)
usable = new_usable
rep = []
for i in range(n):
found = False
for c in range(9, -1, -1):
cout = trd[l[i]][ch[c]]
if (
i < n - 1
and cout <= k
and remp[i + 1][k - cout]
or i == n - 1
and cout == k
):
rep.append(c)
k -= cout
found = True
break
if not found:
poss = False
break
if poss:
print(*rep, sep="")
else:
print(-1)
f() | IMPORT FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR STRING RETURN NUMBER IF VAR VAR STRING VAR VAR STRING VAR NUMBER RETURN VAR ASSIGN VAR DICT ASSIGN VAR DICT FOR VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR VAR DICT ASSIGN VAR VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR LIST NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR VAR FOR VAR VAR VAR VAR IF BIN_OP VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR ASSIGN VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR VAR VAR VAR IF VAR BIN_OP VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR BIN_OP VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR NUMBER IF VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR VAR STRING EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | from sys import stdin
nums = [119, 18, 93, 91, 58, 107, 111, 82, 127, 123]
def calc(a1, a2):
if (a1 ^ a2) & a1 == 0:
d = a1 ^ a2
return sum([(d >> i & 1) for i in range(7)])
else:
return -1
n, k = list(map(int, input().split()))
number = []
for _ in range(n):
number.append(int(input(), 2))
number.reverse()
dp = [([-1] * (k + 1)) for _ in range(n)]
dp_prev_index = [([-1] * (k + 1)) for _ in range(n)]
for i in range(n):
a = [-1] * 2001
for r in range(10):
c = calc(number[i], nums[r])
if c != -1:
a[c] = r
for j in range(min(k + 1, (i + 1) * 7 + 1)):
if i > 0:
for u in range(8):
if j - u < 0 or a[u] == -1 or dp[i - 1][j - u] == -1:
continue
if a[u] > dp[i][j]:
dp[i][j] = a[u]
dp_prev_index[i][j] = j - u
elif i == 0:
dp[i][j] = a[j]
if dp[n - 1][k] == -1:
print(-1)
else:
j = k
for i in range(n - 1, -1, -1):
print(dp[i][j], end="")
j = dp_prev_index[i][j]
print() | ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FUNC_DEF IF BIN_OP BIN_OP VAR VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR RETURN FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER VAR FUNC_CALL VAR NUMBER RETURN NUMBER ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR IF VAR NUMBER ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER IF VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR VAR NUMBER VAR VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER IF VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR BIN_OP VAR VAR IF VAR NUMBER ASSIGN VAR VAR VAR VAR VAR IF VAR BIN_OP VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR VAR VAR VAR STRING ASSIGN VAR VAR VAR VAR EXPR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | n, k = map(int, input().split())
ss = []
ks = []
kss = []
ka = 0
civ = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
civn = [6, 2, 5, 5, 4, 5, 6, 3, 7, 6]
it = ""
pref = []
for i in range(n):
s = input()
ss.append(s)
maa = 10
kk = []
kks = []
for j in range(10):
ma = 0
for jj in range(7):
if s[jj] == "1" and civ[j][jj] == "0":
ma = 10
elif s[jj] == "0" and civ[j][jj] == "1":
ma += 1
if ma < maa:
maa = ma
kk = [j]
elif ma == maa:
kk.append(j)
if ma < 10:
kks.append(j)
ka += maa
pref.append(ka)
ks.append(kk[:])
kss.append(kks[:])
if ka > k:
print(-1)
exit()
sum = 0
ssk = kss[:]
for i in range(n):
maxs = pref[-1] - pref[i]
y = max(kss[i])
while civn[y] - ss[i].count("1") + sum + maxs > k:
kss[i].pop(kss[i].index(y))
y = max(kss[i])
it += str(y)
sum += civn[y] - ss[i].count("1")
k -= sum
if k == 0:
print(it)
exit()
for i in range(n - 1, -1, -1):
x = int(it[i])
ma = civn[x]
mi = x
for j in range(len(kss[i])):
if civn[kss[i][j]] >= ma and k - (civn[kss[i][j]] - civn[x]) >= 0:
ma = civn[kss[i][j]]
mi = kss[i][j]
k += civn[x]
k -= civn[mi]
it = it[:i] + str(mi) + it[i + 1 :]
if k == 0:
break
if k != 0:
print(-1)
else:
print(it) | ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR LIST ASSIGN VAR LIST ASSIGN VAR NUMBER ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR STRING ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR VAR STRING ASSIGN VAR NUMBER IF VAR VAR STRING VAR VAR VAR STRING VAR NUMBER IF VAR VAR ASSIGN VAR VAR ASSIGN VAR LIST VAR IF VAR VAR EXPR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR IF VAR VAR EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR WHILE BIN_OP BIN_OP BIN_OP VAR VAR FUNC_CALL VAR VAR STRING VAR VAR VAR EXPR FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR VAR BIN_OP VAR VAR FUNC_CALL VAR VAR STRING VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR IF VAR VAR VAR VAR VAR BIN_OP VAR BIN_OP VAR VAR VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER IF VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | from sys import stdin, stdout
def find(arr, N, K):
nums = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
dist = [([-1] * 10) for _ in range(N)]
arr.reverse()
for i in range(N):
for j in range(10):
c = 0
for k in range(7):
if nums[j][k] == arr[i][k]:
continue
if nums[j][k] == "1" and arr[i][k] == "0":
c += 1
else:
c = -1
break
dist[i][j] = c
dp = [([0] * (K + 1)) for _ in range(N)]
for i in range(10):
if dist[0][i] != -1 and dist[0][i] <= K:
dp[0][dist[0][i]] = 1
for i in range(1, N):
for j in range(K + 1):
if dp[i - 1][j]:
for k in range(10):
if dist[i][k] != -1 and j + dist[i][k] <= K:
dp[i][j + dist[i][k]] = 1
r = []
j = K
if dp[-1][-1] == 0:
return -1
for i in range(N)[::-1]:
for k in range(10)[::-1]:
if dist[i][k] != -1 and j - dist[i][k] >= 0:
if i == 0 and dist[i][k] == j or i != 0 and dp[i - 1][j - dist[i][k]]:
r.append(k)
j -= dist[i][k]
break
return "".join(map(str, r))
def main():
N, K = list(map(int, stdin.readline().split()))
arr = []
for _ in range(N):
arr.append(stdin.readline().strip())
print(find(arr, N, K))
main() | FUNC_DEF ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR BIN_OP LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR VAR VAR VAR IF VAR VAR VAR STRING VAR VAR VAR STRING VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR NUMBER BIN_OP VAR VAR VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR VAR NUMBER ASSIGN VAR LIST ASSIGN VAR VAR IF VAR NUMBER NUMBER NUMBER RETURN NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER IF VAR VAR VAR NUMBER BIN_OP VAR VAR VAR VAR NUMBER IF VAR NUMBER VAR VAR VAR VAR VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR VAR RETURN FUNC_CALL STRING FUNC_CALL VAR VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
n, k = map(int, input().split())
digits = []
ex = [([0] * 10) for _ in range(n)]
a = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
a = list(map(lambda s: int(s, 2), a))
for i in range(n):
x = int(input(), 2)
for d in range(10):
ex[i][d] = bin(a[d] - x).count("1")
digits.append(x)
dp = [([False] * (k + 1)) for _ in range(n + 1)]
dp[n][0] = True
for i in range(n - 1, -1, -1):
for x in range(k + 1):
for d in range(10):
if a[d] & digits[i] != digits[i]:
continue
excess = ex[i][d]
if x - excess >= 0 and dp[i + 1][x - excess]:
dp[i][x] = True
break
ans = ""
cur = k
for i in range(n):
found = False
for d in range(9, -1, -1):
if a[d] & digits[i] != digits[i]:
continue
excess = ex[i][d]
if cur - excess >= 0 and dp[i + 1][cur - excess]:
cur -= excess
ans += str(d)
found = True
break
if not found:
print(-1)
exit()
print(ans) | IMPORT ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR BIN_OP LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR VAR STRING EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR IF BIN_OP VAR VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR VAR ASSIGN VAR VAR VAR NUMBER ASSIGN VAR STRING ASSIGN VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF BIN_OP VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR IF BIN_OP VAR VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | binrep = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
bintoint = {n: binrep[n] for n in range(10)}
allowed = {pos: set(n for n in range(10) if binrep[n][pos] == "1") for pos in range(7)}
size = {n: sum(1 for c in binrep[n] if c == "1") for n in range(10)}
def analyse(binstr):
possible = set(n for n in range(10))
for pos, c in enumerate(binstr):
if c == "1":
possible = possible.intersection(allowed[pos])
return sorted(list(possible), reverse=True)
def countlights(binstr):
total = 0
for c in binstr:
total += int(c)
return total
def solvenumber(sparemoves, N, pos=0, number=""):
if pos == N:
if sparemoves == 0:
return number
else:
return -1
possibilities = possibilityarray[pos]
missing = missingarray[pos]
posminmoves = min(missing)
extramoves = [(moves - posminmoves) for moves in missing]
for index, digit in enumerate(possibilities):
cost = extramoves[index]
if cost <= sparemoves:
result = solvenumber(sparemoves - cost, N, pos + 1, number + str(digit))
if result != -1:
return result
return -1
N, K = list(map(int, input().split()))
lightsonarray = [input() for n in range(N)]
possibilityarray = [analyse(string) for string in lightsonarray]
missingarray = [
[(size[num] - countlights(string)) for num in possibilityarray[index]]
for index, string in enumerate(lightsonarray)
]
minmoves = sum(min(movesreq) for movesreq in missingarray)
maxmoves = sum(max(movesreq) for movesreq in missingarray)
if K < minmoves or K > maxmoves:
print("-1")
else:
sparemoves = K - minmoves
number = solvenumber(sparemoves, N)
print(number) | ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR VAR VAR VAR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR NUMBER VAR VAR VAR STRING VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR NUMBER VAR VAR VAR VAR STRING VAR FUNC_CALL VAR NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR IF VAR STRING ASSIGN VAR FUNC_CALL VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FUNC_DEF ASSIGN VAR NUMBER FOR VAR VAR VAR FUNC_CALL VAR VAR RETURN VAR FUNC_DEF NUMBER STRING IF VAR VAR IF VAR NUMBER RETURN VAR RETURN NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR FUNC_CALL VAR VAR IF VAR NUMBER RETURN VAR RETURN NUMBER ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR IF VAR VAR VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | from sys import stdin, stdout
class Param:
inf = int(10000000000.0)
code = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
n, k = list(map(int, stdin.readline().split()))
s_list = []
for i in range(n):
s_list.append(stdin.readline())
pass
bit_list = [int(s, 2) for s in s_list]
move_rec = [([0] * 10) for i in range(1 << 7)]
def move(bit, value):
x = code[value]
ans = 0
for i in range(7):
if x[i] == "1" and not bit & 1 << 6 - i:
ans += 1
elif x[i] == "1" and bit & 1 << 6 - i:
pass
elif x[i] == "0" and not bit & 1 << 6 - i:
pass
elif x[i] == "0" and bit & 1 << 6 - i:
ans = Param.inf
break
pass
move_rec[bit][value] = ans
for bit in bit_list:
for value in range(10):
move(bit, value)
dp = [([False] * (k + 1)) for i in range(n + 1)]
dp[0][0] = True
for pos in range(n):
for i in range(k + 1):
if dp[pos][i]:
for value in range(10):
need = move_rec[bit_list[-(pos + 1)]][value]
if need + i <= k:
dp[pos + 1][need + i] = True
pass
pass
pass
ans = ""
if dp[n][k] == False:
ans = "-1"
else:
rest = k
for pos in reversed(range(1, n + 1)):
for value in reversed(range(0, 10)):
need = move_rec[bit_list[-pos]][value]
if rest - need >= 0 and dp[pos - 1][rest - need]:
ans += str(value)
rest = rest - need
break
pass
pass
pass
print(ans) | CLASS_DEF ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER VAR VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER FUNC_DEF ASSIGN VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING BIN_OP VAR BIN_OP NUMBER BIN_OP NUMBER VAR VAR NUMBER IF VAR VAR STRING BIN_OP VAR BIN_OP NUMBER BIN_OP NUMBER VAR IF VAR VAR STRING BIN_OP VAR BIN_OP NUMBER BIN_OP NUMBER VAR IF VAR VAR STRING BIN_OP VAR BIN_OP NUMBER BIN_OP NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR BIN_OP VAR NUMBER VAR IF BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER ASSIGN VAR STRING IF VAR VAR VAR NUMBER ASSIGN VAR STRING ASSIGN VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR VAR VAR VAR VAR IF BIN_OP VAR VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | n, k = map(int, input().split())
bins = [input() for _ in range(n)]
digits = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
memo = [[(-1) for _ in range(k + 1)] for _ in range(n + 1)]
memo[n][0] = 0
def foo(u, p):
d = 0
for cu, cp in zip(u, p):
if cu > cp:
return -1
d += cu != cp
return d
for i in range(n - 1, -1, -1):
for m, s in enumerate(digits):
d = foo(bins[i], s)
if d == -1:
continue
for j in range(k + 1 - d):
recu = memo[i + 1][j]
if recu == -1:
continue
memo[i][j + d] = 10 * d + m
if memo[0][k] >= 0:
for i in range(n):
print(memo[i][k] % 10, end="")
k -= memo[i][k] // 10
print()
else:
print(-1) | ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FUNC_DEF ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR IF VAR VAR RETURN NUMBER VAR VAR VAR RETURN VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER VAR ASSIGN VAR VAR BIN_OP VAR NUMBER VAR IF VAR NUMBER ASSIGN VAR VAR BIN_OP VAR VAR BIN_OP BIN_OP NUMBER VAR VAR IF VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR NUMBER STRING VAR BIN_OP VAR VAR VAR NUMBER EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR NUMBER |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
sys.setrecursionlimit(10**5)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II():
return int(sys.stdin.readline())
def MI():
return map(int, sys.stdin.readline().split())
def LI():
return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number):
return [LI() for _ in range(rows_number)]
def SI():
return sys.stdin.readline()[:-1]
def main():
seg = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
seg = [int(s, 2) for s in seg]
n, k = MI()
ss = [SI() for _ in range(n)]
dp = [1] * (n + 1)
mask = (1 << k + 1) - 1
for i in range(n - 1, -1, -1):
a = int(ss[i], 2)
pre = dp[i + 1]
value = 0
for d, b in enumerate(seg):
if a & b != a:
continue
delta = bin(b ^ a).count("1")
value |= pre << delta
dp[i] = value & mask
if dp[0] >> k & 1 == 0:
print(-1)
exit()
ans = []
for i in range(n):
a = int(ss[i], 2)
for d in range(9, -1, -1):
b = seg[d]
if a & b != a:
continue
delta = bin(b ^ a).count("1")
if delta > k:
continue
if dp[i + 1] >> k - delta & 1:
ans.append(d)
k -= delta
break
print(*ans, sep="")
main() | IMPORT EXPR FUNC_CALL VAR BIN_OP NUMBER NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR STRING FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_DEF RETURN FUNC_CALL VAR NUMBER FUNC_DEF ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR FUNC_CALL VAR VAR NUMBER VAR VAR ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR IF BIN_OP VAR VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR STRING VAR BIN_OP VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR IF BIN_OP BIN_OP VAR NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR IF BIN_OP VAR VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR STRING IF VAR VAR IF BIN_OP BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR STRING EXPR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | from sys import stdin, stdout
digits = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
counts = [s.count("1") for s in digits]
bits = [int(s, 2) for s in digits]
n, k = list(map(int, stdin.readline().split()))
poss = [[] for i in range(n)]
for i in range(n):
s = stdin.readline()
count = s.count("1")
bit = int(s, 2)
for d in range(9, -1, -1):
if bit & bits[d] == bit:
poss[i].append((d, counts[d] - count))
dp = [([False] * (k + 1)) for i in range(n + 1)]
dp[0][0] = True
for i in range(n):
allowed = poss[n - i - 1]
for j in range(k + 1):
if dp[i][j]:
for _, c in allowed:
if j + c <= k:
dp[i + 1][j + c] = True
out = ""
if dp[n][k]:
curr = k
for i in range(n):
for v, c in poss[i]:
if curr - c >= 0 and dp[n - i - 1][curr - c]:
out += str(v)
curr -= c
break
assert dp[n - i - 1][curr]
print(out)
else:
print(-1) | ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR FUNC_CALL VAR STRING VAR VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF BIN_OP VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR BIN_OP BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR FOR VAR VAR VAR IF BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER ASSIGN VAR STRING IF VAR VAR VAR ASSIGN VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR VAR VAR VAR IF BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER BIN_OP VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR BIN_OP BIN_OP VAR VAR NUMBER VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR NUMBER |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | maxk = 2005
def xcost(s, d):
price = 0
for i in range(7):
if s[i] == "1" and d[i] == "0":
price = maxk
break
elif s[i] == "0" and d[i] == "1":
price += 1
return price
s = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
p = []
cost = [[(0) for j in range(10)] for i in range(128)]
for i in range(128):
x = bin(i)[2:].zfill(7)
p.append(x)
for i in range(128):
for j in range(10):
v = xcost(p[i], s[j])
cost[i][j] = v
n, k = map(int, input().split(" "))
scoreboard = []
for i in range(n):
x = int(str(input()), 2)
scoreboard.append(x)
dp = [[(False) for i in range(k + 1)] for j in range(n)]
i = n - 1
bit_int = scoreboard[i]
for j in cost[bit_int]:
if j <= k:
dp[i][j] = True
for i in range(n - 2, -1, -1):
bit_int = scoreboard[i]
for j in range(k + 1):
for x in cost[bit_int]:
if j >= x:
if dp[i + 1][j - x]:
dp[i][j] = True
break
if dp[0][k]:
ans, spend, pos = "", k, 0
for i in scoreboard:
for j in range(9, -1, -1):
v = cost[i][j]
if pos == n - 1 and spend == v:
ans += str(j)
break
elif pos < n - 1 and spend >= v:
if dp[pos + 1][spend - v]:
ans += str(j)
spend -= v
break
pos += 1
print(ans)
else:
print(-1) | ASSIGN VAR NUMBER FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR STRING ASSIGN VAR VAR IF VAR VAR STRING VAR VAR STRING VAR NUMBER RETURN VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR LIST ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR FOR VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR VAR VAR IF VAR VAR IF VAR BIN_OP VAR NUMBER BIN_OP VAR VAR ASSIGN VAR VAR VAR NUMBER IF VAR NUMBER VAR ASSIGN VAR VAR VAR STRING VAR NUMBER FOR VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR VAR IF VAR BIN_OP VAR NUMBER VAR VAR VAR FUNC_CALL VAR VAR IF VAR BIN_OP VAR NUMBER VAR VAR IF VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR NUMBER |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
input = sys.stdin.readline
def main():
N, K = [int(x) for x in input().split()]
S = [int(input().strip(), 2) for _ in range(N)]
A = [119, 18, 93, 91, 58, 107, 111, 82, 127, 123]
B = [([-1] * 10) for j in range(N)]
for i, s in enumerate(S):
for j in range(10):
if A[j] & s == s:
B[i][j] = bin(A[j] ^ s).count("1")
dp = [([0] * (K + 1)) for _ in range(N + 2)]
dp[N + 1][0] = 1
for i in range(N, -1, -1):
for j in range(K + 1):
if dp[i + 1][j] == 0:
continue
for k in range(10):
if B[i - 1][k] == -1 or j + B[i - 1][k] > K:
continue
dp[i][j + B[i - 1][k]] = 1
if dp[1][K] == 0:
print(-1)
return
ans = []
c = K
for i in range(1, N + 1):
for k in range(9, -1, -1):
if (
B[i - 1][k] != -1
and c - B[i - 1][k] >= 0
and dp[i + 1][c - B[i - 1][k]] != 0
):
c -= B[i - 1][k]
ans.append(str(k))
break
print("".join(ans))
main() | IMPORT ASSIGN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR VAR VAR VAR ASSIGN VAR VAR VAR FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR VAR STRING ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR BIN_OP VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER RETURN ASSIGN VAR LIST ASSIGN VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR NUMBER VAR VAR BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING VAR EXPR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | n, k = map(int, input().split())
str1 = []
for i in range(n):
str1.append(input())
digit = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
poss = [[(0) for d in range(10)] for i in range(n)]
for i in range(n):
for d in range(10):
temp = str1[i]
stat = 0
for j in range(7):
if temp[j] == "1" and digit[d][j] == "0":
stat = -1
break
elif temp[j] == "0" and digit[d][j] == "1":
stat += 1
poss[i][d] = stat
make = [[(False) for i in range(k + 1)] for j in range(n + 1)]
make[n][0] = True
for i in range(n, 0, -1):
for j in range(k + 1):
if make[i][j] == True:
for d in range(10):
if poss[i - 1][d] != -1 and j + poss[i - 1][d] <= k:
make[i - 1][j + poss[i - 1][d]] = True
if make[0][k] != True:
print(-1)
else:
fin = ""
for i in range(n):
for j in range(9, -1, -1):
if poss[i][j] != -1 and poss[i][j] <= k and make[i + 1][k - poss[i][j]]:
fin += str(j)
k -= poss[i][j]
break
print(fin) | ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR VAR STRING ASSIGN VAR NUMBER IF VAR VAR STRING VAR VAR VAR STRING VAR NUMBER ASSIGN VAR VAR VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR STRING FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR NUMBER VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | from sys import stdin, stdout
codes = dict()
def create_codes():
digits = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
global codes
for i in range(128):
c = "{:07b}".format(i)
cnt_dict = dict()
for k, x in enumerate(digits):
cnt = 0
for j in range(7):
if c[j] > x[j]:
j -= 1
break
elif c[j] < x[j]:
cnt += 1
if j == 6:
cnt_dict[k] = cnt
codes[c] = cnt_dict
def main():
n, k = list(map(int, stdin.readline().split()))
global codes
create_codes()
inp = []
for _ in range(n):
code = stdin.readline().rstrip()
inp.append(code)
dp = [([False] * (k + 1)) for _ in range(n + 1)]
dp[n][0] = True
for i in range(n, 0, -1):
code = inp[i - 1]
for j in range(k + 1):
if not dp[i][j]:
continue
for key, val in codes[code].items():
if val + j > k:
continue
dp[i - 1][val + j] = True
if not dp[0][k]:
stdout.write("-1")
return
for i in range(n):
code = inp[i]
for d in range(9, -1, -1):
if (
d in codes[code]
and k - codes[code][d] >= 0
and dp[i + 1][k - codes[code][d]]
):
k -= codes[code][d]
stdout.write(str(d))
break
main() | ASSIGN VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL STRING VAR ASSIGN VAR FUNC_CALL VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR VAR VAR NUMBER IF VAR VAR VAR VAR VAR NUMBER IF VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR FOR VAR VAR FUNC_CALL VAR VAR IF BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER IF VAR NUMBER VAR EXPR FUNC_CALL VAR STRING RETURN FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR BIN_OP VAR VAR VAR VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
from itertools import accumulate
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [([c] * b) for i in range(a)]
def list3d(a, b, c, d):
return [[([d] * c) for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[([e] * d) for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(input())
def MAP():
return map(int, input().split())
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
INF = 10**18
MOD = 10**9 + 7
def popcount(i):
i = i - (i >> 1 & 1431655765)
i = (i & 858993459) + (i >> 2 & 858993459)
i = i + (i >> 4) & 252645135
i = i + (i >> 8)
i = i + (i >> 16)
return i & 63
B = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
for i in range(10):
B[i] = int(B[i], 2)
N, K = MAP()
A = [int(input(), 2) for i in range(N)][::-1]
dp = list2d(N + 1, K + 1, 0)
dp[0][0] = 1
for i, a in enumerate(A):
for j in range(K + 1):
if not dp[i][j]:
continue
for x, b in enumerate(B):
ab = a & b
cnt = popcount(b ^ ab)
ng = 1 if a ^ ab > 0 else 0
if not ng and j + cnt <= K:
dp[i + 1][j + cnt] |= 1 << x
if not dp[N][K]:
print(-1)
exit()
cnt = K
ans = []
for i in range(N, 0, -1):
for j in range(9, -1, -1):
if dp[i][cnt] >> j & 1:
num = j
break
ans.append(str(num))
need = popcount(B[num]) - popcount(A[i - 1])
cnt -= need
print("".join(ans)) | IMPORT FUNC_DEF RETURN FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN BIN_OP LIST VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF RETURN BIN_OP LIST VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF RETURN BIN_OP LIST VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF NUMBER RETURN FUNC_CALL VAR BIN_OP VAR VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF NONE RETURN VAR NONE FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_DEF EXPR FUNC_CALL VAR STRING FUNC_DEF EXPR FUNC_CALL VAR STRING FUNC_DEF EXPR FUNC_CALL VAR STRING FUNC_DEF EXPR FUNC_CALL VAR STRING ASSIGN VAR BIN_OP NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_DEF ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER RETURN BIN_OP VAR NUMBER ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER FOR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR NUMBER NUMBER NUMBER IF VAR BIN_OP VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP NUMBER VAR IF VAR VAR VAR EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF BIN_OP BIN_OP VAR VAR VAR VAR NUMBER ASSIGN VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | from sys import stderr, stdin
def rl():
return [int(w) for w in stdin.readline().split()]
D = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
n, k = rl()
x = [stdin.readline().rstrip() for _ in range(n)]
r = [([-1] * (k + 1)) for _ in range(n + 1)]
r[n][0] = 0
for i in range(n - 1, -1, -1):
for d in range(10):
dc = 0
for f, t in zip(x[i], D[d]):
if f > t:
break
else:
dc += f != t
else:
z = dc * 10 + d
for c in range(k + 1 - dc):
if r[i + 1][c] >= 0:
r[i][c + dc] = z
if r[0][k] >= 0:
for i in range(n):
print(r[i][k] % 10, end="")
k -= r[i][k] // 10
print()
else:
print(-1) | FUNC_DEF RETURN FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR IF VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER VAR IF VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR BIN_OP VAR VAR VAR IF VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR NUMBER STRING VAR BIN_OP VAR VAR VAR NUMBER EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR NUMBER |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | def comp(a, b):
b = d[b]
count = 0
for i in range(7):
if a[i] == "1" and b[i] == "0":
return -1
elif a[i] == "0" and b[i] == "1":
count += 1
return count
n, count = map(int, input().split())
l = []
d = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
num = set(d)
for i in range(n):
l.append(input())
dp = [[(-1) for i in range(9)] for j in range(n)]
for i in range(n):
for j in range(1, 8):
for k in range(10):
if comp(l[i], k) == j:
dp[i][j] = k
for i in range(n):
if l[i] in num:
dp[i][0] = d.index(l[i])
minn = 0
number = [-1] * n
value = [0] * n
for i in range(n):
for j in range(8):
if dp[i][j] != -1:
minn += j
value[i] = j
number[i] = dp[i][j]
break
if count < minn:
print(-1)
exit(0)
count -= minn
if count != 0:
for i in range(n):
m = max(dp[i][value[i] : min(8, value[i] + count + 1)])
ind = dp[i].index(m)
number[i] = m
count -= ind - value[i]
value[i] = ind
number1 = []
number2 = []
value1 = []
value2 = []
count1, count2 = count, count
for i in range(n):
number2.append(number[i])
number1.append(number[i])
value1.append(value[i])
value2.append(value[i])
if count1 != 0:
for i in range(n - 1, -1, -1):
for j in range(7, value1[i], -1):
if count1 >= j - value1[i] and dp[i][j] != -1:
number1[i] = dp[i][j]
value1[i] = j
count1 -= 1
break
if count1 == 0:
break
if count2 != 0:
if count2 == 1:
for i in range(n - 1, -1, -1):
if count2 == 1:
for j in range(value2[i] + 2, 8):
if dp[i][j] != -1:
number2[i] = dp[i][j]
value2[i] = j
count2 -= 2
break
elif dp[i][value2[i] - 1] != -1:
number2[i] = dp[i][value2[i] - 1]
value2[i] -= 1
count2 += 1
break
if count1 != 0 and count2 != 0:
print(-1)
exit()
elif count1 != 0 or count2 != 0:
if count1 == 0:
print("".join(map(str, number1)))
else:
print("".join(map(str, number2)))
else:
ans1 = "".join(map(str, number1))
ans2 = "".join(map(str, number2))
if ans1 > ans2:
print(ans1)
else:
print(ans2) | FUNC_DEF ASSIGN VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR STRING RETURN NUMBER IF VAR VAR STRING VAR VAR STRING VAR NUMBER RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER IF FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR ASSIGN VAR VAR NUMBER FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR NUMBER VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER VAR VAR IF VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR LIST ASSIGN VAR LIST ASSIGN VAR LIST ASSIGN VAR LIST ASSIGN VAR VAR VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR IF VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR VAR NUMBER IF VAR BIN_OP VAR VAR VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR NUMBER IF VAR NUMBER IF VAR NUMBER IF VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER NUMBER IF VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR NUMBER IF VAR VAR BIN_OP VAR VAR NUMBER NUMBER ASSIGN VAR VAR VAR VAR BIN_OP VAR VAR NUMBER VAR VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR IF VAR NUMBER VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL STRING FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL STRING FUNC_CALL VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))
dig = [119, 18, 93, 91, 58, 107, 111, 82, 127, 123]
pct = [0] * (1 << 7)
for bit in range(1 << 7):
for j in range(7):
if not bit & 1 << j:
pct[bit | 1 << j] = pct[bit] + 1
def solve():
n, k = nm()
s = [int(input(), 2) for _ in range(n)]
dp = [([False] * (k + 20)) for _ in range(n + 1)]
dp[n][k] = True
for i in range(n - 1, -1, -1):
for j in range(k, -1, -1):
if dp[i + 1][j]:
for d in range(10):
if s[i] & dig[d] == s[i]:
dp[i][j - pct[s[i] ^ dig[d]]] = True
if not dp[0][0]:
return -1
cur = ""
ck = 0
for i in range(n):
for d in range(9, -1, -1):
if s[i] & dig[d] == s[i] and dp[i + 1][ck + pct[s[i] ^ dig[d]]]:
ck += pct[s[i] ^ dig[d]]
cur += str(d)
break
return cur
print(solve()) | IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR BIN_OP NUMBER VAR ASSIGN VAR BIN_OP VAR BIN_OP NUMBER VAR BIN_OP VAR VAR NUMBER FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR BIN_OP VAR VAR VAR VAR NUMBER IF VAR NUMBER NUMBER RETURN NUMBER ASSIGN VAR STRING ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF BIN_OP VAR VAR VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR VAR VAR VAR VAR VAR BIN_OP VAR VAR VAR VAR VAR FUNC_CALL VAR VAR RETURN VAR EXPR FUNC_CALL VAR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
input = sys.stdin.readline
inf = 10000000
mod = 998244353
STR = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
N, M = map(int, input().split())
A = [input().strip() for i in range(N)]
NUM = [([0] * 10) for i in range(N + 1)]
F = [([False] * (M + 1)) for i in range(N + 1)]
F[N][M] = True
for i in range(N):
for j in range(10):
for k in range(7):
if A[i][k] != STR[j][k]:
if A[i][k] == "1":
NUM[i][j] = inf
break
else:
NUM[i][j] += 1
for i in range(N - 1, -1, -1):
for j in range(M + 1):
for k in range(10):
delta = NUM[i][k]
if j + delta > M:
continue
if F[i + 1][delta + j] == True:
F[i][j] = True
if F[0][0] == False:
print("-1")
sys.exit()
pos = 0
ANS = []
for i in range(N):
for j in range(9, -1, -1):
if pos + NUM[i][j] <= M and F[i + 1][pos + NUM[i][j]] == True:
pos = pos + NUM[i][j]
ANS.append(j)
break
for ans in ANS:
print(ans, end="") | IMPORT ASSIGN VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR VAR VAR VAR IF VAR VAR VAR STRING ASSIGN VAR VAR VAR VAR VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR VAR IF BIN_OP VAR VAR VAR IF VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER ASSIGN VAR VAR VAR NUMBER IF VAR NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF BIN_OP VAR VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR STRING |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
def to_dec(s):
x = 0
for j in range(7):
if int(s[j]):
x |= 1 << j
return x
def tic_count(x):
c = 0
while x > 0:
if x % 2 == 1:
c += 1
x //= 2
return c
t = 1
for _ in range(t):
n, k = map(int, input().split())
digs = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
digs = list(map(to_dec, digs))
tics = [tic_count(x) for x in digs]
d = [[(False) for j in range(k + 1)] for i in range(n + 1)]
a = [0] * n
t = [0] * n
for i in range(n):
a[i] = to_dec(input())
t[i] = tic_count(a[i])
d[n][k] = True
for i in range(n - 1, -1, -1):
cur = a[i]
for x in range(10):
for left in range(k + 1):
if digs[x] & cur == cur:
need = tics[x] - t[i]
if left - need >= 0 and d[i + 1][left] == True:
d[i][left - need] = True
left = 0
res = []
for i in range(n):
for x in range(9, -1, -1):
if digs[x] & a[i] == a[i]:
need = tics[x] - t[i]
if left + need <= k and d[i + 1][left + need]:
res.append(str(x))
left += need
break
if len(res) != n:
print(-1)
else:
print("".join(res)) | IMPORT FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF FUNC_CALL VAR VAR VAR VAR BIN_OP NUMBER VAR RETURN VAR FUNC_DEF ASSIGN VAR NUMBER WHILE VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR NUMBER VAR NUMBER RETURN VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF BIN_OP VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR IF BIN_OP VAR VAR NUMBER VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR BIN_OP VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF BIN_OP VAR VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR IF BIN_OP VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL STRING VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | printn = lambda x: print(x, end="")
inn = lambda: int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda: input().strip()
DBG = True
BIG = 10**18
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
digs = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
def chg(pat, c):
dig = digs[c]
cnt = 0
for i in range(7):
if pat[i] == "0" and dig[i] == "1":
cnt += 1
if pat[i] == "1" and dig[i] == "0":
return 9
return cnt
n, k = inm()
pats = []
chgh = {}
for i in range(n):
p = ins()
a = []
for m in range(10):
a.append(chg(p, m))
chgh[p] = a
pats.append(p)
d = [([0] * (k + 1)) for i in range(n + 1)]
d[n][0] = 1
for i in range(n - 1, -1, -1):
p = pats[i]
for j in range(k + 1):
if d[i + 1][j] == 0:
continue
for m in range(10):
v = chgh[p][m]
if v < 9 and j + v <= k:
d[i][j + v] = 1
if d[0][k] == 0:
print(-1)
exit()
ans = []
x = k
for i in range(n):
p = pats[i]
for m in range(9, -1, -1):
v = chgh[p][m]
if v < 9 and x - v >= 0 and d[i + 1][x - v] == 1:
ans.append(str(m))
x -= v
break
print("".join(ans)) | ASSIGN VAR FUNC_CALL VAR VAR STRING ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_DEF IF VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING FUNC_DEF ASSIGN VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR STRING VAR NUMBER IF VAR VAR STRING VAR VAR STRING RETURN NUMBER RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR DICT FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR VAR IF VAR NUMBER BIN_OP VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR VAR IF VAR NUMBER BIN_OP VAR VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | from sys import gettrace, stdin
if not gettrace():
def input():
return next(stdin)[:-1]
NUMS = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
def main():
n, k = map(int, input().split())
digits = []
counts = []
for _ in range(n):
digit = input()
digits.append(digit)
counts.append([])
for num in NUMS:
count = 0
for j in range(7):
if num[j] == "0" and digit[j] == "1":
count = k + 1
break
if num[j] == "1" and digit[j] == "0":
count += 1
counts[-1].append(count)
prems = [set() for _ in range(n)] + [{0}]
for i in range(n - 1, -1, -1):
for c in counts[i]:
for r in prems[i + 1]:
if c + r <= k:
prems[i].add(c + r)
res = []
if k not in prems[0]:
print(-1)
return
for i in range(n):
for j in range(9, -1, -1):
if k - counts[i][j] in prems[i + 1]:
res.append(j)
k -= counts[i][j]
break
print("".join(map(str, res)))
main() | IF FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR VAR NUMBER ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR LIST FOR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR STRING ASSIGN VAR BIN_OP VAR NUMBER IF VAR VAR STRING VAR VAR STRING VAR NUMBER EXPR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR LIST NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR VAR VAR FOR VAR VAR BIN_OP VAR NUMBER IF BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR LIST IF VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER RETURN FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF BIN_OP VAR VAR VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | numbers = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
n, m = list(map(int, input().split()))
changes = [([0] * 10) for i in range(n)]
for i in range(n):
s = input()
for j in range(10):
count = 0
for k in range(7):
if numbers[j][k] == "1" and s[k] == "0":
count += 1
elif numbers[j][k] == "0" and s[k] == "1":
count = -1
break
changes[i][j] = count
dp = [([0] * (m + 1)) for i in range(n + 1)]
dp[n][0] = 1
for i in range(n, 0, -1):
for j in range(m + 1):
if dp[i][j]:
for k in range(10):
if changes[i - 1][k] != -1 and changes[i - 1][k] + j <= m:
dp[i - 1][j + changes[i - 1][k]] = 1
if dp[0][m] == 0:
print(-1)
else:
for i in range(n):
num = 0
for j in range(9, -1, -1):
if (
changes[i][j] != -1
and m >= changes[i][j]
and dp[i + 1][m - changes[i][j]]
):
num = j
m -= changes[i][j]
break
print(num, end="") | ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR STRING VAR VAR STRING VAR NUMBER IF VAR VAR VAR STRING VAR VAR STRING ASSIGN VAR NUMBER ASSIGN VAR VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR NUMBER VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR STRING |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
input = sys.stdin.readline
def prog():
digits = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
n, k = map(int, input().split())
dp = [[(False) for i in range(k + 1)] for i in range(n + 1)]
dp[0][0] = True
changes = [[None for i in range(10)] for i in range(n + 1)]
nums = [input().strip() for i in range(n)]
nums.reverse()
for i in range(n):
num = nums[i]
for digit1 in range(10):
digit = digits[digit1]
change = 0
fail = False
for j in range(7):
if num[j] == "1" and digit[j] == "0":
fail = True
break
elif num[j] == "0" and digit[j] == "1":
change += 1
if not fail:
changes[i + 1][digit1] = change
for a in range(k + 1):
if dp[i][a] == True and a + change <= k:
dp[i + 1][a + change] = True
if dp[n][k] == False:
print(-1)
else:
ans = []
for i in range(n, 0, -1):
for j in range(9, -1, -1):
val = changes[i][j]
if val is not None and k - val >= 0 and dp[i - 1][k - val] == True:
ans.append(str(j))
k -= val
break
print("".join(ans))
prog() | IMPORT ASSIGN VAR VAR FUNC_DEF ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER NUMBER ASSIGN VAR NONE VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR STRING ASSIGN VAR NUMBER IF VAR VAR STRING VAR VAR STRING VAR NUMBER IF VAR ASSIGN VAR BIN_OP VAR NUMBER VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR NUMBER BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER IF VAR VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR VAR IF VAR NONE BIN_OP VAR VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING VAR EXPR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
lines = sys.stdin.readlines()
n, k = map(int, lines[0].strip().split(" "))
strings = []
for i in range(1, n + 1):
strings.append(lines[i].strip())
encoding = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
cnt = []
for i in range(10):
cnt.append(encoding[i].count("1"))
S = set(strings)
def xor(a, b):
val = 0
for i in range(7):
if a[i] == "1":
if b[i] == "0":
val += 1
elif b[i] == "1":
return -1
return val
cache = {}
for s in S:
arr = []
seen = set()
for i in range(9, -1, -1):
tmp = xor(encoding[i], s)
if tmp != -1 and tmp not in seen:
arr.append((str(i), tmp))
seen.add(tmp)
cache[s] = arr
dp = [[(0) for _ in range(k + 1)] for _ in range(n)]
for node in cache[strings[-1]]:
if node[1] <= k:
dp[-1][node[1]] = node[0]
for i in range(n - 2, -1, -1):
for val in cache[strings[i]]:
for j in range(val[1], k + 1):
if dp[i][j] != 0:
continue
if dp[i + 1][j - val[1]] != 0:
dp[i][j] = val[0]
if dp[0][-1] == 0:
print(-1)
else:
res = ""
cK = k
for i in range(n):
tmp = dp[i][cK]
res += tmp
val = xor(encoding[int(tmp)], strings[i])
cK -= val
print(res) | IMPORT ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR NUMBER STRING ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR STRING ASSIGN VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING IF VAR VAR STRING VAR NUMBER IF VAR VAR STRING RETURN NUMBER RETURN VAR ASSIGN VAR DICT FOR VAR VAR ASSIGN VAR LIST ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR VAR VAR NUMBER IF VAR NUMBER VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR VAR VAR VAR FOR VAR FUNC_CALL VAR VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR VAR NUMBER IF VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER NUMBER ASSIGN VAR VAR VAR VAR NUMBER IF VAR NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR STRING ASSIGN VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | from sys import exit, setrecursionlimit, stdin, stdout
setrecursionlimit(10000)
def diff(small, large):
s = 0
for i in range(7):
if small[i] == "0" and large[i] == "1":
s += 1
elif small[i] == "1" and large[i] == "0":
return -1
return s
blast = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
def collect(small):
res = [diff(small, i) for i in blast]
return res
assert collect("1110111") == [0, -1, -1, -1, -1, -1, -1, -1, 1, -1]
p = []
n = 0
INVALID = -1
NONE = -2
T = [(2200 * [NONE]) for i in range(2200)]
def bt(pi, k):
global p, n, T
if k < 0:
return INVALID
if T[pi][k] != -2:
return T[pi][k]
if pi == n:
v = INVALID
if k == 0:
v = 0
T[pi][k] = v
return T[pi][k]
for j in range(9, -1, -1):
if p[pi][j] == -1:
continue
r = bt(pi + 1, k - p[pi][j])
if r != INVALID:
T[pi][k] = j
return T[pi][k]
T[pi][k] = INVALID
return T[pi][k]
def main():
global p, n, T
rows = stdin.read().split("\n")
n, k = map(int, rows[0].split(" "))
for i in range(n):
p.append(collect(rows[i + 1]))
v = bt(0, k)
if v == -1:
print(-1)
else:
pi = 0
r = []
while pi < n:
j = T[pi][k]
k -= p[pi][j]
pi += 1
r.append(str(j))
print("".join(r))
main() | EXPR FUNC_CALL VAR NUMBER FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR STRING VAR NUMBER IF VAR VAR STRING VAR VAR STRING RETURN NUMBER RETURN VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR RETURN VAR FUNC_CALL VAR STRING LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP NUMBER LIST VAR VAR FUNC_CALL VAR NUMBER FUNC_DEF IF VAR NUMBER RETURN VAR IF VAR VAR VAR NUMBER RETURN VAR VAR VAR IF VAR VAR ASSIGN VAR VAR IF VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR VAR VAR RETURN VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR VAR RETURN VAR VAR VAR ASSIGN VAR VAR VAR VAR RETURN VAR VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR NUMBER STRING FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST WHILE VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING VAR EXPR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | n, k = list(map(int, input().split()))
numbers = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
distance = [([0] * 10) for i in range(n)]
for i in range(n):
s = str(input())
for j in range(10):
for l in range(7):
if s[l] == "0" and numbers[j][l] == "1":
distance[i][j] += 1
elif s[l] == "1" and numbers[j][l] == "0":
distance[i][j] = -1
break
dp = [([0] * (k + 1)) for i in range(n + 1)]
dp[n][0] = 1
for i in range(n, 0, -1):
for j in range(k + 1):
if dp[i][j] == 1:
for l in range(10):
if distance[i - 1][l] != -1 and j + distance[i - 1][l] <= k:
dp[i - 1][j + distance[i - 1][l]] = 1
if dp[0][k] == 0:
print(-1)
else:
ans = ""
for i in range(n):
temp = -1
for j in range(9, -1, -1):
if (
distance[i][j] != -1
and k >= distance[i][j]
and dp[i + 1][k - distance[i][j]] == 1
):
temp = j
k -= distance[i][j]
break
ans += str(temp)
print(ans) | ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR BIN_OP LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR VAR STRING VAR VAR VAR NUMBER IF VAR VAR STRING VAR VAR VAR STRING ASSIGN VAR VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR STRING FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR NUMBER VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
def I():
return sys.stdin.readline().rstrip()
cds = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
def dist(s, n):
cs = cds[n]
cost = 0
for c, cc in zip(s, cs):
if c != cc:
if c == "1":
return False, 0
cost += 1
return True, cost
def main():
n, k = map(int, I().split())
dstring = [I() for _ in range(n)]
lens = {n: [0]}
dp = [([None] * (k + 1)) for _ in range(n + 1)]
dp[n][0] = "-", 0
for i in range(n - 1, -1, -1):
idone = set()
lens[i] = set()
for d in range(9, -1, -1):
char = chr(ord("0") + d)
res = dist(dstring[i], d)
if res[0]:
diff = res[1]
if diff in idone:
continue
idone.add(diff)
for ln in lens[i + 1]:
ndiff = ln + diff
if ndiff <= k and ndiff not in lens[i]:
lens[i].add(ndiff)
dp[i][ndiff] = char, diff
if dp[0][k] != None:
ans = []
for i in range(n):
dpv = dp[i][k]
ans.append(dpv[0])
k -= dpv[1]
print("".join(ans))
else:
print("-1")
main() | IMPORT FUNC_DEF RETURN FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING FUNC_DEF ASSIGN VAR VAR VAR ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR IF VAR VAR IF VAR STRING RETURN NUMBER NUMBER VAR NUMBER RETURN NUMBER VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR DICT VAR LIST NUMBER ASSIGN VAR BIN_OP LIST NONE BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER STRING NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR STRING VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER ASSIGN VAR VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR IF VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR IF VAR NUMBER VAR NONE ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL STRING VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
n, k = map(int, input().split())
l = []
nums = [
[1, 1, 1, 0, 1, 1, 1],
[0, 0, 1, 0, 0, 1, 0],
[1, 0, 1, 1, 1, 0, 1],
[1, 0, 1, 1, 0, 1, 1],
[0, 1, 1, 1, 0, 1, 0],
[1, 1, 0, 1, 0, 1, 1],
[1, 1, 0, 1, 1, 1, 1],
[1, 0, 1, 0, 0, 1, 0],
[1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 0, 1, 1],
]
for _ in range(n):
l.append(list(map(int, list(input()))))
def dist(a, b):
c = 0
for ai, bi in zip(a, b):
if ai != bi:
if ai == 1:
return -1
else:
c += 1
return c
least = []
most = []
for v in l:
le = 100
mo = -1
for i in range(10):
d = dist(v, nums[i])
if d != -1:
le = min(le, d)
mo = max(mo, d)
least.append(le)
most.append(mo)
def rec(i, k, rl, rm):
if i == n:
return ""
v = l[i]
nrl = rl - least[i]
nrm = rm - most[i]
for j in range(10)[::-1]:
d = dist(v, nums[j])
if d != -1 and d <= k and k - d >= nrl and k - d <= nrm:
r = rec(i + 1, k - d, nrl, nrm)
if r is not None:
return str(j) + r
return None
r = rec(0, k, sum(least), sum(most))
if r is None:
print(-1)
else:
print(r) | IMPORT ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR LIST LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR IF VAR VAR IF VAR NUMBER RETURN NUMBER VAR NUMBER RETURN VAR ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR FUNC_DEF IF VAR VAR RETURN STRING ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER VAR VAR BIN_OP VAR VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR IF VAR NONE RETURN BIN_OP FUNC_CALL VAR VAR VAR RETURN NONE ASSIGN VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR NONE EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | def read_int():
return int(input())
def read_ints():
return map(int, input().split(" "))
def cost(good, broken):
ans = 0
for i in range(7):
if good[i] == "0" and broken[i] == "1":
return -1
if good[i] == "1" and broken[i] == "0":
ans += 1
return ans
s = ["{:07b}".format(i) for i in range(128)]
d = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
f = [[(-1) for i in range(8)] for j in range(128)]
g = [[] for i in range(128)]
lc = []
rc = []
for i in range(128):
for j in range(10):
c = cost(d[j], s[i])
if c == -1:
continue
if f[i][c] == -1:
g[i].append(c)
f[i][c] = max(f[i][c], j)
g[i].sort()
lc.append(g[i][0])
rc.append(g[i][-1])
n, k = read_ints()
nums = []
total = 0
for i in range(n):
num = input()
for stick in num:
if stick == "1":
total += 1
nums.append(int(num, 2))
if total + k > 7 * n:
print(-1)
else:
lo = 0
ls = [0]
rs = [0]
for i in range(n):
ls.append(ls[-1] + lc[nums[i]])
rs.append(rs[-1] + rc[nums[i]])
if k < ls[n]:
print(-1)
else:
ans = [(-1) for i in range(n)]
used = 0
for i in range(n):
rmin = ls[n] - ls[i + 1]
rmax = rs[n] - rs[i + 1]
u = 0
for j in g[nums[i]]:
if rmin <= k - used - j <= rmax:
if f[nums[i]][j] > ans[i]:
ans[i] = f[nums[i]][j]
u = j
used += u
print(int("".join(map(str, ans)))) | FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR STRING RETURN NUMBER IF VAR VAR STRING VAR VAR STRING VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL STRING VAR VAR FUNC_CALL VAR NUMBER ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR NUMBER ASSIGN VAR LIST VAR FUNC_CALL VAR NUMBER ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR IF VAR NUMBER IF VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FOR VAR VAR IF VAR STRING VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST NUMBER ASSIGN VAR LIST NUMBER FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR VAR IF VAR VAR VAR EXPR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR VAR VAR IF VAR BIN_OP BIN_OP VAR VAR VAR VAR IF VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL VAR VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
input = sys.stdin.readline
d = {
(1): [3, 6],
(0): [1, 2, 3, 5, 6, 7],
(2): [1, 3, 5, 4, 7],
(3): [1, 3, 4, 6, 7],
(4): [2, 3, 4, 6],
(5): [1, 2, 4, 6, 7],
(6): [1, 2, 4, 5, 6, 7],
(7): [1, 3, 6],
(8): [1, 2, 3, 4, 5, 6, 7],
(9): [1, 2, 3, 4, 6, 7],
}
n, k = map(int, input().split())
p = [[] for i in range(n + 1)]
f = [[(-1) for i in range(10)] for j in range(n + 1)]
g = [[(-1) for i in range(10)] for j in range(n + 1)]
for i in range(n):
s = list(input().rstrip())
for j in range(len(s)):
if s[j] == "1":
p[i].append(j + 1)
for j in range(10):
if len(set(p[i]) - set(d[j])) != 0:
continue
else:
z = len(set(d[j]) - set(p[i]))
f[i][z] = max(f[i][z], j)
g[i][j] = z
count = [[(0) for i in range((k + 1) * 8)] for j in range(n + 1)]
for i in range(n - 1, -1, -1):
if i == n - 1:
for j in range(8):
if f[i][j] != -1:
count[i][j] = 1
else:
for u in range(k + 1):
if count[i + 1][u] == 1:
for y in range(8):
if f[i][y] != -1:
count[i][y + u] = 1
s = ""
for i in range(n - 1):
for j in range(9, -1, -1):
if g[i][j] != -1 and count[i + 1][k - g[i][j]] == 1 and k >= g[i][j]:
k -= g[i][j]
s += str(j)
break
if k >= 0 and k <= 8 and f[n - 1][k] != -1:
s += str(f[n - 1][k])
print(s if len(s) == n else -1) | IMPORT ASSIGN VAR VAR ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR STRING EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR NUMBER ASSIGN VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR NUMBER ASSIGN VAR VAR BIN_OP VAR VAR NUMBER ASSIGN VAR STRING FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR NUMBER VAR VAR VAR VAR VAR VAR VAR VAR VAR FUNC_CALL VAR VAR IF VAR NUMBER VAR NUMBER VAR BIN_OP VAR NUMBER VAR NUMBER VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR NUMBER |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | def b_d(x):
dec = 0
for i in x:
dec = 2 * dec + int(i)
return dec
n, c = map(int, input().split())
a = []
for i in range(n):
st = input()
a.append(st)
b = [[] for i in range(n + 1)]
cc = "1111111"
count = 0
bina = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
for i in range(n):
for j in range(10):
if b_d(a[i]) & b_d(bina[j]) == b_d(a[i]):
e = bin((b_d(a[i]) ^ b_d(cc)) & b_d(bina[j])).replace("0b", "")
count = 0
for l in e:
if l == "1":
count += 1
b[i].append([j, count])
store = [([0] * 10) for i in range(n + 1)]
dp = [([-1] * (c + 1)) for i in range(n + 1)]
dp[n][c] = c
d = []
for i in range(n, 0, -1):
d = b[i - 1]
for j in range(c + 1):
if dp[i][j] >= 0:
for k in d:
if k[1] <= j:
dp[i - 1][j - k[1]] = max(k[0], dp[i - 1][j - k[1]])
if k[0] >= dp[i - 1][j - k[1]]:
store[i - 1][k[0]] = k[1]
if dp[0][0] == -1:
print(-1)
else:
i = 0
ans = ""
j = 0
while i < n:
ans += str(dp[i][j])
j += store[i][dp[i][j]]
i += 1
print(ans) | FUNC_DEF ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR BIN_OP BIN_OP NUMBER VAR FUNC_CALL VAR VAR RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR LIST VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR STRING ASSIGN VAR NUMBER ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR STRING STRING ASSIGN VAR NUMBER FOR VAR VAR IF VAR STRING VAR NUMBER EXPR FUNC_CALL VAR VAR LIST VAR VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR NUMBER FOR VAR VAR IF VAR NUMBER VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER IF VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR STRING ASSIGN VAR NUMBER WHILE VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | class Solution:
def __init__(self):
self.n, self.k = list(map(int, input().split()))
self.s = [input() for i in range(0, self.n)]
self.state = [
(119, 6),
(36, 2),
(93, 5),
(109, 5),
(46, 4),
(107, 5),
(123, 6),
(37, 3),
(127, 7),
(111, 6),
]
self.p = []
self.dp = [[(False) for j in range(0, self.k + 1)] for i in range(0, self.n)]
def solve(self):
for a in self.s:
state = int(a[::-1], 2)
stick = a.count("1")
v = []
for i, (dState, dStick) in enumerate(self.state):
if dState & state == state:
v.append((i, dStick - stick))
self.p.append(v)
for i in range(self.n - 1, -1, -1):
for j, stick in self.p[i]:
if i == self.n - 1:
if stick <= self.k:
self.dp[i][stick] = True
else:
for d in range(stick, self.k + 1):
self.dp[i][d] |= self.dp[i + 1][d - stick]
if not self.dp[0][self.k]:
return "-1"
result = ""
for i, v in enumerate(self.p):
for j, stick in v[::-1]:
ok = (
self.k == stick
if i == self.n - 1
else self.k >= stick and self.dp[i + 1][self.k - stick]
)
if ok:
self.k -= stick
result += str(j)
break
return result
print(Solution().solve()) | CLASS_DEF FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR FUNC_DEF FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR LIST FOR VAR VAR VAR FUNC_CALL VAR VAR IF BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR VAR VAR VAR IF VAR BIN_OP VAR NUMBER IF VAR VAR ASSIGN VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR IF VAR NUMBER VAR RETURN STRING ASSIGN VAR STRING FOR VAR VAR FUNC_CALL VAR VAR FOR VAR VAR VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR IF VAR VAR VAR VAR FUNC_CALL VAR VAR RETURN VAR EXPR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | def get(s1, s2):
c = 0
for i in range(0, 7):
if s1[i] == "0" and s2[i] == "1":
return 10000
if s1[i] == "1" and s2[i] == "0":
c += 1
return c
pre = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
n, k = map(int, input().split())
L = []
for i in range(n):
s = input()
L.append(s)
dp = []
for i in range(n + 1):
h = []
for j in range(k + 1):
h.append(False)
dp.append(h)
dp[n][0] = True
for i in range(9, -1, -1):
cost = get(pre[i], L[n - 1])
if cost <= k:
dp[n - 1][cost] = True
for i in range(n - 2, -1, -1):
for e in range(9, -1, -1):
cost = get(pre[e], L[i])
for j in range(0, k + 1):
if j - cost >= 0 and j - cost <= k and dp[i + 1][j - cost] == True:
dp[i][j] = True
if dp[0][k] == False:
print(-1)
else:
ans = ""
tot = 0
for i in range(0, n):
for j in range(9, -1, -1):
cost = get(pre[j], L[i])
if (
k - (tot + cost) >= 0
and k - (tot + cost) <= k
and dp[i + 1][k - (tot + cost)] == True
):
ans += str(j)
tot += cost
break
print(ans) | FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER IF VAR VAR STRING VAR VAR STRING RETURN NUMBER IF VAR VAR STRING VAR VAR STRING VAR NUMBER RETURN VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER IF VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR VAR NUMBER BIN_OP VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER ASSIGN VAR VAR VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR STRING ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR IF BIN_OP VAR BIN_OP VAR VAR NUMBER BIN_OP VAR BIN_OP VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR VAR NUMBER VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | vk = dict(
zip(
range(10),
[
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
],
)
)
kv = {k: v for v, k in vk.items()}
def transfer(s1, s2):
reachable = True
dist = 0
for x, y in zip(s1, s2):
if y == "0" and x == "1":
reachable = False
break
elif y == "1" and x == "0":
dist += 1
return reachable, dist
n, k = list(map(int, input().split()))
rep = []
for _ in range(n):
rep.append(input())
target = {}
for i in range(n):
for j in range(9, -1, -1):
reachable, dist = transfer(rep[i], vk[j])
if reachable and dist <= k:
target[i, j] = dist
f = [[(-1) for _ in range(k + 1)] for _ in range(n + 1)]
f[n][0] = 1
for j in range(9, -1, -1):
if (i, j) in target:
dist = target[i, j]
f[n - 1][dist] = 1
for i in range(n - 2, -1, -1):
for j in range(9, -1, -1):
if (i, j) in target:
dist = target[i, j]
for w in range(dist, k + 1):
if f[i + 1][w - dist] == 1:
f[i][w] = 1
if f[0][k] == -1:
print(-1)
else:
ans = []
quota = k
for i in range(n):
for j in range(9, -1, -1):
if (i, j) in target:
dist = target[i, j]
if dist <= quota and f[i + 1][quota - dist] == 1:
ans.append(j)
quota -= dist
break
print("".join(map(str, ans))) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR VAR VAR VAR VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR IF VAR STRING VAR STRING ASSIGN VAR NUMBER IF VAR STRING VAR STRING VAR NUMBER RETURN VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR DICT FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR ASSIGN VAR VAR VAR VAR FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER ASSIGN VAR VAR VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR LIST ASSIGN VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR ASSIGN VAR VAR VAR VAR IF VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL VAR VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
sys.setrecursionlimit(10000)
input = sys.stdin.readline
class Memoize:
def __init__(self, f):
self.f = f
self.memo = {}
def __call__(self, *args):
if not args in self.memo:
self.memo[args] = self.f(*args)
return self.memo[args]
class Recurse(Exception):
def __init__(self, *args, **kwargs):
self.args = args
self.kwargs = kwargs
def recurse(*args, **kwargs):
raise Recurse(*args, **kwargs)
def tail_recursive(f):
def decorated(*args, **kwargs):
while True:
try:
return f(*args, **kwargs)
except Recurse as r:
args = r.args
kwargs = r.kwargs
continue
return decorated
nums = {
(0): 119,
(1): 18,
(2): 93,
(3): 91,
(4): 58,
(5): 107,
(6): 111,
(7): 82,
(8): 127,
(9): 123,
}
rev = {v: k for k, v in nums.items()}
counts = {
(0): 6,
(1): 2,
(2): 5,
(3): 5,
(4): 4,
(5): 5,
(6): 6,
(7): 3,
(8): 7,
(9): 6,
}
n, k = map(int, input().split())
digits = [int(input(), 2) for _ in range(0, n)]
dp = [([0] * (k + 1)) for _ in range(n + 1)]
dp[n][0] = 1
for i in range(n - 1, -1, -1):
for x in range(9, -1, -1):
used = (
-1
if nums[x] | digits[i] != nums[x]
else bin(nums[x] ^ digits[i]).count("1")
)
if used == -1:
continue
for j in range(k, -1, -1):
if j - used < 0:
continue
dp[i][j] = dp[i][j] | dp[i + 1][j - used]
if dp[0][k] == 0:
print("-1")
else:
ans = ""
j = k
for i in range(n):
for x in range(9, -1, -1):
used = (
-1
if nums[x] | digits[i] != nums[x]
else bin(nums[x] ^ digits[i]).count("1")
)
if used != -1 and j >= used and dp[i + 1][j - used]:
ans += str(x)
j -= used
break
print(ans) | IMPORT EXPR FUNC_CALL VAR NUMBER ASSIGN VAR VAR CLASS_DEF FUNC_DEF ASSIGN VAR VAR ASSIGN VAR DICT FUNC_DEF IF VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR RETURN VAR VAR CLASS_DEF VAR FUNC_DEF ASSIGN VAR VAR ASSIGN VAR VAR FUNC_DEF FUNC_CALL VAR VAR VAR FUNC_DEF FUNC_DEF WHILE NUMBER RETURN FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR RETURN VAR ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR VAR VAR FUNC_CALL VAR ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR VAR VAR VAR VAR NUMBER FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR VAR VAR STRING IF VAR NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF BIN_OP VAR VAR NUMBER ASSIGN VAR VAR VAR BIN_OP VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING ASSIGN VAR STRING ASSIGN VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR VAR VAR VAR VAR NUMBER FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR VAR VAR STRING IF VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
input = sys.stdin.readline
def main():
n, k = map(int, input().split())
sb = [int(input(), 2) for _ in range(n)]
digit = [119, 18, 93, 91, 58, 107, 111, 82, 127, 123]
cnt = [([k + 1] * 10) for _ in range(n)]
for i in range(n):
for d in range(10):
if digit[d] | sb[i] == digit[d]:
c = 0
x = digit[d] ^ sb[i]
while x > 0:
if x & 1:
c += 1
x >>= 1
cnt[i][d] = c
dp = [([False] * (k + 1)) for _ in range(n + 1)]
dp[-1][0] = True
for i in range(n)[::-1]:
for j in range(k + 1):
for d, c in enumerate(cnt[i]):
if j - c >= 0:
dp[i][j] |= dp[i + 1][j - c]
if not dp[0][k]:
print(-1)
exit()
ans = [""] * n
for i in range(n):
for d, c in list(enumerate(cnt[i]))[::-1]:
if k - c >= 0 and dp[i + 1][k - c]:
ans[i] = str(d)
k -= c
break
print("".join(ans))
main() | IMPORT ASSIGN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP LIST BIN_OP VAR NUMBER NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR VAR VAR VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR VAR WHILE VAR NUMBER IF BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR IF BIN_OP VAR VAR NUMBER VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR IF VAR NUMBER VAR EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST STRING VAR FOR VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER VAR BIN_OP VAR NUMBER BIN_OP VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING VAR EXPR FUNC_CALL VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | N, K = map(int, input().split())
arr = [list(input()) for _ in range(N)]
dp = [([False] * (K + 1)) for _ in range(N + 1)]
dp[0][0] = True
costs = [[] for _ in range(2**7)]
digits = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
for i in range(2**7):
bits = format(i, "b")
if len(bits) != 7:
bits = "0" * (7 - len(bits)) + bits
for digit in digits:
tmp = 0
for j in range(7):
if bits[j] == "0" and digit[j] == "1":
tmp += 1
elif bits[j] == "1" and digit[j] == "0":
break
else:
costs[i].append(tmp)
for i in range(2**7):
costs[i] = list(set(costs[i]))
for i in range(N):
tmp = 0
for k in range(7):
if arr[N - i - 1][k] == "1":
tmp += 2 ** (6 - k)
for j in range(K, -1, -1):
for c in costs[tmp]:
if j - c >= 0 and dp[i][j - c] == True:
dp[i + 1][j] = True
ans = ""
for i in range(N):
for j in range(9, -1, -1):
cost = 0
for k in range(7):
if arr[i][k] == "0" and digits[j][k] == "1":
cost += 1
elif arr[i][k] == "1" and digits[j][k] == "0":
break
else:
if K - cost >= 0 and dp[N - i - 1][K - cost] == True:
ans += str(j)
K -= cost
break
else:
print(-1)
break
else:
print(ans) | ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER NUMBER ASSIGN VAR LIST VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING FOR VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR STRING IF FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP STRING BIN_OP NUMBER FUNC_CALL VAR VAR VAR FOR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR STRING VAR NUMBER IF VAR VAR STRING VAR VAR STRING EXPR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP BIN_OP VAR VAR NUMBER VAR STRING VAR BIN_OP NUMBER BIN_OP NUMBER VAR FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR VAR VAR IF BIN_OP VAR VAR NUMBER VAR VAR BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR STRING FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR STRING VAR VAR VAR STRING VAR NUMBER IF VAR VAR VAR STRING VAR VAR VAR STRING IF BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER BIN_OP VAR VAR NUMBER VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | def diff(a, b):
c = 0
for i in range(7):
if a[i] == "0" and b[i] == "1":
c = 5000
elif a[i] == "1" and b[i] == "0":
c += 1
return c
def get(a, b):
c = 0
for i in range(7):
if a[i] == "0" and b[i] == "1":
c = 5000
elif a[i] == "1" and b[i] == "0":
c += 1
return c
pre = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
n, k = map(int, input().split())
L = []
for i in range(n):
s = input()
L.append(s)
cost = []
for i in range(0, len(L)):
s = L[i]
tt = []
for j in range(9, -1, -1):
d = diff(pre[j], s)
tt.append((d, j))
tt.sort()
cost.append(tt[0][0])
sumu = 0
for i in range(0, len(cost)):
sumu += cost[i]
sumu2 = 0
for i in range(0, len(L)):
for j in range(0, len(L[i])):
if L[i][j] == "0":
sumu2 += 1
if sumu > k or k > sumu2:
print(-1)
else:
ans = []
rem = k - sumu
for i in range(0, len(L)):
rem += cost[i]
for j in range(9, -1, -1):
d = get(pre[j], L[i])
if d <= rem:
rem -= d
ans.append(str(j))
break
for i in range(len(ans) - 1, -1, -1):
if rem <= 0:
break
st = pre[int(ans[i])]
init = get(st, L[i])
rem += init
temp = init
fnl = int(ans[i])
for j in range(int(ans[i]) - 1, -1, -1):
d = get(pre[j], L[i])
if d > temp and d <= rem:
temp = d
fnl = j
rem -= temp
ans[i] = str(fnl)
if rem > 0:
print(-1)
else:
ans = "".join(ans)
print(ans) | FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR STRING ASSIGN VAR NUMBER IF VAR VAR STRING VAR VAR STRING VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR STRING VAR VAR STRING ASSIGN VAR NUMBER IF VAR VAR STRING VAR VAR STRING VAR NUMBER RETURN VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR VAR IF VAR VAR VAR STRING VAR NUMBER IF VAR VAR VAR VAR EXPR FUNC_CALL VAR NUMBER ASSIGN VAR LIST ASSIGN VAR BIN_OP VAR VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR IF VAR VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER IF VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL STRING VAR EXPR FUNC_CALL VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | import sys
r = sys.stdin.readline
n, k = map(int, r().split())
seg0to9 = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
ck = [([-1] * 10) for _ in range(n)]
def bit_count(n):
k = 0
cnt = 0
while n >= 1 << k:
if n & 1 << k != 0:
cnt += 1
k += 1
return cnt
for i in range(n):
cur = r().strip()
for j, seg in enumerate(seg0to9):
if int(cur, 2) | int(seg, 2) == int(seg, 2):
ck[i][j] = bit_count(int(cur, 2) ^ int(seg, 2))
dp = [([False] * (k + 1)) for _ in range(n + 1)]
dp[n][0] = True
for i in range(n, 0, -1):
for j in range(k + 1):
if dp[i][j]:
for d in range(10):
if ck[i - 1][d] != -1 and ck[i - 1][d] + j <= k:
dp[i - 1][j + ck[i - 1][d]] = True
if not dp[0][k]:
print("-1")
exit(0)
for i in range(n):
cur = -1
for d in range(9, -1, -1):
if ck[i][d] != -1 and ck[i][d] <= k and dp[i + 1][k - ck[i][d]]:
cur = d
k -= ck[i][d]
break
print(cur, end="") | IMPORT ASSIGN VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR BIN_OP LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR BIN_OP NUMBER VAR IF BIN_OP VAR BIN_OP NUMBER VAR NUMBER VAR NUMBER VAR NUMBER RETURN VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR FOR VAR VAR FUNC_CALL VAR VAR IF BIN_OP FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR NUMBER IF VAR NUMBER VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR NUMBER VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR STRING |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | sevsegbits = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
sevseg = [int(x, 2) for x in sevsegbits]
n, k = [int(x) for x in input().split()]
dp = [[(False) for _ in range(k + 1)] for i in range(n + 1)]
dp[n][0] = True
rip = [[(-1) for i in range(10)] for i in range(n)]
popat = [(-1) for i in range(n)]
for i in range(n):
popat[i] = int(input(), 2)
for i in range(n - 1, -1, -1):
p = popat[i]
for j in range(10):
if sevseg[j] & p == p:
ct = bin(sevseg[j] ^ p).count("1")
rip[i][j] = ct
for l in range(k + 1):
if dp[i + 1][l] == True and l + ct <= k:
dp[i][l + ct] = True
if dp[0][k] == False:
print(-1)
else:
cct = k
for i in range(n):
for j in range(9, -1, -1):
if (
rip[i][j] != -1
and cct >= rip[i][j]
and dp[i + 1][cct - rip[i][j]] == True
):
print(j, end="")
cct -= rip[i][j]
break | ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR FUNC_CALL VAR VAR NUMBER VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR VAR VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR BIN_OP VAR VAR VAR STRING ASSIGN VAR VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER BIN_OP VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR NUMBER VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR STRING VAR VAR VAR VAR |
Denis, after buying flowers and sweets (you will learn about this story in the next task), went to a date with Nastya to ask her to become a couple. Now, they are sitting in the cafe and finally... Denis asks her to be together, but ... Nastya doesn't give any answer.
The poor boy was very upset because of that. He was so sad that he punched some kind of scoreboard with numbers. The numbers are displayed in the same way as on an electronic clock: each digit position consists of $7$ segments, which can be turned on or off to display different numbers. The picture shows how all $10$ decimal digits are displayed:
After the punch, some segments stopped working, that is, some segments might stop glowing if they glowed earlier. But Denis remembered how many sticks were glowing and how many are glowing now. Denis broke exactly $k$ segments and he knows which sticks are working now. Denis came up with the question: what is the maximum possible number that can appear on the board if you turn on exactly $k$ sticks (which are off now)?
It is allowed that the number includes leading zeros.
-----Input-----
The first line contains integer $n$ $(1 \leq n \leq 2000)$ — the number of digits on scoreboard and $k$ $(0 \leq k \leq 2000)$ — the number of segments that stopped working.
The next $n$ lines contain one binary string of length $7$, the $i$-th of which encodes the $i$-th digit of the scoreboard.
Each digit on the scoreboard consists of $7$ segments. We number them, as in the picture below, and let the $i$-th place of the binary string be $0$ if the $i$-th stick is not glowing and $1$ if it is glowing. Then a binary string of length $7$ will specify which segments are glowing now.
Thus, the sequences "1110111", "0010010", "1011101", "1011011", "0111010", "1101011", "1101111", "1010010", "1111111", "1111011" encode in sequence all digits from $0$ to $9$ inclusive.
-----Output-----
Output a single number consisting of $n$ digits — the maximum number that can be obtained if you turn on exactly $k$ sticks or $-1$, if it is impossible to turn on exactly $k$ sticks so that a correct number appears on the scoreboard digits.
-----Examples-----
Input
1 7
0000000
Output
8
Input
2 5
0010010
0010010
Output
97
Input
3 5
0100001
1001001
1010011
Output
-1
-----Note-----
In the first test, we are obliged to include all $7$ sticks and get one $8$ digit on the scoreboard.
In the second test, we have sticks turned on so that units are formed. For $5$ of additionally included sticks, you can get the numbers $07$, $18$, $34$, $43$, $70$, $79$, $81$ and $97$, of which we choose the maximum — $97$.
In the third test, it is impossible to turn on exactly $5$ sticks so that a sequence of numbers appears on the scoreboard. | CORRECTS = [
"1110111",
"0010010",
"1011101",
"1011011",
"0111010",
"1101011",
"1101111",
"1010010",
"1111111",
"1111011",
]
def binary(gen):
digit = bin(gen)[2:]
while len(digit) < 7:
digit = "0" + digit
return digit
def tocorrect(digit):
global CORRECTS
possibles = []
for correct in CORRECTS:
changes = 0
possible = True
for correct_segment, segment in zip(correct, digit):
if segment == "0" and correct_segment == "1":
changes += 1
elif segment == "1" and correct_segment == "0":
possible = False
break
if possible:
possibles += (changes,)
possibles.sort()
return possibles
def newdigit(digit, possibilities, pascazinedine):
global CORRECT
for i, correct in enumerate(CORRECTS[::-1]):
number = 9 - i
changes = 0
possible = True
for correct_segment, segment in zip(correct, digit):
if segment == "0" and correct_segment == "1":
changes += 1
elif segment == "1" and correct_segment == "0":
possible = False
break
if (
changes in possibilities
and changes < 10
and possible
and not number in pascazinedine
):
return number, changes
pregen = {}
for gen in range(128):
digit = binary(gen)
pregen[digit] = tocorrect(digit)
N, K = map(int, input().split())
scoreboard = []
mintochange = 0
maxtochange = 0
for i in range(N):
digit = input()
scoreboard += (digit,)
mintochange += pregen[digit][0]
maxtochange += pregen[digit][-1]
possibilities = [[] for x in range(N)]
interdits = [[] for x in range(N)]
for i_, digit in enumerate(scoreboard[::-1]):
i = N - i_ - 1
possibilities[i] = pregen[digit]
mini = pregen[digit][0]
maxi = pregen[digit][-1]
exceptions = []
for possibility in range(mini, maxi + 1):
if not possibility in pregen[digit]:
exceptions += (possibility,)
if i_ == 0:
interdits[i] = exceptions
elif len(pregen[digit]) == 1:
try:
interdits[i] += (pregen[digit][0] + interdits[i - 1][0],)
except IndexError:
pass
if mintochange > K or maxtochange < K or K in interdits[0]:
print(-1)
else:
k = K
ans = ""
for p, digit in enumerate(scoreboard):
mintochange -= pregen[digit][0]
maxtochange -= pregen[digit][-1]
maxchangeable = k - mintochange
minchangeable = k - maxtochange
possibility = pregen[digit]
i = 0
while i < len(possibility):
if possibility[i] < minchangeable or possibility[i] > maxchangeable:
del possibility[i]
i -= 1
i += 1
Done = False
pascazinedine = []
while not Done:
number, changes = newdigit(digit, possibility, pascazinedine)
try:
if k - changes in interdits[p + 1]:
pass
else:
Done = True
except IndexError:
Done = True
if not Done:
pascazinedine += (number,)
ans += str(number)
k -= changes
print(ans) | ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR NUMBER WHILE FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP STRING VAR RETURN VAR FUNC_DEF ASSIGN VAR LIST FOR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR IF VAR STRING VAR STRING VAR NUMBER IF VAR STRING VAR STRING ASSIGN VAR NUMBER IF VAR VAR VAR EXPR FUNC_CALL VAR RETURN VAR FUNC_DEF FOR VAR VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR IF VAR STRING VAR STRING VAR NUMBER IF VAR STRING VAR STRING ASSIGN VAR NUMBER IF VAR VAR VAR NUMBER VAR VAR VAR RETURN VAR VAR ASSIGN VAR DICT FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR VAR NUMBER VAR VAR VAR NUMBER ASSIGN VAR LIST VAR FUNC_CALL VAR VAR ASSIGN VAR LIST VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR NUMBER ASSIGN VAR VAR VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER IF VAR VAR VAR VAR VAR IF VAR NUMBER ASSIGN VAR VAR VAR IF FUNC_CALL VAR VAR VAR NUMBER VAR VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR IF VAR VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR VAR ASSIGN VAR STRING FOR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR NUMBER VAR VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR NUMBER WHILE VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR VAR VAR VAR VAR VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST WHILE VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR IF BIN_OP VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER IF VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | q = int(input())
while q:
q -= 1
x, y = map(int, input().split())
binx, biny = list(map(int, list(bin(x)[:1:-1]))), list(
map(int, list(bin(y)[:1:-1]))
)
cntx, cnty = 0, 0
tag = True
if x > y:
print("NO")
continue
for i in range(len(binx)):
if binx[i] == 1:
cntx += 1
if biny[i] == 1:
cnty += 1
if cntx < cnty:
tag = False
if sum(binx) >= sum(biny) and tag and x <= y:
print("YES")
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR NUMBER IF VAR VAR NUMBER VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | def lsb(x):
return x & -x
def solve(x, y):
if x == y:
return True
if x > y:
return False
while y:
if x == 0 or lsb(x) > lsb(y):
return False
x -= lsb(x)
y -= lsb(y)
return True
q = int(input())
for i in range(q):
x, y = map(int, input().split())
if solve(x, y):
print("YES")
else:
print("NO") | FUNC_DEF RETURN BIN_OP VAR VAR FUNC_DEF IF VAR VAR RETURN NUMBER IF VAR VAR RETURN NUMBER WHILE VAR IF VAR NUMBER FUNC_CALL VAR VAR FUNC_CALL VAR VAR RETURN NUMBER VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
def main():
import sys
input = sys.stdin.buffer.readline
q = int(input())
Q = [tuple(map(int, input().split())) for i in range(q)]
ans = []
for u, v in Q:
if v < u:
ans.append("NO")
continue
u = bin(u)[2:]
v = bin(v)[2:]
x = u.count("1")
y = u.count("1")
if x < y:
ans.append("NO")
else:
U = []
V = []
for z in v:
V.append(int(z))
if len(v) > len(u):
d = len(v) - len(u)
for i in range(d):
U.append(0)
for z in u:
U.append(int(z))
n = len(V)
pu = 0
flag = 1
for i in range(n):
if V[i]:
if pu < i:
pu = i
flag2 = 1
for j in range(pu, n):
if U[j]:
flag2 = 0
pu = j + 1
break
if flag2:
flag = 0
break
if flag:
ans.append("YES")
else:
ans.append("NO")
print("\n".join(ans))
main() | IMPORT FUNC_DEF IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR STRING IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR NUMBER FOR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR IF VAR VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER IF VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR FUNC_CALL STRING VAR EXPR FUNC_CALL VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
from sys import stdin
tt = int(stdin.readline())
ans = []
for loop in range(tt):
u, v = map(int, stdin.readline().split())
if u > v:
ans.append("NO")
continue
asum = 0
bsum = 0
flag = True
for i in range(31):
if 2**i & u > 0:
asum += 1
if 2**i & v > 0:
bsum += 1
if asum < bsum:
flag = False
break
if flag:
ans.append("YES")
else:
ans.append("NO")
print("\n".join(ans)) | IMPORT ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP BIN_OP NUMBER VAR VAR NUMBER VAR NUMBER IF BIN_OP BIN_OP NUMBER VAR VAR NUMBER VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR FUNC_CALL STRING VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | def lsb(x):
return x & -x
Q = int(input())
for q in range(Q):
a, b = map(int, input().split(" "))
if a > b:
print("NO")
else:
can = True
while b > 0:
if lsb(a) > lsb(b) or a == 0:
can = False
break
a -= lsb(a)
b -= lsb(b)
if can:
print("YES")
else:
print("NO") | FUNC_DEF RETURN BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER WHILE VAR NUMBER IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | for _ in range(int(input())):
u, v = list(map(int, input().split()))
if u > v:
print("NO")
elif u == v:
print("YES")
else:
fl = True
u = bin(u)
v = bin(v)
u_o = 0
v_o = 0
diff = len(v) - len(u)
for i in range(len(u) - 1, 1, -1):
if u[i] == "1":
u_o += 1
if v[i + diff] == "1":
v_o += 1
if v_o > u_o:
print("NO")
fl = False
break
if fl:
for i in range(2, 2 + diff):
if v[i] == "1":
v_o += 1
if v_o > u_o:
print("NO")
else:
print("YES") | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER IF VAR VAR STRING VAR NUMBER IF VAR BIN_OP VAR VAR STRING VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER IF VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER VAR IF VAR VAR STRING VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
(*data,) = sys.stdin.read().split("\n")[::-1]
def input():
return data.pop()
def fprint(*args, **kwargs):
print(*args, **kwargs, flush=True)
def eprint(*args, **kwargs):
print(*args, **kwargs, file=sys.stderr)
for _ in range(int(input())):
src, dst = map(int, input().split())
if src <= dst:
spare = 0
while dst:
if src & 1:
spare += 1
src //= 2
if dst & 1 and not spare:
break
if dst & 1:
spare -= 1
dst //= 2
print("YES" if not dst else "NO") | IMPORT ASSIGN VAR FUNC_CALL FUNC_CALL VAR STRING NUMBER FUNC_DEF RETURN FUNC_CALL VAR FUNC_DEF EXPR FUNC_CALL VAR VAR VAR NUMBER FUNC_DEF EXPR FUNC_CALL VAR VAR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR ASSIGN VAR NUMBER WHILE VAR IF BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER IF BIN_OP VAR NUMBER VAR IF BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR STRING STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
input = sys.stdin.readline
for _ in range(int(input())):
u, v = map(int, input().split())
if u == v:
print("YES")
continue
res = "NO"
if not (u <= v and bin(u).count("1") >= bin(v).count("1")):
print("NO")
continue
while u < v:
while u & 1 == v & 1:
u //= 2
v //= 2
if not v or u & 1 < v & 1:
break
x, y = u, 0
while x & 1 and u + 2 * y + 1 <= v:
x //= 2
y *= 2
y += 1
u += y
if u == v:
res = "YES"
print(res) | IMPORT ASSIGN VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR STRING IF VAR VAR FUNC_CALL FUNC_CALL VAR VAR STRING FUNC_CALL FUNC_CALL VAR VAR STRING EXPR FUNC_CALL VAR STRING WHILE VAR VAR WHILE BIN_OP VAR NUMBER BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER IF VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR VAR NUMBER WHILE BIN_OP VAR NUMBER BIN_OP BIN_OP VAR BIN_OP NUMBER VAR NUMBER VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR VAR IF VAR VAR ASSIGN VAR STRING EXPR FUNC_CALL VAR VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | for _ in range(int(input())):
l, r = map(int, input().split())
if l > r:
print("NO")
else:
L = 0
R = 0
ok = True
while l or r:
if l & 1:
L += 1
l >>= 1
if r & 1:
R += 1
r >>= 1
if R > L:
ok = False
if ok:
print("YES")
else:
print("NO") | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR IF BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER IF BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | for s in [*open(0)][1:]:
u, v = map(int, s.split())
n = 0
while u < v and n >= 0:
n += u % 2 - v % 2
v >>= 1
u >>= 1
print("YNEOS"[u != v or n < 0 :: 2]) | FOR VAR LIST FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR ASSIGN VAR NUMBER WHILE VAR VAR VAR NUMBER VAR BIN_OP BIN_OP VAR NUMBER BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING VAR VAR VAR NUMBER NUMBER |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
def isT(u1, u2):
if u1 > u2:
return False
else:
while u2 > 1:
if u2 & -u2 < u1 & -u1 or u1 == 0:
return False
u1 -= u1 & -u1
u2 -= u2 & -u2
return True
q = int(sys.stdin.readline())
for i in range(q):
u1, u2 = list(map(int, sys.stdin.readline().split()))
if isT(u1, u2):
print("YES")
else:
print("NO") | IMPORT FUNC_DEF IF VAR VAR RETURN NUMBER WHILE VAR NUMBER IF BIN_OP VAR VAR BIN_OP VAR VAR VAR NUMBER RETURN NUMBER VAR BIN_OP VAR VAR VAR BIN_OP VAR VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
inp = lambda: list(map(int, sys.stdin.readline().rstrip("\r\n").split()))
mod = 10**9 + 7
Mod = 998244353
INF = float("inf")
tc = 1
(tc,) = inp()
for _ in range(tc):
a, b = inp()
def lsb(x):
return x & -x
f = True
if a > b:
f = False
while b > 0:
if lsb(b) < lsb(a) or a == 0:
f = False
break
a -= lsb(a)
b -= lsb(b)
print("YES" if f else "NO") | IMPORT ASSIGN VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_DEF RETURN BIN_OP VAR VAR ASSIGN VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER WHILE VAR NUMBER IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR STRING STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | q = int(input())
for qw in range(q):
x, y = [int(x) for x in input().split()]
if x > y:
print("No")
continue
sx = 0
sy = 0
ans = "Yes"
while y > 0:
sx += x % 2
sy += y % 2
if sx < sy:
ans = "No"
x //= 2
y //= 2
print(ans) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR STRING WHILE VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER IF VAR VAR ASSIGN VAR STRING VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
input = iter(sys.stdin.read().splitlines()).__next__
q = int(input())
output = []
for _ in range(q):
u, v = map(int, input().split())
if u > v:
output.append("NO")
continue
count_u = 0
count_v = 0
while v > 0:
count_u += u & 1
count_v += v & 1
if count_v > count_u:
output.append("NO")
break
u >>= 1
v >>= 1
else:
output.append("YES")
print(*output, sep="\n") | IMPORT ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR STRING VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | def next(x):
get_bin = lambda x: format(x, "b")
b = get_bin(x)
mult = 1
l = set({0})
newlist = set()
i = len(b) - 1
while i >= 0:
if b[i] == "1":
for j in l:
newlist.add(j + mult)
l = l.union(newlist)
mult *= 2
i -= 1
return l
for q in range(int(input())):
u, v = list(map(int, input().split()))
if u > v:
print("NO")
else:
possible = True
bu = format(u, "b")
bv = format(v, "b")
ones = 0
i = -1
while i >= -len(bu):
if bu[i] == "0":
if bv[i] == "1":
ones -= 1
if ones < 0:
print("NO")
possible = False
break
elif bv[i] == "0":
ones += 1
i -= 1
if possible:
for i in range(len(bv) - len(bu)):
if bv[i] == "1":
ones -= 1
if ones >= 0:
print("YES")
else:
print("NO") | FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR STRING ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER WHILE VAR NUMBER IF VAR VAR STRING FOR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER VAR NUMBER RETURN VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR STRING ASSIGN VAR FUNC_CALL VAR VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR FUNC_CALL VAR VAR IF VAR VAR STRING IF VAR VAR STRING VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER IF VAR VAR STRING VAR NUMBER VAR NUMBER IF VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR STRING VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | Q = int(input())
ans = ["YES"] * Q
for t in range(Q):
u, v = map(int, input().split())
if u > v:
ans[t] = "NO"
continue
cum1 = cum2 = 0
for i in range(32):
if (u >> i) % 2:
cum1 += 1
if (v >> i) % 2:
cum2 += 1
if cum1 < cum2:
ans[t] = "NO"
break
print(*ans, sep="\n") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST STRING VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR ASSIGN VAR VAR STRING ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER IF BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER IF VAR VAR ASSIGN VAR VAR STRING EXPR FUNC_CALL VAR VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | for _ in range(int(input())):
n, m = map(int, input().split())
if bin(n).count("1") >= bin(m).count("1") and n <= m:
A = []
B = []
sa = bin(n)
sb = bin(m)
for i in range(len(sa)):
if sa[-i - 1] == "1":
A.append(i)
for i in range(len(sb)):
if sb[-i - 1] == "1":
B.append(i)
tr = True
for i in range(len(B)):
if A[i] > B[i]:
tr = False
break
if tr:
print("YES")
else:
print("NO")
else:
print("NO") | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF FUNC_CALL FUNC_CALL VAR VAR STRING FUNC_CALL FUNC_CALL VAR VAR STRING VAR VAR ASSIGN VAR LIST ASSIGN VAR LIST ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR BIN_OP VAR NUMBER STRING EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR BIN_OP VAR NUMBER STRING EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
input = sys.stdin.buffer.readline
def solve(u, v):
ulist = list(map(int, "{:031b}".format(u)))
vlist = list(map(int, "{:031b}".format(v)))
su = sum(ulist)
sv = sum(vlist)
if su < sv:
return False
diff = su - sv
cur = 0
for ub, vb in zip(ulist, vlist):
cur += vb - ub
if cur < 0:
return False
spare = cur
if spare > 0:
spare = min(spare, diff)
cur += spare
diff -= spare
return diff == 0
q = int(input())
answers = []
for _ in range(q):
u, v = map(int, input().split())
answers.append("YES" if solve(u, v) else "NO")
print("\n".join(answers)) | IMPORT ASSIGN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL STRING VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL STRING VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR VAR IF VAR NUMBER RETURN NUMBER ASSIGN VAR VAR IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR RETURN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR STRING STRING EXPR FUNC_CALL VAR FUNC_CALL STRING VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
sys.setrecursionlimit(10**5)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II():
return int(sys.stdin.buffer.readline())
def MI():
return map(int, sys.stdin.buffer.readline().split())
def LI():
return list(map(int, sys.stdin.buffer.readline().split()))
def LLI(rows_number):
return [LI() for _ in range(rows_number)]
def BI():
return sys.stdin.buffer.readline().rstrip()
def SI():
return sys.stdin.buffer.readline().rstrip().decode()
inf = 10**16
md = 10**9 + 7
def tolst(a):
res = [0] * 30
for i in range(30):
res[i] = a & 1
a >>= 1
return res
def ok():
if u > v:
return False
uu = tolst(u)
vv = tolst(v)
s = t = 0
for a, b in zip(uu, vv):
s += a
t += b
if v and s < t:
return False
return True
for _ in range(II()):
u, v = MI()
print("YES" if ok() else "NO") | IMPORT EXPR FUNC_CALL VAR BIN_OP NUMBER NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR STRING FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_DEF RETURN FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF IF VAR VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR IF VAR VAR VAR RETURN NUMBER RETURN NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR STRING STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
input = sys.stdin.readline
def main():
Q = int(input())
UV = [[int(x) for x in input().split()] for _ in range(Q)]
for u, v in UV:
if u == v:
print("YES")
elif u > v:
print("NO")
else:
u_one = bin(u).count("1")
u_i = []
v_i = []
for i in range(32):
if u >> i & 1:
u_i.append(i)
if v >> i & 1:
v_i.append(i)
v_one = bin(v).count("1")
if u_one == v_one:
f = True
for a, b in zip(u_i, v_i):
if a > b:
f = False
break
if f:
print("YES")
else:
print("NO")
elif u_one > v_one:
f = True
for a, b in zip(u_i, v_i):
if a > b:
f = False
break
if f:
print("YES")
else:
print("NO")
else:
print("NO")
main() | IMPORT ASSIGN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR VAR FOR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR STRING IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR STRING ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR IF BIN_OP BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR STRING IF VAR VAR ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR IF VAR VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING IF VAR VAR ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR IF VAR VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
input = sys.stdin.readline
q = int(input())
for _ in range(q):
u, v = map(int, input().split())
x = bin(u)[2:]
y = bin(v)[2:]
n, m = len(x), len(y)
if v < u or x.count("1") < y.count("1"):
print("No")
else:
ok = True
count = 0
for i in range(n):
count += int(x[-i])
count -= int(y[-i])
if count < 0:
ok = False
break
if ok:
print("Yes")
else:
print("No") | IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR FUNC_CALL VAR STRING FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR VAR IF VAR NUMBER ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
pin = sys.stdin.readline
Q = int(pin())
for q in range(Q):
u, v = map(int, pin().split())
if u > v:
print("NO")
else:
u, v = bin(u)[2:][::-1], bin(v)[2:][::-1]
if u.count("1") < v.count("1"):
print("NO")
else:
F = 1
S = 0
for i in range(len(u)):
if u[i] == v[i]:
continue
elif u[i] == "1":
S += 1
else:
S -= 1
if S < 0:
F = 0
break
print(["NO", "YES"][F]) | IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR VAR FUNC_CALL VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER IF FUNC_CALL VAR STRING FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR IF VAR VAR STRING VAR NUMBER VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER EXPR FUNC_CALL VAR LIST STRING STRING VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
input = sys.stdin.readline
q = int(input())
for i in range(q):
x, y = map(int, input().split())
X = []
Y = []
for i in range(31, -1, -1):
if x & 1 << i != 0:
X.append(i)
if y & 1 << i != 0:
Y.append(i)
if len(X) < len(Y):
print("NO")
elif len(X) == len(Y):
for j in range(len(X)):
if X[j] <= Y[j]:
True
else:
print("NO")
break
else:
print("YES")
else:
flag = 0
for j in range(len(Y)):
if Y[j] > X[j]:
flag = 1
break
if Y[j] < X[j]:
flag = -1
break
if flag == -1 or flag == 0:
print("NO")
continue
indx = 0
for j in range(len(Y)):
if indx == len(X):
print("NO")
break
while X[indx] > Y[j]:
indx += 1
if indx == len(X):
break
if indx == len(X):
print("NO")
break
else:
indx += 1
else:
print("YES") | IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF BIN_OP VAR BIN_OP NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR IF BIN_OP VAR BIN_OP NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR EXPR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR ASSIGN VAR NUMBER IF VAR VAR VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING WHILE VAR VAR VAR VAR VAR NUMBER IF VAR FUNC_CALL VAR VAR IF VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING VAR NUMBER EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
input = sys.stdin.readline
def parse(x):
out = []
for i in range(29, -1, -1):
if x >= 1 << i:
out.append(i)
x -= 1 << i
return out
res = []
n = int(input())
for _ in range(n):
a, b = map(int, input().split())
if a == b:
res.append("YES")
continue
p1 = parse(a)
p2 = parse(b)
if len(p2) > len(p1):
res.append("NO")
continue
start = 0
while len(p2) > start and p1[start] == p2[start]:
start += 1
p1 = p1[start:]
p2 = p2[start:]
if len(p2) == 0 or p2[0] < p1[0]:
res.append("NO")
continue
assert p2[0] > p1[0]
for i in range(len(p2) - 1):
if p1[-i - 1] > p2[-i - 1]:
res.append("NO")
break
else:
res.append("YES")
print("\n".join(res)) | IMPORT ASSIGN VAR VAR FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR VAR VAR BIN_OP NUMBER VAR RETURN VAR ASSIGN VAR LIST ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER WHILE FUNC_CALL VAR VAR VAR VAR VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR FUNC_CALL STRING VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | t = int(input())
for _ in range(t):
u, v = tuple(map(int, input().split()))
if v < u:
print("NO")
continue
ustr = format(u, "b")
vstr = format(v, "b")
ustr = str(ustr[::-1]) + "0" * (len(vstr) - len(ustr))
vstr = str(vstr[::-1])
maxCarry = 0
carry = False
for cu, cv in zip(ustr, vstr):
if cu == "0" and cv == "1":
maxCarry -= 1
if maxCarry < 0:
break
carry = False
if cu == "1" and cv == "0":
carry = True
maxCarry += 1
if not carry and maxCarry >= 0:
print("YES")
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR STRING ASSIGN VAR FUNC_CALL VAR VAR STRING ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER BIN_OP STRING BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR IF VAR STRING VAR STRING VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER IF VAR STRING VAR STRING ASSIGN VAR NUMBER VAR NUMBER IF VAR VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | for _ in range(int(input())):
u, v = map(int, input().split())
def zeroes(x):
c = 0
while x & 1 == 0:
x //= 2
c += 1
return c
def bits(x):
c = 1
ret = []
while c <= x:
if c & x:
ret.append(c)
c *= 2
return ret
bu = bits(u)
bv = bits(v)
if u <= v and len(bu) >= len(bv) and zeroes(u) <= zeroes(v):
bu = bu[0 : len(bv)]
possible = True
for ui, vi in zip(bu, bv):
if ui > vi:
possible = False
break
print("yEs" if possible else "nO")
else:
print("No") | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF ASSIGN VAR NUMBER WHILE BIN_OP VAR NUMBER NUMBER VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR LIST WHILE VAR VAR IF BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR IF VAR VAR ASSIGN VAR NUMBER EXPR FUNC_CALL VAR VAR STRING STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | q = int(input())
queries = [tuple(map(int, input().split())) for _ in range(q)]
for u, v in queries:
if u > v:
print("No")
continue
u = [int(c) for c in bin(u)[:1:-1]]
v = [int(c) for c in bin(v)[:1:-1]]
ui = [i for i, x in enumerate(u) if x == 1]
vi = [i for i, x in enumerate(v) if x == 1]
if len(vi) > len(ui):
print("No")
continue
ui = ui[: len(vi)]
print("Yes" if all(x <= y for x, y in zip(ui, vi)) else "No") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR VAR FOR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR VAR VAR VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR FUNC_CALL VAR VAR VAR NUMBER IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR FUNC_CALL VAR VAR VAR STRING STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | q = int(input())
for _ in range(q):
u, v = map(int, input().split())
bu = bin(u)[2:][::-1]
bv = bin(v)[2:][::-1]
if u > v or bu.count("1") < bv.count("1"):
print("NO")
continue
uCounts = [i for i, c in enumerate(bu) if c == "1"]
vCounts = [i for i, c in enumerate(bv) if c == "1"]
for j in range(len(vCounts)):
if vCounts[j] < uCounts[j]:
print("NO")
break
else:
print("YES") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR FUNC_CALL VAR STRING FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING ASSIGN VAR VAR VAR VAR FUNC_CALL VAR VAR VAR STRING ASSIGN VAR VAR VAR VAR FUNC_CALL VAR VAR VAR STRING FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
n = int(input())
for i in range(n):
f, t = list(map(int, input().split()))
if f > t:
print("NO")
elif f == t:
print("YES")
elif f & 1 == 0 and t & 1:
print("NO")
else:
binf = bin(f)[2:]
bint = bin(t)[2:]
ans = "YES"
n = len(bint)
binf = "0" * (n - len(binf)) + binf
currSum = 0
for i in range(n):
if bint[n - i - 1] == "1":
currSum += 1
if binf[n - i - 1] == "1":
currSum -= 1
if currSum > 0:
ans = "NO"
break
if bint.count("1") > binf.count("1"):
print("NO")
else:
print(ans) | IMPORT ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING IF VAR VAR EXPR FUNC_CALL VAR STRING IF BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR STRING ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP STRING BIN_OP VAR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR BIN_OP BIN_OP VAR VAR NUMBER STRING VAR NUMBER IF VAR BIN_OP BIN_OP VAR VAR NUMBER STRING VAR NUMBER IF VAR NUMBER ASSIGN VAR STRING IF FUNC_CALL VAR STRING FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | for i in range(int(input())):
a, b = list(map(int, input().split()))
if b < a:
print("NO")
else:
c = str(bin(a))[2:]
d = str(bin(b))[2:]
e = 0
f = 0
g = len(c)
h = len(d)
x = 0
for k in range(h):
if k < g and c[g - k - 1] == "1":
e += 1
if d[h - k - 1] == "1":
f += 1
if f > e:
x = 1
break
if x == 0:
print("YES")
else:
print("NO") | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR BIN_OP BIN_OP VAR VAR NUMBER STRING VAR NUMBER IF VAR BIN_OP BIN_OP VAR VAR NUMBER STRING VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
input = sys.stdin.readline
I = lambda: list(map(int, input().split()))
(t,) = I()
for _ in range(t):
u, v = I()
pos = 0
if u > v:
pos = 1
else:
ps = 0
i = 0
while i < 32:
cr = 1 << i
if u & cr:
ps += 1
if v & cr:
ps -= 1
if ps < 0:
pos = 1
break
i += 1
print("YNEOS"[pos::2]) | IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR NUMBER ASSIGN VAR BIN_OP NUMBER VAR IF BIN_OP VAR VAR VAR NUMBER IF BIN_OP VAR VAR VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING VAR NUMBER |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | def read_list() -> list:
return [int(i) for i in input().strip().split()]
def read_num() -> int:
return int(input().strip())
def check(u, v):
cnt_u, cnt_v = 0, 0
for i in range(31):
if u >> i & 1:
cnt_u += 1
if v >> i & 1:
cnt_v += 1
if cnt_v != 0:
if cnt_u == 0:
return False
cnt_u -= 1
cnt_v -= 1
return True
q = read_num()
for _ in range(q):
u, v = read_list()
print("YES" if u <= v and check(u, v) else "NO") | FUNC_DEF RETURN FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER IF BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER IF VAR NUMBER IF VAR NUMBER RETURN NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR STRING STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | queries = int(input())
for _ in range(queries):
u, v = map(int, input().split(" "))
if u > v:
print("NO")
continue
elif u == v:
print("YES")
continue
u_bin = bin(u).replace("0b", "")
v_bin = bin(v).replace("0b", "")
if len(u_bin) < len(v_bin):
u_bin = "0" * (len(v_bin) - len(u_bin)) + u_bin
u_bin = u_bin[::-1]
v_bin = v_bin[::-1]
count_u, count_v = 0, 0
stop = False
for i in range(len(u_bin)):
if u_bin[i] == "1":
count_u += 1
if v_bin[i] == "1":
count_v += 1
if count_v > count_u:
print("NO")
stop = True
break
if not stop:
print("YES") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING IF VAR VAR EXPR FUNC_CALL VAR STRING IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR STRING STRING ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR STRING STRING IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP STRING BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR STRING VAR NUMBER IF VAR VAR STRING VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | def f(n):
for i in range(1, n):
if i & n - i == n - i:
print(i, n)
for tc in range(int(input())):
u, v = map(int, input().split())
if u > v:
print("NO")
continue
elif u == v:
print("YES")
continue
binu = bin(u)[2:]
binv = bin(v)[2:]
binu = "0" * (len(binv) - len(binu)) + binu
binu = binu[::-1]
binv = binv[::-1]
cntu, cntv = 0, 0
for i in range(len(binu)):
cntv += binv[i] == "1"
cntu += binu[i] == "1"
if cntv > cntu:
print("NO")
break
else:
print("YES") | FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER VAR IF BIN_OP VAR BIN_OP VAR VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP STRING BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR STRING VAR VAR VAR STRING IF VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
readline = sys.stdin.readline
T = int(readline())
Ans = ["NO"] * T
limit = 33
for qu in range(T):
u, v = map(int, readline().split())
if u <= v:
p = 0
for k in range(limit):
if 1 << k & u == 1 << k & v:
continue
if 1 << k & u == 0:
p -= 1
if p < 0:
break
else:
p += 1
else:
Ans[qu] = "YES"
print("\n".join(Ans)) | IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST STRING VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF BIN_OP BIN_OP NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR VAR IF BIN_OP BIN_OP NUMBER VAR VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR VAR STRING EXPR FUNC_CALL VAR FUNC_CALL STRING VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | from sys import stdin, stdout
input = stdin.readline
t = int(input())
for _ in range(t):
a, b = map(int, input().split())
if b < a:
print("no")
continue
ans = "yes"
x = 0
y = 0
for i in range(32):
if a & 1 << i:
x += 1
if b & 1 << i:
y += 1
if y > x:
ans = "no"
break
print(ans) | ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR BIN_OP NUMBER VAR VAR NUMBER IF BIN_OP VAR BIN_OP NUMBER VAR VAR NUMBER IF VAR VAR ASSIGN VAR STRING EXPR FUNC_CALL VAR VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
def main():
q = int(input())
allans = []
for _ in range(q):
u, z = readIntArr()
u2 = bin(u)[2:][::-1]
z2 = bin(z)[2:][::-1]
if z < u:
ans = "No"
else:
n = len(z2)
cumuU = 0
cumuZ = 0
ok = True
for i in range(n):
if i < len(u2) and u2[i] == "1":
cumuU += 1
if z2[i] == "1":
cumuZ += 1
if cumuU < cumuZ:
ok = False
if ok:
ans = "Yes"
else:
ans = "No"
allans.append(ans)
multiLineArrayPrint(allans)
return
input = lambda: sys.stdin.readline().rstrip("\r\n")
def oneLineArrayPrint(arr):
print(" ".join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print("\n".join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print("\n".join([" ".join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
inf = float("inf")
MOD = 10**9 + 7
for _ in range(1):
main() | IMPORT FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR ASSIGN VAR STRING ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR FUNC_CALL VAR VAR VAR VAR STRING VAR NUMBER IF VAR VAR STRING VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER IF VAR ASSIGN VAR STRING ASSIGN VAR STRING EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR RETURN ASSIGN VAR FUNC_CALL FUNC_CALL VAR STRING FUNC_DEF EXPR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL VAR VAR VAR VAR FUNC_DEF EXPR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL VAR VAR VAR VAR FUNC_DEF EXPR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL STRING FUNC_CALL VAR VAR VAR VAR VAR VAR FUNC_DEF RETURN FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | d = int(input())
for d in range(d):
u, v = [int(x) for x in input().split()]
if u > v:
print("NO")
else:
ucount = bin(u).count("1")
vcount = bin(v).count("1")
if ucount < vcount:
print("NO")
else:
uu, vv = 0, 0
for i in range(32):
if u >> i & 1:
uu += 1
if v >> i & 1:
vv += 1
if uu < vv:
print("NO")
break
else:
print("YES") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR STRING ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR STRING IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER IF BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | for i in range(int(input())):
x, y = map(int, input().split())
k1 = k2 = 0
flg = 0
if x > y:
print("NO")
else:
for j in range(2**5):
k1 += (x >> j) % 2
k2 += (y >> j) % 2
if k2 > k1:
print("NO")
flg = 1
break
if flg == 0:
print("YES") | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR BIN_OP NUMBER NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | for rpt in range(int(input())):
u, v = [int(x) for x in input().split()]
binu = [int(x) for x in list("{0:0b}".format(u))]
binv = [int(x) for x in list("{0:0b}".format(v))]
if u > v or len(binu) > len(binv):
print("NO")
else:
binu = [(0) for x in range(len(binv) - len(binu))] + binu
ones_availible = 0
for i in range(len(binv) - 1, -1, -1):
if binu[i] == 1:
ones_availible += 1
if binv[i] == 1:
ones_availible -= 1
if ones_availible < 0:
break
if ones_availible < 0:
print("NO")
else:
print("YES") | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR FUNC_CALL STRING VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR FUNC_CALL STRING VAR IF VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR BIN_OP NUMBER VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER IF VAR VAR NUMBER VAR NUMBER IF VAR VAR NUMBER VAR NUMBER IF VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | for w in range(int(input())):
a, b = tuple(map(int, input().split()))
if b < a:
print("NO")
elif b == a or b == 2 * a:
print("YES")
else:
u = a
v = b
u_binary = bin(u).replace("0b", "")[::-1]
v_binary = bin(v).replace("0b", "")[::-1]
x = 0
y = 0
ans = 1
i = 0
while i < max(len(u_binary), len(v_binary)):
if i < len(u_binary):
if u_binary[i] == "1":
x += 1
if i < len(v_binary):
if v_binary[i] == "1":
y += 1
if y > x:
ans = 0
break
i += 1
if ans == 0:
print("NO")
else:
print("YES") | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING IF VAR VAR VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR STRING STRING NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR STRING STRING NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR FUNC_CALL VAR VAR IF VAR VAR STRING VAR NUMBER IF VAR FUNC_CALL VAR VAR IF VAR VAR STRING VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
def read_ints():
return [int(i) for i in sys.stdin.readline().strip().split()]
def read_int():
return int(sys.stdin.readline().strip())
def path(u, v):
if u > v:
return False
ub = "{0:b}".format(u).zfill(32)[::-1]
vb = "{0:b}".format(v).zfill(32)[::-1]
u_ones = 0
v_ones = 0
for uc, vc in zip(ub, vb):
if uc == "1":
u_ones += 1
if vc == "1":
v_ones += 1
if v_ones > u_ones:
return False
return True
q = read_int()
for i in range(q):
u, v = read_ints()
if path(u, v):
print("YES")
else:
print("NO") | IMPORT FUNC_DEF RETURN FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF IF VAR VAR RETURN NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL STRING VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL STRING VAR NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR IF VAR STRING VAR NUMBER IF VAR STRING VAR NUMBER IF VAR VAR RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | import sys
input = sys.stdin.readline
q = int(input())
for _ in range(q):
u, v = map(int, input().split())
pu = 0
pv = 0
tu = []
tv = []
for i in range(31, -1, -1):
if u >> i & 1:
pu += 1
tu.append(i)
if v >> i & 1:
pv += 1
tv.append(i)
dp = [([0] * (pv + 1)) for _ in range(pu + 1)]
dp[0][0] = 1
for i in range(pu):
for j in range(pv):
if tu[i] < tv[j]:
for k in range(i + 1, pu + 1):
dp[k][j + 1] |= dp[i][j]
if tu[i] <= tv[j]:
dp[i + 1][j + 1] |= dp[i][j]
if dp[pu][pv]:
print("YES")
else:
print("NO") | IMPORT ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR IF BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER VAR VAR BIN_OP VAR NUMBER VAR VAR VAR IF VAR VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER VAR VAR VAR IF VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | T = int(input())
for _ in range(T):
u, v = map(int, input().split())
if u > v:
print("NO")
else:
s = bin(u).replace("0b", "")
t = bin(v).replace("0b", "")
s = s[::-1]
t = t[::-1]
s = s + "0" * (len(t) - len(s))
n = len(t)
cnt = 0
flag = 0
for i in range(n):
if s[i] == "1":
cnt = cnt + 1
if t[i] == "1":
if cnt == 0:
flag = 1
break
cnt = cnt - 1
if flag == 1:
print("NO")
else:
print("YES") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR STRING STRING ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR STRING STRING ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP STRING BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR STRING ASSIGN VAR BIN_OP VAR NUMBER IF VAR VAR STRING IF VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | n = int(input())
for j in range(n):
p, q = map(int, input().split())
if p > q:
print("NO")
elif p == q:
print("YES")
else:
poss = 1
while q > 0:
if p == 0 or q & -q < p & -p:
poss = 0
break
else:
p -= p & -p
q -= q & -q
if poss:
print("YES")
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER WHILE VAR NUMBER IF VAR NUMBER BIN_OP VAR VAR BIN_OP VAR VAR ASSIGN VAR NUMBER VAR BIN_OP VAR VAR VAR BIN_OP VAR VAR IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | from sys import gettrace, stdin
if gettrace():
def inputi():
return input()
else:
def input():
return next(stdin)[:-1]
def inputi():
return stdin.buffer.readline()
def solve():
u, v = map(int, input().split())
if v < u:
print("NO")
return
bu = 0
bv = 0
while u > 0 or v > 0:
bu += u & 1
bv += v & 1
if bv > bu:
print("NO")
return
u >>= 1
v >>= 1
print("YES")
def main():
t = int(input())
for _ in range(t):
solve()
main() | IF FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR VAR NUMBER FUNC_DEF RETURN FUNC_CALL VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING RETURN ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR NUMBER VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR STRING RETURN VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | test = int(input())
for t in range(test):
u, v = map(int, input().split())
if u > v:
print("NO")
continue
k = 0
l = 0
while v > 0:
k += u % 2
l += v % 2
if l > k:
break
u //= 2
v //= 2
if v > 0:
print("NO")
else:
print("YES") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER IF VAR VAR VAR NUMBER VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
There is a new attraction in Singapore Zoo: The Infinite Zoo.
The Infinite Zoo can be represented by a graph with an infinite number of vertices labeled $1,2,3,\ldots$. There is a directed edge from vertex $u$ to vertex $u+v$ if and only if $u\&v=v$, where $\&$ denotes the bitwise AND operation . There are no other edges in the graph.
Zookeeper has $q$ queries. In the $i$-th query she will ask you if she can travel from vertex $u_i$ to vertex $v_i$ by going through directed edges.
-----Input-----
The first line contains an integer $q$ ($1 \leq q \leq 10^5$) — the number of queries.
The $i$-th of the next $q$ lines will contain two integers $u_i$, $v_i$ ($1 \leq u_i, v_i < 2^{30}$) — a query made by Zookeeper.
-----Output-----
For the $i$-th of the $q$ queries, output "YES" in a single line if Zookeeper can travel from vertex $u_i$ to vertex $v_i$. Otherwise, output "NO".
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
-----Examples-----
Input
5
1 4
3 6
1 6
6 2
5 5
Output
YES
YES
NO
NO
YES
-----Note-----
The subgraph on vertices $1,2,3,4,5,6$ is shown below. | q = int(input())
for _ in range(q):
u, v = [int(x) for x in input().split()]
if u > v:
print("NO")
continue
if u == v:
print("YES")
continue
count_u = 0
count_v = 0
fine = True
for i in range(30):
if u & 2**i:
count_u += 1
if v & 2**i:
count_v += 1
if count_v > count_u:
fine = False
print("NO")
break
if fine:
print("YES") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR STRING IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR BIN_OP NUMBER VAR VAR NUMBER IF BIN_OP VAR BIN_OP NUMBER VAR VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER EXPR FUNC_CALL VAR STRING IF VAR EXPR FUNC_CALL VAR STRING |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.