description stringlengths 171 4k | code stringlengths 94 3.98k | normalized_code stringlengths 57 4.99k |
|---|---|---|
Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.
Return the number of permutations of A that are squareful. Two permutations A1 and A2 differ if and only if there is some index i such that A1[i] != A2[i].
Example 1:
Input: [1,17,8]
Output: 2
Explanation:
[1,8,17] and [17,8,1] are the valid permutations.
Example 2:
Input: [2,2,2]
Output: 1
Note:
1 <= A.length <= 12
0 <= A[i] <= 1e9 | class Solution:
def numSquarefulPerms(self, A: List[int]) -> int:
A.sort()
self.ans = 0
def check(A, i, path):
return int((A[i] + path[-1]) ** 0.5 + 0.0) ** 2 == A[i] + path[-1]
def dfs(A, path):
if not A:
self.ans += 1
return
for i in range(len(A)):
if i > 0 and A[i] == A[i - 1]:
continue
if not path or path and check(A, i, path):
dfs(A[:i] + A[i + 1 :], path + [A[i]])
dfs(A, [])
return self.ans | CLASS_DEF FUNC_DEF VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR NUMBER FUNC_DEF RETURN BIN_OP FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER NUMBER NUMBER NUMBER BIN_OP VAR VAR VAR NUMBER FUNC_DEF IF VAR VAR NUMBER RETURN FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER IF VAR VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR LIST VAR VAR EXPR FUNC_CALL VAR VAR LIST RETURN VAR VAR |
Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.
Return the number of permutations of A that are squareful. Two permutations A1 and A2 differ if and only if there is some index i such that A1[i] != A2[i].
Example 1:
Input: [1,17,8]
Output: 2
Explanation:
[1,8,17] and [17,8,1] are the valid permutations.
Example 2:
Input: [2,2,2]
Output: 1
Note:
1 <= A.length <= 12
0 <= A[i] <= 1e9 | class Solution:
def dfs(self, pos):
if pos == self.n:
self.ans += 1
return
last = None
for i, val in enumerate(self.a):
if self.usable[i]:
if val == last:
continue
if pos - 1 >= 0 and val + self.rec[pos - 1] not in self.square:
continue
self.usable[i] = False
self.rec[pos] = val
self.dfs(pos + 1)
self.usable[i] = True
last = val
def numSquarefulPerms(self, A: List[int]) -> int:
self.a = sorted(A)
self.square = set()
i = 0
while i * i <= self.a[-1] * 2:
self.square.add(i * i)
i += 1
self.ans = 0
self.n = len(self.a)
self.usable = [True] * self.n
self.rec = [None] * self.n
self.dfs(0)
return self.ans | CLASS_DEF FUNC_DEF IF VAR VAR VAR NUMBER RETURN ASSIGN VAR NONE FOR VAR VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR IF BIN_OP VAR NUMBER NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR BIN_OP LIST NONE VAR EXPR FUNC_CALL VAR NUMBER RETURN VAR VAR |
Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.
Return the number of permutations of A that are squareful. Two permutations A1 and A2 differ if and only if there is some index i such that A1[i] != A2[i].
Example 1:
Input: [1,17,8]
Output: 2
Explanation:
[1,8,17] and [17,8,1] are the valid permutations.
Example 2:
Input: [2,2,2]
Output: 1
Note:
1 <= A.length <= 12
0 <= A[i] <= 1e9 | class Solution:
def numSquarefulPerms(self, A):
A.sort()
N = len(A)
graph = [([0] * N) for _ in range(N)]
for i in range(N):
for j in range(N):
if i == j:
continue
if int((A[i] + A[j]) ** 0.5) ** 2 == A[i] + A[j]:
graph[i][j] = 1
graph[j][i] = 1
dp = [([0] * N) for i in range(1 << N)]
for i in range(N):
dp[1 << i][i] = 1
for s in range(1 << N):
for i in range(N):
if not dp[s][i]:
continue
for j in range(N):
if not graph[i][j]:
continue
if s & 1 << j:
continue
if j > 0 and s & 1 << j - 1 and A[j] == A[j - 1]:
continue
dp[s | 1 << j][j] += dp[s][i]
ans = 0
for i in range(N):
ans += dp[-1][i]
return ans | CLASS_DEF FUNC_DEF EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR IF BIN_OP FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR VAR NUMBER NUMBER BIN_OP VAR VAR VAR VAR ASSIGN VAR VAR VAR NUMBER ASSIGN VAR VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR VAR FUNC_CALL VAR BIN_OP NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP NUMBER VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP NUMBER VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR IF BIN_OP VAR BIN_OP NUMBER VAR IF VAR NUMBER BIN_OP VAR BIN_OP NUMBER BIN_OP VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR BIN_OP NUMBER VAR VAR VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR VAR NUMBER VAR RETURN VAR |
Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.
Return the number of permutations of A that are squareful. Two permutations A1 and A2 differ if and only if there is some index i such that A1[i] != A2[i].
Example 1:
Input: [1,17,8]
Output: 2
Explanation:
[1,8,17] and [17,8,1] are the valid permutations.
Example 2:
Input: [2,2,2]
Output: 1
Note:
1 <= A.length <= 12
0 <= A[i] <= 1e9 | class Solution:
def numSquarefulPerms(self, A: List[int]) -> int:
d = defaultdict(int)
res = 0
ps = {}
i = 0
while i * i <= 2 * max(A):
ps[i * i] = True
i += 1
def ok(x):
return x in ps
def solve(x):
nonlocal res
if not len(d):
res += 1
return
for k in list(d.keys()):
if not ok(x + k):
continue
d[k] -= 1
if d[k] == 0:
del d[k]
solve(k)
d[k] += 1
for x in A:
d[x] += 1
for k in list(d.keys()):
d[k] -= 1
if not d[k]:
del d[k]
solve(k)
d[k] += 1
return res | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR DICT ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR BIN_OP NUMBER FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR NUMBER VAR NUMBER FUNC_DEF RETURN VAR VAR FUNC_DEF IF FUNC_CALL VAR VAR VAR NUMBER RETURN FOR VAR FUNC_CALL VAR FUNC_CALL VAR IF FUNC_CALL VAR BIN_OP VAR VAR VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR NUMBER FOR VAR VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR NUMBER IF VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR NUMBER RETURN VAR VAR |
Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.
Return the number of permutations of A that are squareful. Two permutations A1 and A2 differ if and only if there is some index i such that A1[i] != A2[i].
Example 1:
Input: [1,17,8]
Output: 2
Explanation:
[1,8,17] and [17,8,1] are the valid permutations.
Example 2:
Input: [2,2,2]
Output: 1
Note:
1 <= A.length <= 12
0 <= A[i] <= 1e9 | def getPermutations(array):
ans = set()
def helper(arr, i, ans):
if i == len(arr) - 1:
ans.add(tuple(arr))
return
for j in range(i, len(arr)):
if not (arr[i] == arr[j] and i != j):
test = i <= 1 or (arr[i - 1] + arr[i - 2]) ** 0.5 == int(
(arr[i - 1] + arr[i - 2]) ** 0.5
)
swap(arr, i, j)
if test:
helper(arr, i + 1, ans)
swap(arr, i, j)
def swap(arr, i, j):
arr[i], arr[j] = arr[j], arr[i]
helper(array, 0, ans)
return ans
class Solution:
def numSquarefulPerms(self, A: List[int]) -> int:
va = getPermutations(A)
valid = 0
for a in va:
isValid = True
for idx in range(1, len(a)):
if (a[idx] + a[idx - 1]) ** 0.5 != int((a[idx] + a[idx - 1]) ** 0.5):
isValid = False
break
if isValid:
valid += 1
return valid | FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_DEF IF VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR RETURN FOR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR NUMBER BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR VAR VAR IF VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR VAR VAR VAR FUNC_DEF ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER VAR RETURN VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR IF BIN_OP BIN_OP VAR VAR VAR BIN_OP VAR NUMBER NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR NUMBER IF VAR VAR NUMBER RETURN VAR VAR |
Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.
Return the number of permutations of A that are squareful. Two permutations A1 and A2 differ if and only if there is some index i such that A1[i] != A2[i].
Example 1:
Input: [1,17,8]
Output: 2
Explanation:
[1,8,17] and [17,8,1] are the valid permutations.
Example 2:
Input: [2,2,2]
Output: 1
Note:
1 <= A.length <= 12
0 <= A[i] <= 1e9 | class Solution:
def numSquarefulPerms(self, A: List[int]) -> int:
A.sort()
n = len(A)
visited = [False] * n
res = []
self.count = 0
def dfs(curr):
if len(curr) == n:
self.count += 1
return
for i in range(n):
if visited[i]:
continue
if i > 0 and A[i] == A[i - 1] and not visited[i - 1]:
continue
if (
len(curr) > 0
and int((curr[-1] + A[i]) ** 0.5) ** 2 != curr[-1] + A[i]
):
continue
visited[i] = True
dfs(curr + [A[i]])
visited[i] = False
dfs([])
return self.count | CLASS_DEF FUNC_DEF VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR LIST ASSIGN VAR NUMBER FUNC_DEF IF FUNC_CALL VAR VAR VAR VAR NUMBER RETURN FOR VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER IF FUNC_CALL VAR VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER VAR VAR NUMBER NUMBER BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR LIST VAR VAR ASSIGN VAR VAR NUMBER EXPR FUNC_CALL VAR LIST RETURN VAR VAR |
Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.
Return the number of permutations of A that are squareful. Two permutations A1 and A2 differ if and only if there is some index i such that A1[i] != A2[i].
Example 1:
Input: [1,17,8]
Output: 2
Explanation:
[1,8,17] and [17,8,1] are the valid permutations.
Example 2:
Input: [2,2,2]
Output: 1
Note:
1 <= A.length <= 12
0 <= A[i] <= 1e9 | class Solution:
def numSquarefulPerms(self, A: List[int]) -> int:
def edge(x, y):
return int((x + y) ** 0.5) ** 2 == x + y
def dfs(x, t):
count[x] -= 1
if t == 0:
ans = 1
else:
ans = 0
for y in graph[x]:
if count[y]:
ans += dfs(y, t - 1)
count[x] += 1
return ans
N = len(A)
count = collections.Counter(A)
graph = collections.defaultdict(list)
for x in count:
for y in count:
if edge(x, y):
graph[x].append(y)
return sum(dfs(x, N - 1) for x in count) | CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF RETURN BIN_OP FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER BIN_OP VAR VAR FUNC_DEF VAR VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR VAR IF VAR VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FOR VAR VAR IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR VAR |
Remember the story of Little Match Girl? By now, you know exactly what matchsticks the little match girl has, please find out a way you can make one square by using up all those matchsticks. You should not break any stick, but you can link them up, and each matchstick must be used exactly one time.
Your input will be several matchsticks the girl has, represented with their stick length. Your output will either be true or false, to represent whether you could make one square using all the matchsticks the little match girl has.
Example 1:
Input: [1,1,2,2,2]
Output: true
Explanation: You can form a square with length 2, one side of the square came two sticks with length 1.
Example 2:
Input: [3,3,3,3,4]
Output: false
Explanation: You cannot find a way to form a square with all the matchsticks.
Note:
The length sum of the given matchsticks is in the range of 0 to 10^9.
The length of the given matchstick array will not exceed 15. | class Solution:
def makesquare(self, nums):
if len(nums) < 4:
return False
length = sum(nums)
if length % 4:
return False
length = int(length / 4)
nums.sort(reverse=True)
if length < nums[0]:
return False
elif length == nums[0]:
stack = list([(set([0]), 1, length, 1)])
else:
stack = list([(set([0]), 1, length - nums[0], 2)])
while stack:
usedSet, startIndex, target, remainRounds = stack.pop()
for i in range(len(nums) - 1, startIndex - 1, -1):
if i in usedSet:
continue
num = nums[i]
if num < target and i + 1 < len(nums):
stack.append((usedSet | {i}, i + 1, target - num, remainRounds))
elif num == target:
if remainRounds == 0:
return True
else:
stack.append((usedSet | {i}, 1, length, remainRounds - 1))
return False | CLASS_DEF FUNC_DEF IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR NUMBER IF VAR VAR NUMBER RETURN NUMBER IF VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR LIST FUNC_CALL VAR LIST NUMBER NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR LIST FUNC_CALL VAR LIST NUMBER NUMBER BIN_OP VAR VAR NUMBER NUMBER WHILE VAR ASSIGN VAR VAR VAR VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER BIN_OP VAR NUMBER NUMBER IF VAR VAR ASSIGN VAR VAR VAR IF VAR VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR IF VAR VAR IF VAR NUMBER RETURN NUMBER EXPR FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR NUMBER RETURN NUMBER |
Remember the story of Little Match Girl? By now, you know exactly what matchsticks the little match girl has, please find out a way you can make one square by using up all those matchsticks. You should not break any stick, but you can link them up, and each matchstick must be used exactly one time.
Your input will be several matchsticks the girl has, represented with their stick length. Your output will either be true or false, to represent whether you could make one square using all the matchsticks the little match girl has.
Example 1:
Input: [1,1,2,2,2]
Output: true
Explanation: You can form a square with length 2, one side of the square came two sticks with length 1.
Example 2:
Input: [3,3,3,3,4]
Output: false
Explanation: You cannot find a way to form a square with all the matchsticks.
Note:
The length sum of the given matchsticks is in the range of 0 to 10^9.
The length of the given matchstick array will not exceed 15. | class Solution:
def makesquare(self, nums):
def checkv(t, c, nums, used):
if t == 0:
return True
if t < 0:
return False
while c < len(nums) and used[c]:
c = c + 1
if c >= len(nums):
return False
if checkv(t - nums[c], c + 1, nums, used):
used[c] = True
return True
if checkv(t, c + 1, nums, used):
return True
return False
edgel = sum(nums)
if edgel % 4 != 0 or edgel == 0:
return False
edgel = edgel / 4
nums.sort(key=lambda x: -x)
n = len(nums)
used = [False] * n
for p in range(3):
t = edgel
if not checkv(t, 0, nums, used):
return False
return True | CLASS_DEF FUNC_DEF FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER WHILE VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER IF VAR FUNC_CALL VAR VAR RETURN NUMBER IF FUNC_CALL VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR NUMBER RETURN NUMBER IF FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER VAR NUMBER RETURN NUMBER ASSIGN VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR IF FUNC_CALL VAR VAR NUMBER VAR VAR RETURN NUMBER RETURN NUMBER |
Remember the story of Little Match Girl? By now, you know exactly what matchsticks the little match girl has, please find out a way you can make one square by using up all those matchsticks. You should not break any stick, but you can link them up, and each matchstick must be used exactly one time.
Your input will be several matchsticks the girl has, represented with their stick length. Your output will either be true or false, to represent whether you could make one square using all the matchsticks the little match girl has.
Example 1:
Input: [1,1,2,2,2]
Output: true
Explanation: You can form a square with length 2, one side of the square came two sticks with length 1.
Example 2:
Input: [3,3,3,3,4]
Output: false
Explanation: You cannot find a way to form a square with all the matchsticks.
Note:
The length sum of the given matchsticks is in the range of 0 to 10^9.
The length of the given matchstick array will not exceed 15. | class Solution:
def makesquare(self, nums):
total = sum(nums)
if total % 4 != 0 or len(nums) < 4:
return False
size = total / 4
nums.sort(reverse=True)
used = [False] * len(nums)
def dfs(i, expect):
if i >= len(nums):
return expect % size == 0
if used[i]:
return dfs(i + 1, expect)
used[i] = True
if nums[i] == expect:
return True
if nums[i] < expect:
expect -= nums[i]
available = [j for j in range(i + 1, len(nums)) if not used[j]]
for x in available:
if dfs(x, expect):
return True
used[i] = False
return False
for i in range(len(nums)):
if not dfs(i, size):
return False
return True | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR IF BIN_OP VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER RETURN NUMBER ASSIGN VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR FUNC_DEF IF VAR FUNC_CALL VAR VAR RETURN BIN_OP VAR VAR NUMBER IF VAR VAR RETURN FUNC_CALL VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR NUMBER IF VAR VAR VAR RETURN NUMBER IF VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR VAR VAR FOR VAR VAR IF FUNC_CALL VAR VAR VAR RETURN NUMBER ASSIGN VAR VAR NUMBER RETURN NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR VAR RETURN NUMBER RETURN NUMBER |
Given a list of words, list of single letters (might be repeating) and score of every character.
Return the maximum score of any valid set of words formed by using the given letters (words[i] cannot be used two or more times).
It is not necessary to use all characters in letters and each letter can only be used once. Score of letters 'a', 'b', 'c', ... ,'z' is given by score[0], score[1], ... , score[25] respectively.
Example 1:
Input: words = ["dog","cat","dad","good"], letters = ["a","a","c","d","d","d","g","o","o"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
Output: 23
Explanation:
Score a=1, c=9, d=5, g=3, o=2
Given letters, we can form the words "dad" (5+1+5) and "good" (3+2+2+5) with a score of 23.
Words "dad" and "dog" only get a score of 21.
Example 2:
Input: words = ["xxxz","ax","bx","cx"], letters = ["z","a","b","c","x","x","x"], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
Output: 27
Explanation:
Score a=4, b=4, c=4, x=5, z=10
Given letters, we can form the words "ax" (4+5), "bx" (4+5) and "cx" (4+5) with a score of 27.
Word "xxxz" only get a score of 25.
Example 3:
Input: words = ["leetcode"], letters = ["l","e","t","c","o","d"], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
Output: 0
Explanation:
Letter "e" can only be used once.
Constraints:
1 <= words.length <= 14
1 <= words[i].length <= 15
1 <= letters.length <= 100
letters[i].length == 1
score.length == 26
0 <= score[i] <= 10
words[i], letters[i] contains only lower case English letters. | class Solution:
def maxScoreWords(
self, words: List[str], letters: List[str], score: List[int]
) -> int:
limit = Counter(letters)
n = len(words)
subsets = []
def back(i, curr):
if i == n:
subsets.append(curr)
return
back(i + 1, curr + words[i])
back(i + 1, curr)
back(0, "")
print(subsets)
ans = 0
def findscore(wo):
freq = Counter(wo)
currscore = 0
for c in freq:
if freq[c] <= limit[c]:
currscore += score[ord(c) - ord("a")] * freq[c]
else:
return 0
return currscore
for x in subsets:
ans = max(ans, findscore(x))
return ans | CLASS_DEF FUNC_DEF VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR LIST FUNC_DEF IF VAR VAR EXPR FUNC_CALL VAR VAR RETURN EXPR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR NUMBER STRING EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR VAR VAR VAR BIN_OP VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR STRING VAR VAR RETURN NUMBER RETURN VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR RETURN VAR VAR |
Given a list of words, list of single letters (might be repeating) and score of every character.
Return the maximum score of any valid set of words formed by using the given letters (words[i] cannot be used two or more times).
It is not necessary to use all characters in letters and each letter can only be used once. Score of letters 'a', 'b', 'c', ... ,'z' is given by score[0], score[1], ... , score[25] respectively.
Example 1:
Input: words = ["dog","cat","dad","good"], letters = ["a","a","c","d","d","d","g","o","o"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
Output: 23
Explanation:
Score a=1, c=9, d=5, g=3, o=2
Given letters, we can form the words "dad" (5+1+5) and "good" (3+2+2+5) with a score of 23.
Words "dad" and "dog" only get a score of 21.
Example 2:
Input: words = ["xxxz","ax","bx","cx"], letters = ["z","a","b","c","x","x","x"], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
Output: 27
Explanation:
Score a=4, b=4, c=4, x=5, z=10
Given letters, we can form the words "ax" (4+5), "bx" (4+5) and "cx" (4+5) with a score of 27.
Word "xxxz" only get a score of 25.
Example 3:
Input: words = ["leetcode"], letters = ["l","e","t","c","o","d"], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
Output: 0
Explanation:
Letter "e" can only be used once.
Constraints:
1 <= words.length <= 14
1 <= words[i].length <= 15
1 <= letters.length <= 100
letters[i].length == 1
score.length == 26
0 <= score[i] <= 10
words[i], letters[i] contains only lower case English letters. | class Solution:
def maxScoreWords(
self, words: List[str], letters: List[str], score: List[int]
) -> int:
res = []
i = 0
letters = collections.Counter(letters)
res = [0]
self.dfs(i, words, letters, score, 0, res)
return res[0]
def dfs(self, i, words, letters, score, current, res):
res[0] = max(res[0], current)
for index in range(i, len(words)):
word = words[index]
cnt = collections.Counter(word)
temp = 0
valid = True
for ch in cnt:
if cnt[ch] > letters[ch]:
valid = False
break
temp += cnt[ch] * score[ord(ch) - ord("a")]
if not valid:
continue
else:
for ch in cnt:
letters[ch] -= cnt[ch]
self.dfs(index + 1, words, letters, score, current + temp, res)
for ch in cnt:
letters[ch] += cnt[ch]
return | CLASS_DEF FUNC_DEF VAR VAR VAR VAR VAR VAR ASSIGN VAR LIST ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR LIST NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR NUMBER VAR RETURN VAR NUMBER VAR FUNC_DEF ASSIGN VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR FOR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR VAR VAR ASSIGN VAR NUMBER VAR BIN_OP VAR VAR VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR STRING IF VAR FOR VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR VAR BIN_OP VAR VAR VAR FOR VAR VAR VAR VAR VAR VAR RETURN |
Given a list of words, list of single letters (might be repeating) and score of every character.
Return the maximum score of any valid set of words formed by using the given letters (words[i] cannot be used two or more times).
It is not necessary to use all characters in letters and each letter can only be used once. Score of letters 'a', 'b', 'c', ... ,'z' is given by score[0], score[1], ... , score[25] respectively.
Example 1:
Input: words = ["dog","cat","dad","good"], letters = ["a","a","c","d","d","d","g","o","o"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
Output: 23
Explanation:
Score a=1, c=9, d=5, g=3, o=2
Given letters, we can form the words "dad" (5+1+5) and "good" (3+2+2+5) with a score of 23.
Words "dad" and "dog" only get a score of 21.
Example 2:
Input: words = ["xxxz","ax","bx","cx"], letters = ["z","a","b","c","x","x","x"], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
Output: 27
Explanation:
Score a=4, b=4, c=4, x=5, z=10
Given letters, we can form the words "ax" (4+5), "bx" (4+5) and "cx" (4+5) with a score of 27.
Word "xxxz" only get a score of 25.
Example 3:
Input: words = ["leetcode"], letters = ["l","e","t","c","o","d"], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
Output: 0
Explanation:
Letter "e" can only be used once.
Constraints:
1 <= words.length <= 14
1 <= words[i].length <= 15
1 <= letters.length <= 100
letters[i].length == 1
score.length == 26
0 <= score[i] <= 10
words[i], letters[i] contains only lower case English letters. | class Solution:
def maxScoreWords(
self, words: List[str], letters: List[str], score: List[int]
) -> int:
let = Counter(letters)
sc = {}
for i in range(26):
sc[chr(i + ord("a"))] = score[i]
word = {}
for w in words:
word[w] = Counter(w)
self.ans = 0
used = []
def run(x, cur, let):
if x == len(words):
return
for i in range(x, len(words)):
if i not in used:
tmp = dict(let)
bx = True
d = 0
for k, v in word[words[i]].items():
if k not in let:
bx = False
break
let[k] -= v
d += sc[k] * v
if let[k] < 0:
bx = False
break
if bx:
used.append(i)
run(i + 1, cur + d, let)
if cur + d > self.ans:
self.ans = max(self.ans, cur + d)
used.pop()
let = tmp
let = tmp
run(0, 0, let)
return self.ans | CLASS_DEF FUNC_DEF VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR FUNC_CALL VAR STRING VAR VAR ASSIGN VAR DICT FOR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR LIST FUNC_DEF IF VAR FUNC_CALL VAR VAR RETURN FOR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR IF VAR VAR ASSIGN VAR NUMBER VAR VAR VAR VAR BIN_OP VAR VAR VAR IF VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR IF BIN_OP VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR VAR ASSIGN VAR VAR EXPR FUNC_CALL VAR NUMBER NUMBER VAR RETURN VAR VAR |
Given a list of words, list of single letters (might be repeating) and score of every character.
Return the maximum score of any valid set of words formed by using the given letters (words[i] cannot be used two or more times).
It is not necessary to use all characters in letters and each letter can only be used once. Score of letters 'a', 'b', 'c', ... ,'z' is given by score[0], score[1], ... , score[25] respectively.
Example 1:
Input: words = ["dog","cat","dad","good"], letters = ["a","a","c","d","d","d","g","o","o"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
Output: 23
Explanation:
Score a=1, c=9, d=5, g=3, o=2
Given letters, we can form the words "dad" (5+1+5) and "good" (3+2+2+5) with a score of 23.
Words "dad" and "dog" only get a score of 21.
Example 2:
Input: words = ["xxxz","ax","bx","cx"], letters = ["z","a","b","c","x","x","x"], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
Output: 27
Explanation:
Score a=4, b=4, c=4, x=5, z=10
Given letters, we can form the words "ax" (4+5), "bx" (4+5) and "cx" (4+5) with a score of 27.
Word "xxxz" only get a score of 25.
Example 3:
Input: words = ["leetcode"], letters = ["l","e","t","c","o","d"], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
Output: 0
Explanation:
Letter "e" can only be used once.
Constraints:
1 <= words.length <= 14
1 <= words[i].length <= 15
1 <= letters.length <= 100
letters[i].length == 1
score.length == 26
0 <= score[i] <= 10
words[i], letters[i] contains only lower case English letters. | class Solution:
def maxScoreWords(
self, words: List[str], letters: List[str], score: List[int]
) -> int:
def letterScore(c):
return score[ord(c) - ord("a")]
def helper(i, remaining, scoreSoFar):
if not remaining or i == len(words):
return scoreSoFar
res = helper(i + 1, remaining, scoreSoFar)
cw = Counter(words[i])
if not cw - remaining:
res = max(
res,
helper(
i + 1,
remaining - cw,
scoreSoFar + sum(map(letterScore, words[i])),
),
)
return res
return helper(0, Counter(letters), 0) | CLASS_DEF FUNC_DEF VAR VAR VAR VAR VAR VAR FUNC_DEF RETURN VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR STRING FUNC_DEF IF VAR VAR FUNC_CALL VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR RETURN FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR |
Given a list of words, list of single letters (might be repeating) and score of every character.
Return the maximum score of any valid set of words formed by using the given letters (words[i] cannot be used two or more times).
It is not necessary to use all characters in letters and each letter can only be used once. Score of letters 'a', 'b', 'c', ... ,'z' is given by score[0], score[1], ... , score[25] respectively.
Example 1:
Input: words = ["dog","cat","dad","good"], letters = ["a","a","c","d","d","d","g","o","o"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
Output: 23
Explanation:
Score a=1, c=9, d=5, g=3, o=2
Given letters, we can form the words "dad" (5+1+5) and "good" (3+2+2+5) with a score of 23.
Words "dad" and "dog" only get a score of 21.
Example 2:
Input: words = ["xxxz","ax","bx","cx"], letters = ["z","a","b","c","x","x","x"], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
Output: 27
Explanation:
Score a=4, b=4, c=4, x=5, z=10
Given letters, we can form the words "ax" (4+5), "bx" (4+5) and "cx" (4+5) with a score of 27.
Word "xxxz" only get a score of 25.
Example 3:
Input: words = ["leetcode"], letters = ["l","e","t","c","o","d"], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
Output: 0
Explanation:
Letter "e" can only be used once.
Constraints:
1 <= words.length <= 14
1 <= words[i].length <= 15
1 <= letters.length <= 100
letters[i].length == 1
score.length == 26
0 <= score[i] <= 10
words[i], letters[i] contains only lower case English letters. | class Solution:
def maxScoreWords(
self, words: List[str], letters: List[str], score: List[int]
) -> int:
max_score = 0
word_limits = Counter(letters)
def helper(curr, chars, curr_words):
nonlocal max_score
if curr >= len(words):
if chars & word_limits == chars:
curr_score = sum([(chars[c] * score[ord(c) - 97]) for c in chars])
max_score = max(max_score, curr_score)
print(chars)
else:
chars += Counter(words[curr])
helper(curr + 1, chars, curr_words + 1)
chars -= Counter(words[curr])
helper(curr + 1, chars, curr_words)
helper(0, Counter(), 0)
return max_score | CLASS_DEF FUNC_DEF VAR VAR VAR VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FUNC_DEF IF VAR FUNC_CALL VAR VAR IF BIN_OP VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR EXPR FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER RETURN VAR VAR |
Given a list of words, list of single letters (might be repeating) and score of every character.
Return the maximum score of any valid set of words formed by using the given letters (words[i] cannot be used two or more times).
It is not necessary to use all characters in letters and each letter can only be used once. Score of letters 'a', 'b', 'c', ... ,'z' is given by score[0], score[1], ... , score[25] respectively.
Example 1:
Input: words = ["dog","cat","dad","good"], letters = ["a","a","c","d","d","d","g","o","o"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
Output: 23
Explanation:
Score a=1, c=9, d=5, g=3, o=2
Given letters, we can form the words "dad" (5+1+5) and "good" (3+2+2+5) with a score of 23.
Words "dad" and "dog" only get a score of 21.
Example 2:
Input: words = ["xxxz","ax","bx","cx"], letters = ["z","a","b","c","x","x","x"], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
Output: 27
Explanation:
Score a=4, b=4, c=4, x=5, z=10
Given letters, we can form the words "ax" (4+5), "bx" (4+5) and "cx" (4+5) with a score of 27.
Word "xxxz" only get a score of 25.
Example 3:
Input: words = ["leetcode"], letters = ["l","e","t","c","o","d"], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
Output: 0
Explanation:
Letter "e" can only be used once.
Constraints:
1 <= words.length <= 14
1 <= words[i].length <= 15
1 <= letters.length <= 100
letters[i].length == 1
score.length == 26
0 <= score[i] <= 10
words[i], letters[i] contains only lower case English letters. | class Solution:
def maxScoreWords(
self, words: List[str], letters: List[str], score: List[int]
) -> int:
lcnt = Counter(letters)
words = [w for w in words if all(Counter(w)[l] <= lcnt[l] for l in w)]
al = "abcdefghijklmnopqrstuvwxyz"
scores = {w: sum(score[al.index(l)] for l in w) for w in words}
costs = {w: Counter(w) for w in words}
score = 0
for i in range(1, len(words) + 1):
for comb in combinations(words, i):
if all(sum(costs[w][l] for w in comb) <= lcnt[l] for l in lcnt):
score = max(score, sum(scores[w] for w in comb))
return score | CLASS_DEF FUNC_DEF VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR STRING ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR IF FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR VAR VAR RETURN VAR VAR |
Given a list of words, list of single letters (might be repeating) and score of every character.
Return the maximum score of any valid set of words formed by using the given letters (words[i] cannot be used two or more times).
It is not necessary to use all characters in letters and each letter can only be used once. Score of letters 'a', 'b', 'c', ... ,'z' is given by score[0], score[1], ... , score[25] respectively.
Example 1:
Input: words = ["dog","cat","dad","good"], letters = ["a","a","c","d","d","d","g","o","o"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
Output: 23
Explanation:
Score a=1, c=9, d=5, g=3, o=2
Given letters, we can form the words "dad" (5+1+5) and "good" (3+2+2+5) with a score of 23.
Words "dad" and "dog" only get a score of 21.
Example 2:
Input: words = ["xxxz","ax","bx","cx"], letters = ["z","a","b","c","x","x","x"], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
Output: 27
Explanation:
Score a=4, b=4, c=4, x=5, z=10
Given letters, we can form the words "ax" (4+5), "bx" (4+5) and "cx" (4+5) with a score of 27.
Word "xxxz" only get a score of 25.
Example 3:
Input: words = ["leetcode"], letters = ["l","e","t","c","o","d"], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
Output: 0
Explanation:
Letter "e" can only be used once.
Constraints:
1 <= words.length <= 14
1 <= words[i].length <= 15
1 <= letters.length <= 100
letters[i].length == 1
score.length == 26
0 <= score[i] <= 10
words[i], letters[i] contains only lower case English letters. | class Solution:
def maxScoreWords(
self, words: List[str], letters: List[str], score: List[int]
) -> int:
def solve(idx, counter):
if idx == len(words):
return 0
wc = collections.Counter(words[idx])
if all(counter[key] >= wc[key] for key in wc):
ans = max(
sum(score[ord(c) - ord("a")] for c in words[idx])
+ solve(idx + 1, counter - wc),
solve(idx + 1, counter),
)
else:
ans = solve(idx + 1, counter)
return ans
return solve(0, collections.Counter(letters)) | CLASS_DEF FUNC_DEF VAR VAR VAR VAR VAR VAR FUNC_DEF IF VAR FUNC_CALL VAR VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR IF FUNC_CALL VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR STRING VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR RETURN VAR RETURN FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR VAR |
Given a list of words, list of single letters (might be repeating) and score of every character.
Return the maximum score of any valid set of words formed by using the given letters (words[i] cannot be used two or more times).
It is not necessary to use all characters in letters and each letter can only be used once. Score of letters 'a', 'b', 'c', ... ,'z' is given by score[0], score[1], ... , score[25] respectively.
Example 1:
Input: words = ["dog","cat","dad","good"], letters = ["a","a","c","d","d","d","g","o","o"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
Output: 23
Explanation:
Score a=1, c=9, d=5, g=3, o=2
Given letters, we can form the words "dad" (5+1+5) and "good" (3+2+2+5) with a score of 23.
Words "dad" and "dog" only get a score of 21.
Example 2:
Input: words = ["xxxz","ax","bx","cx"], letters = ["z","a","b","c","x","x","x"], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
Output: 27
Explanation:
Score a=4, b=4, c=4, x=5, z=10
Given letters, we can form the words "ax" (4+5), "bx" (4+5) and "cx" (4+5) with a score of 27.
Word "xxxz" only get a score of 25.
Example 3:
Input: words = ["leetcode"], letters = ["l","e","t","c","o","d"], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
Output: 0
Explanation:
Letter "e" can only be used once.
Constraints:
1 <= words.length <= 14
1 <= words[i].length <= 15
1 <= letters.length <= 100
letters[i].length == 1
score.length == 26
0 <= score[i] <= 10
words[i], letters[i] contains only lower case English letters. | class Solution:
def maxScoreWords(
self, words: List[str], letters: List[str], score: List[int]
) -> int:
lettersCounter = collections.Counter(letters)
scoreDict = {
letter: score for letter, score in zip("abcdefghijklmnopqrstuvwxyz", score)
}
self.cache = [{} for i in range(len(words))]
return self.backtracking(words, 0, lettersCounter, scoreDict)
def backtracking(self, words, cur, remainLC, scoreDict):
if cur >= len(words):
return 0
signature = tuple((key, remainLC[key]) for key in sorted(remainLC))
if signature in self.cache[cur]:
return self.cache[cur][signature]
notChoose = self.backtracking(words, cur + 1, remainLC, scoreDict)
wc = collections.Counter(words[cur])
if any(remainLC[w] < wc[w] for w in wc.keys()):
return notChoose
diff = remainLC - wc
curScore = sum(scoreDict[ch] for ch in words[cur])
choose = self.backtracking(words, cur + 1, diff, scoreDict)
ans = max(curScore + choose, notChoose)
self.cache[cur][signature] = ans
return ans | CLASS_DEF FUNC_DEF VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR FUNC_CALL VAR STRING VAR ASSIGN VAR DICT VAR FUNC_CALL VAR FUNC_CALL VAR VAR RETURN FUNC_CALL VAR VAR NUMBER VAR VAR VAR FUNC_DEF IF VAR FUNC_CALL VAR VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR FUNC_CALL VAR VAR IF VAR VAR VAR RETURN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF FUNC_CALL VAR VAR VAR VAR VAR VAR FUNC_CALL VAR RETURN VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR VAR ASSIGN VAR VAR VAR VAR RETURN VAR |
Given a list of words, list of single letters (might be repeating) and score of every character.
Return the maximum score of any valid set of words formed by using the given letters (words[i] cannot be used two or more times).
It is not necessary to use all characters in letters and each letter can only be used once. Score of letters 'a', 'b', 'c', ... ,'z' is given by score[0], score[1], ... , score[25] respectively.
Example 1:
Input: words = ["dog","cat","dad","good"], letters = ["a","a","c","d","d","d","g","o","o"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
Output: 23
Explanation:
Score a=1, c=9, d=5, g=3, o=2
Given letters, we can form the words "dad" (5+1+5) and "good" (3+2+2+5) with a score of 23.
Words "dad" and "dog" only get a score of 21.
Example 2:
Input: words = ["xxxz","ax","bx","cx"], letters = ["z","a","b","c","x","x","x"], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
Output: 27
Explanation:
Score a=4, b=4, c=4, x=5, z=10
Given letters, we can form the words "ax" (4+5), "bx" (4+5) and "cx" (4+5) with a score of 27.
Word "xxxz" only get a score of 25.
Example 3:
Input: words = ["leetcode"], letters = ["l","e","t","c","o","d"], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
Output: 0
Explanation:
Letter "e" can only be used once.
Constraints:
1 <= words.length <= 14
1 <= words[i].length <= 15
1 <= letters.length <= 100
letters[i].length == 1
score.length == 26
0 <= score[i] <= 10
words[i], letters[i] contains only lower case English letters. | class Solution:
def maxScoreWords(
self, words: List[str], letters: List[str], score: List[int]
) -> int:
n = len(words)
m = len(letters)
letters = collections.Counter(letters)
ans = 0
for i in range(1, n + 1):
combinations = list(itertools.combinations(words, i))
for combine in combinations:
tempScore = self.calculateScore("".join(combine), letters, score)
ans = max(tempScore, ans)
return ans
def calculateScore(self, s, letters, score):
counter = collections.Counter(s)
ans = 0
for ch in counter:
if counter[ch] > letters[ch]:
return float("-inf")
ans += counter[ch] * score[ord(ch) - ord("a")]
return ans | CLASS_DEF FUNC_DEF VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL STRING VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR VAR VAR RETURN FUNC_CALL VAR STRING VAR BIN_OP VAR VAR VAR BIN_OP FUNC_CALL VAR VAR FUNC_CALL VAR STRING RETURN VAR |
In LeetCode Store, there are some kinds of items to sell. Each item has a price.
However, there are some special offers, and a special offer consists of one or more different kinds of items with a sale price.
You are given the each item's price, a set of special offers, and the number we need to buy for each item.
The job is to output the lowest price you have to pay for exactly certain items as given, where you could make optimal use of the special offers.
Each special offer is represented in the form of an array, the last number represents the price you need to pay for this special offer, other numbers represents how many specific items you could get if you buy this offer.
You could use any of special offers as many times as you want.
Example 1:
Input: [2,5], [[3,0,5],[1,2,10]], [3,2]
Output: 14
Explanation:
There are two kinds of items, A and B. Their prices are $2 and $5 respectively.
In special offer 1, you can pay $5 for 3A and 0B
In special offer 2, you can pay $10 for 1A and 2B.
You need to buy 3A and 2B, so you may pay $10 for 1A and 2B (special offer #2), and $4 for 2A.
Example 2:
Input: [2,3,4], [[1,1,0,4],[2,2,1,9]], [1,2,1]
Output: 11
Explanation:
The price of A is $2, and $3 for B, $4 for C.
You may pay $4 for 1A and 1B, and $9 for 2A ,2B and 1C.
You need to buy 1A ,2B and 1C, so you may pay $4 for 1A and 1B (special offer #1), and $3 for 1B, $4 for 1C.
You cannot add more items, though only $9 for 2A ,2B and 1C.
Note:
There are at most 6 kinds of items, 100 special offers.
For each item, you need to buy at most 6 of them.
You are not allowed to buy more items than you want, even if that would lower the overall price. | class Solution:
def shoppingOffers(self, price, special, needs):
d = {}
n = len(needs)
def minp(needs, d):
if str(needs) in d:
return d[str(needs)]
res = 0
for i in range(n):
res += price[i] * needs[i]
for s in special:
for i in range(n):
if s[i] > needs[i]:
break
else:
need2 = []
for i in range(n):
need2.append(needs[i] - s[i])
res = min(res, minp(need2, d) + s[-1])
d[str(needs)] = res
return res
return minp(needs, d) | CLASS_DEF FUNC_DEF ASSIGN VAR DICT ASSIGN VAR FUNC_CALL VAR VAR FUNC_DEF IF FUNC_CALL VAR VAR VAR RETURN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR BIN_OP VAR VAR VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP FUNC_CALL VAR VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR RETURN VAR RETURN FUNC_CALL VAR VAR VAR |
In LeetCode Store, there are some kinds of items to sell. Each item has a price.
However, there are some special offers, and a special offer consists of one or more different kinds of items with a sale price.
You are given the each item's price, a set of special offers, and the number we need to buy for each item.
The job is to output the lowest price you have to pay for exactly certain items as given, where you could make optimal use of the special offers.
Each special offer is represented in the form of an array, the last number represents the price you need to pay for this special offer, other numbers represents how many specific items you could get if you buy this offer.
You could use any of special offers as many times as you want.
Example 1:
Input: [2,5], [[3,0,5],[1,2,10]], [3,2]
Output: 14
Explanation:
There are two kinds of items, A and B. Their prices are $2 and $5 respectively.
In special offer 1, you can pay $5 for 3A and 0B
In special offer 2, you can pay $10 for 1A and 2B.
You need to buy 3A and 2B, so you may pay $10 for 1A and 2B (special offer #2), and $4 for 2A.
Example 2:
Input: [2,3,4], [[1,1,0,4],[2,2,1,9]], [1,2,1]
Output: 11
Explanation:
The price of A is $2, and $3 for B, $4 for C.
You may pay $4 for 1A and 1B, and $9 for 2A ,2B and 1C.
You need to buy 1A ,2B and 1C, so you may pay $4 for 1A and 1B (special offer #1), and $3 for 1B, $4 for 1C.
You cannot add more items, though only $9 for 2A ,2B and 1C.
Note:
There are at most 6 kinds of items, 100 special offers.
For each item, you need to buy at most 6 of them.
You are not allowed to buy more items than you want, even if that would lower the overall price. | class Solution:
def shoppingOffers(self, price, special, needs):
res = 0
for pric, need in zip(price, needs):
res += pric * need
for offer in special:
clone = list(needs)
i = 0
while i < len(needs):
diff = clone[i] - offer[i]
if diff < 0:
break
clone[i] = diff
i += 1
if i == len(needs):
res = min(res, offer[-1] + self.shoppingOffers(price, special, clone))
return res | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR IF VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER IF VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR VAR VAR RETURN VAR |
In LeetCode Store, there are some kinds of items to sell. Each item has a price.
However, there are some special offers, and a special offer consists of one or more different kinds of items with a sale price.
You are given the each item's price, a set of special offers, and the number we need to buy for each item.
The job is to output the lowest price you have to pay for exactly certain items as given, where you could make optimal use of the special offers.
Each special offer is represented in the form of an array, the last number represents the price you need to pay for this special offer, other numbers represents how many specific items you could get if you buy this offer.
You could use any of special offers as many times as you want.
Example 1:
Input: [2,5], [[3,0,5],[1,2,10]], [3,2]
Output: 14
Explanation:
There are two kinds of items, A and B. Their prices are $2 and $5 respectively.
In special offer 1, you can pay $5 for 3A and 0B
In special offer 2, you can pay $10 for 1A and 2B.
You need to buy 3A and 2B, so you may pay $10 for 1A and 2B (special offer #2), and $4 for 2A.
Example 2:
Input: [2,3,4], [[1,1,0,4],[2,2,1,9]], [1,2,1]
Output: 11
Explanation:
The price of A is $2, and $3 for B, $4 for C.
You may pay $4 for 1A and 1B, and $9 for 2A ,2B and 1C.
You need to buy 1A ,2B and 1C, so you may pay $4 for 1A and 1B (special offer #1), and $3 for 1B, $4 for 1C.
You cannot add more items, though only $9 for 2A ,2B and 1C.
Note:
There are at most 6 kinds of items, 100 special offers.
For each item, you need to buy at most 6 of them.
You are not allowed to buy more items than you want, even if that would lower the overall price. | class Solution:
def shoppingOffers(self, price, special, needs):
a = 0
n = len(needs)
for i in range(n):
a += needs[i] * price[i]
for s in special:
new_needs = needs.copy()
check = True
for i in range(n):
new_needs[i] = new_needs[i] - s[i]
if new_needs[i] < 0:
check = False
break
if check:
a = min(a, s[n] + self.shoppingOffers(price, special, new_needs))
return a | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR VAR BIN_OP VAR VAR VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR VAR IF VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR |
In LeetCode Store, there are some kinds of items to sell. Each item has a price.
However, there are some special offers, and a special offer consists of one or more different kinds of items with a sale price.
You are given the each item's price, a set of special offers, and the number we need to buy for each item.
The job is to output the lowest price you have to pay for exactly certain items as given, where you could make optimal use of the special offers.
Each special offer is represented in the form of an array, the last number represents the price you need to pay for this special offer, other numbers represents how many specific items you could get if you buy this offer.
You could use any of special offers as many times as you want.
Example 1:
Input: [2,5], [[3,0,5],[1,2,10]], [3,2]
Output: 14
Explanation:
There are two kinds of items, A and B. Their prices are $2 and $5 respectively.
In special offer 1, you can pay $5 for 3A and 0B
In special offer 2, you can pay $10 for 1A and 2B.
You need to buy 3A and 2B, so you may pay $10 for 1A and 2B (special offer #2), and $4 for 2A.
Example 2:
Input: [2,3,4], [[1,1,0,4],[2,2,1,9]], [1,2,1]
Output: 11
Explanation:
The price of A is $2, and $3 for B, $4 for C.
You may pay $4 for 1A and 1B, and $9 for 2A ,2B and 1C.
You need to buy 1A ,2B and 1C, so you may pay $4 for 1A and 1B (special offer #1), and $3 for 1B, $4 for 1C.
You cannot add more items, though only $9 for 2A ,2B and 1C.
Note:
There are at most 6 kinds of items, 100 special offers.
For each item, you need to buy at most 6 of them.
You are not allowed to buy more items than you want, even if that would lower the overall price. | class Solution:
def shoppingOffers(self, price, special, needs):
def directPurchase(price, needs):
total = 0
for i in range(len(needs)):
total += price[i] * needs[i]
return total
def dfs(price, special, needs, index):
local_min = directPurchase(price, needs)
for i in range(index, len(special)):
offer = special[i]
temp = []
for j in range(len(needs)):
if needs[j] < offer[j]:
temp = []
break
else:
temp.append(needs[j] - offer[j])
if temp != []:
local_min = min(local_min, offer[-1] + dfs(price, special, temp, i))
return local_min
return dfs(price, special, needs, 0) | CLASS_DEF FUNC_DEF FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR BIN_OP VAR VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR ASSIGN VAR LIST EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR VAR IF VAR LIST ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR VAR VAR VAR RETURN VAR RETURN FUNC_CALL VAR VAR VAR VAR NUMBER |
In LeetCode Store, there are some kinds of items to sell. Each item has a price.
However, there are some special offers, and a special offer consists of one or more different kinds of items with a sale price.
You are given the each item's price, a set of special offers, and the number we need to buy for each item.
The job is to output the lowest price you have to pay for exactly certain items as given, where you could make optimal use of the special offers.
Each special offer is represented in the form of an array, the last number represents the price you need to pay for this special offer, other numbers represents how many specific items you could get if you buy this offer.
You could use any of special offers as many times as you want.
Example 1:
Input: [2,5], [[3,0,5],[1,2,10]], [3,2]
Output: 14
Explanation:
There are two kinds of items, A and B. Their prices are $2 and $5 respectively.
In special offer 1, you can pay $5 for 3A and 0B
In special offer 2, you can pay $10 for 1A and 2B.
You need to buy 3A and 2B, so you may pay $10 for 1A and 2B (special offer #2), and $4 for 2A.
Example 2:
Input: [2,3,4], [[1,1,0,4],[2,2,1,9]], [1,2,1]
Output: 11
Explanation:
The price of A is $2, and $3 for B, $4 for C.
You may pay $4 for 1A and 1B, and $9 for 2A ,2B and 1C.
You need to buy 1A ,2B and 1C, so you may pay $4 for 1A and 1B (special offer #1), and $3 for 1B, $4 for 1C.
You cannot add more items, though only $9 for 2A ,2B and 1C.
Note:
There are at most 6 kinds of items, 100 special offers.
For each item, you need to buy at most 6 of them.
You are not allowed to buy more items than you want, even if that would lower the overall price. | class Solution:
def shoppingOffers(self, rps, sos, tq):
if len(sos) < 1:
return sum([(x * y) for x, y in zip(rps, tq)])
so = sos.pop()
m = self.shoppingOffers(rps, sos, tq)
ss = so[:]
while all([(x <= y) for x, y in zip(ss, tq)]):
rq = [(x - y) for x, y in zip(tq, ss)]
m = min(m, ss[-1] + self.shoppingOffers(rps, sos, rq))
ss = [(x + y) for x, y in zip(ss, so)]
sos.append(so)
return m | CLASS_DEF FUNC_DEF IF FUNC_CALL VAR VAR NUMBER RETURN FUNC_CALL VAR BIN_OP VAR VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR WHILE FUNC_CALL VAR VAR VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR RETURN VAR |
In LeetCode Store, there are some kinds of items to sell. Each item has a price.
However, there are some special offers, and a special offer consists of one or more different kinds of items with a sale price.
You are given the each item's price, a set of special offers, and the number we need to buy for each item.
The job is to output the lowest price you have to pay for exactly certain items as given, where you could make optimal use of the special offers.
Each special offer is represented in the form of an array, the last number represents the price you need to pay for this special offer, other numbers represents how many specific items you could get if you buy this offer.
You could use any of special offers as many times as you want.
Example 1:
Input: [2,5], [[3,0,5],[1,2,10]], [3,2]
Output: 14
Explanation:
There are two kinds of items, A and B. Their prices are $2 and $5 respectively.
In special offer 1, you can pay $5 for 3A and 0B
In special offer 2, you can pay $10 for 1A and 2B.
You need to buy 3A and 2B, so you may pay $10 for 1A and 2B (special offer #2), and $4 for 2A.
Example 2:
Input: [2,3,4], [[1,1,0,4],[2,2,1,9]], [1,2,1]
Output: 11
Explanation:
The price of A is $2, and $3 for B, $4 for C.
You may pay $4 for 1A and 1B, and $9 for 2A ,2B and 1C.
You need to buy 1A ,2B and 1C, so you may pay $4 for 1A and 1B (special offer #1), and $3 for 1B, $4 for 1C.
You cannot add more items, though only $9 for 2A ,2B and 1C.
Note:
There are at most 6 kinds of items, 100 special offers.
For each item, you need to buy at most 6 of them.
You are not allowed to buy more items than you want, even if that would lower the overall price. | class Solution:
def shoppingOffers(self, price, special, needs):
def dfs(curr, special, needs):
p = curr + sum(p * needs[i] for i, p in enumerate(price))
for si in range(len(special)):
s = special[si]
if all(n >= s[i] for i, n in enumerate(needs)):
p = min(
p,
dfs(
curr + s[-1],
special[si:],
[(n - s[i]) for i, n in enumerate(needs)],
),
)
return p
return dfs(0, special, needs) | CLASS_DEF FUNC_DEF FUNC_DEF ASSIGN VAR BIN_OP VAR FUNC_CALL VAR BIN_OP VAR VAR VAR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR IF FUNC_CALL VAR VAR VAR VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR VAR BIN_OP VAR VAR VAR VAR VAR FUNC_CALL VAR VAR RETURN VAR RETURN FUNC_CALL VAR NUMBER VAR VAR |
Suppose you have N integers from 1 to N. We define a beautiful arrangement as an array that is constructed by these N numbers successfully if one of the following is true for the ith position (1
The number at the ith position is divisible by i.
i is divisible by the number at the ith position.
Now given N, how many beautiful arrangements can you construct?
Example 1:
Input: 2
Output: 2
Explanation:
The first beautiful arrangement is [1, 2]:
Number at the 1st position (i=1) is 1, and 1 is divisible by i (i=1).
Number at the 2nd position (i=2) is 2, and 2 is divisible by i (i=2).
The second beautiful arrangement is [2, 1]:
Number at the 1st position (i=1) is 2, and 2 is divisible by i (i=1).
Number at the 2nd position (i=2) is 1, and i (i=2) is divisible by 1.
Note:
N is a positive integer and will not exceed 15. | class Solution:
def countArrangement(self, N):
cache = {}
def helper(i, X):
if i == 1:
return 1
key = i, X
if key in cache:
return cache[key]
total = sum(
helper(i - 1, X[:j] + X[j + 1 :])
for j, x in enumerate(X)
if x % i == 0 or i % x == 0
)
cache[key] = total
return total
return helper(N, tuple(range(1, N + 1))) | CLASS_DEF FUNC_DEF ASSIGN VAR DICT FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR VAR VAR IF VAR VAR RETURN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR BIN_OP VAR NUMBER VAR VAR FUNC_CALL VAR VAR BIN_OP VAR VAR NUMBER BIN_OP VAR VAR NUMBER ASSIGN VAR VAR VAR RETURN VAR RETURN FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER |
Suppose you have N integers from 1 to N. We define a beautiful arrangement as an array that is constructed by these N numbers successfully if one of the following is true for the ith position (1
The number at the ith position is divisible by i.
i is divisible by the number at the ith position.
Now given N, how many beautiful arrangements can you construct?
Example 1:
Input: 2
Output: 2
Explanation:
The first beautiful arrangement is [1, 2]:
Number at the 1st position (i=1) is 1, and 1 is divisible by i (i=1).
Number at the 2nd position (i=2) is 2, and 2 is divisible by i (i=2).
The second beautiful arrangement is [2, 1]:
Number at the 1st position (i=1) is 2, and 2 is divisible by i (i=1).
Number at the 2nd position (i=2) is 1, and i (i=2) is divisible by 1.
Note:
N is a positive integer and will not exceed 15. | class Solution:
def __init__(self):
self._cache = {}
def countArrangement(self, N):
return self.countHelper(N, tuple(range(1, N + 1)))
def countHelper(self, i, array):
if i == 1:
return 1
key = i, array
if key in self._cache:
return self._cache[key]
total = 0
for j in range(len(array)):
if array[j] % i == 0 or i % array[j] == 0:
total += self.countHelper(i - 1, array[:j] + array[j + 1 :])
self._cache[key] = total
return total | CLASS_DEF FUNC_DEF ASSIGN VAR DICT FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FUNC_DEF IF VAR NUMBER RETURN NUMBER ASSIGN VAR VAR VAR IF VAR VAR RETURN VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF BIN_OP VAR VAR VAR NUMBER BIN_OP VAR VAR VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR RETURN VAR |
Suppose you have N integers from 1 to N. We define a beautiful arrangement as an array that is constructed by these N numbers successfully if one of the following is true for the ith position (1
The number at the ith position is divisible by i.
i is divisible by the number at the ith position.
Now given N, how many beautiful arrangements can you construct?
Example 1:
Input: 2
Output: 2
Explanation:
The first beautiful arrangement is [1, 2]:
Number at the 1st position (i=1) is 1, and 1 is divisible by i (i=1).
Number at the 2nd position (i=2) is 2, and 2 is divisible by i (i=2).
The second beautiful arrangement is [2, 1]:
Number at the 1st position (i=1) is 2, and 2 is divisible by i (i=1).
Number at the 2nd position (i=2) is 1, and i (i=2) is divisible by 1.
Note:
N is a positive integer and will not exceed 15. | class Solution:
def countArrangement(self, N):
return (1, 2, 3, 8, 10, 36, 41, 132, 250, 700, 750, 4010, 4237, 10680, 24679)[
N - 1
] | CLASS_DEF FUNC_DEF RETURN NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER BIN_OP VAR NUMBER |
Suppose you have N integers from 1 to N. We define a beautiful arrangement as an array that is constructed by these N numbers successfully if one of the following is true for the ith position (1
The number at the ith position is divisible by i.
i is divisible by the number at the ith position.
Now given N, how many beautiful arrangements can you construct?
Example 1:
Input: 2
Output: 2
Explanation:
The first beautiful arrangement is [1, 2]:
Number at the 1st position (i=1) is 1, and 1 is divisible by i (i=1).
Number at the 2nd position (i=2) is 2, and 2 is divisible by i (i=2).
The second beautiful arrangement is [2, 1]:
Number at the 1st position (i=1) is 2, and 2 is divisible by i (i=1).
Number at the 2nd position (i=2) is 1, and i (i=2) is divisible by 1.
Note:
N is a positive integer and will not exceed 15. | class Solution:
def countArrangement(self, N):
d = {
(1): 1,
(2): 2,
(3): 3,
(4): 8,
(5): 10,
(6): 36,
(7): 41,
(8): 132,
(9): 250,
(10): 700,
(11): 750,
(12): 4010,
(13): 4237,
(14): 10680,
(15): 24679,
}
return d.get(N, N) | CLASS_DEF FUNC_DEF ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER RETURN FUNC_CALL VAR VAR VAR |
A bracket sequence is a string containing only characters "(" and ")". A regular bracket sequence (or, shortly, an RBS) is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example:
* bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)");
* bracket sequences ")(", "(" and ")" are not.
Let's denote the concatenation of two strings x and y as x+y. For example, "()()" + ")(" = "()())(".
You are given n bracket sequences s_1, s_2, ..., s_n. You can rearrange them in any order (you can rearrange only the strings themselves, but not the characters in them).
Your task is to rearrange the strings in such a way that the string s_1 + s_2 + ... + s_n has as many non-empty prefixes that are RBS as possible.
Input
The first line contains a single integer n (1 ≤ n ≤ 20).
Then n lines follow, the i-th of them contains s_i — a bracket sequence (a string consisting of characters "(" and/or ")". All sequences s_i are non-empty, their total length does not exceed 4 ⋅ 10^5.
Output
Print one integer — the maximum number of non-empty prefixes that are RBS for the string s_1 + s_2 + ... + s_n, if the strings s_1, s_2, ..., s_n can be rearranged arbitrarily.
Examples
Input
2
(
)
Output
1
Input
4
()()())
(
(
)
Output
4
Input
1
(())
Output
1
Input
1
)(()
Output
0
Note
In the first example, you can concatenate the strings as follows: "(" + ")" = "()", the resulting string will have one prefix, that is an RBS: "()".
In the second example, you can concatenate the strings as follows: "(" + ")" + "()()())" + "(" = "()()()())(", the resulting string will have four prefixes that are RBS: "()", "()()", "()()()", "()()()()".
The third and the fourth examples contain only one string each, so the order is fixed. | import sys
from sys import stdin
n = int(stdin.readline())
s = [list(stdin.readline()[:-1]) for i in range(n)]
smin = [0] * n
smnum = [0] * n
h = [0] * n
cnts = [{} for i in range(n)]
for i in range(n):
ts = s[i]
nmin = 0
nh = 0
for c in ts:
if c == "(":
nh += 1
else:
nh -= 1
if smin[i] > nh:
smin[i] = nh
smnum[i] = 0
if smin[i] == nh:
smnum[i] += 1
if nh == smin[i]:
if nh not in cnts[i]:
cnts[i][nh] = 0
cnts[i][nh] += 1
h[i] = nh
dp = [float("-inf")] * 2**n
dp[0] = 0
ans = 0
for i in range(2**n):
nh = 0
for j in range(n):
if 2**j & i > 0:
nh += h[j]
for j in range(n):
if 2**j & i == 0 and nh + smin[j] >= 0:
if nh + smin[j] == 0:
dp[2**j | i] = max(dp[2**j | i], dp[i] + smnum[j])
else:
dp[2**j | i] = max(dp[2**j | i], dp[i])
elif 2**j & i == 0 and -1 * nh in cnts[j]:
ans = max(ans, dp[i] + cnts[j][-1 * nh])
ans = max(ans, max(dp))
print(ans) | IMPORT ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR DICT VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR STRING VAR NUMBER VAR NUMBER IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR NUMBER IF VAR VAR VAR VAR VAR NUMBER IF VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR NUMBER VAR VAR VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP LIST FUNC_CALL VAR STRING BIN_OP NUMBER VAR ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP NUMBER VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF BIN_OP BIN_OP NUMBER VAR VAR NUMBER VAR VAR VAR FOR VAR FUNC_CALL VAR VAR IF BIN_OP BIN_OP NUMBER VAR VAR NUMBER BIN_OP VAR VAR VAR NUMBER IF BIN_OP VAR VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP NUMBER VAR VAR FUNC_CALL VAR VAR BIN_OP BIN_OP NUMBER VAR VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR BIN_OP BIN_OP NUMBER VAR VAR FUNC_CALL VAR VAR BIN_OP BIN_OP NUMBER VAR VAR VAR VAR IF BIN_OP BIN_OP NUMBER VAR VAR NUMBER BIN_OP NUMBER VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR VAR VAR BIN_OP NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR |
A bracket sequence is a string containing only characters "(" and ")". A regular bracket sequence (or, shortly, an RBS) is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example:
* bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)");
* bracket sequences ")(", "(" and ")" are not.
Let's denote the concatenation of two strings x and y as x+y. For example, "()()" + ")(" = "()())(".
You are given n bracket sequences s_1, s_2, ..., s_n. You can rearrange them in any order (you can rearrange only the strings themselves, but not the characters in them).
Your task is to rearrange the strings in such a way that the string s_1 + s_2 + ... + s_n has as many non-empty prefixes that are RBS as possible.
Input
The first line contains a single integer n (1 ≤ n ≤ 20).
Then n lines follow, the i-th of them contains s_i — a bracket sequence (a string consisting of characters "(" and/or ")". All sequences s_i are non-empty, their total length does not exceed 4 ⋅ 10^5.
Output
Print one integer — the maximum number of non-empty prefixes that are RBS for the string s_1 + s_2 + ... + s_n, if the strings s_1, s_2, ..., s_n can be rearranged arbitrarily.
Examples
Input
2
(
)
Output
1
Input
4
()()())
(
(
)
Output
4
Input
1
(())
Output
1
Input
1
)(()
Output
0
Note
In the first example, you can concatenate the strings as follows: "(" + ")" = "()", the resulting string will have one prefix, that is an RBS: "()".
In the second example, you can concatenate the strings as follows: "(" + ")" + "()()())" + "(" = "()()()())(", the resulting string will have four prefixes that are RBS: "()", "()()", "()()()", "()()()()".
The third and the fourth examples contain only one string each, so the order is fixed. | def solve():
n = int(input())
a = [[0] for i in range(n)]
mb = [0] * (1 << n)
for i in range(n):
s = input().strip()
m = 0
b = 0
for c in s:
if c == "(":
b += 1
else:
b -= 1
if b <= 0:
if m > b:
m = b
a[i].append(1)
elif m == b:
a[i][-1] += 1
mb[1 << i] = b
dp = [-1000000000] * (1 << n)
dp[0] = 0
ans = 0
for i in range(1, 1 << n):
j = i & i - 1
if j:
mb[i] = mb[i - j] + mb[j]
nd = -1000000000
for j in range(n):
if i >> j & 1:
d = dp[i - (1 << j)]
if d >= 0:
bb = mb[i - (1 << j)]
m = len(a[j]) - 1
if bb - m < 0:
ans = max(ans, a[j][bb] + d)
else:
nd = max(nd, (a[j][-1] if bb - m == 0 else 0) + d)
ans = max(ans, nd)
dp[i] = nd
print(ans)
solve() | FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR STRING VAR NUMBER VAR NUMBER IF VAR NUMBER IF VAR VAR ASSIGN VAR VAR EXPR FUNC_CALL VAR VAR NUMBER IF VAR VAR VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP NUMBER VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP NUMBER VAR ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER VAR ASSIGN VAR BIN_OP VAR BIN_OP VAR NUMBER IF VAR ASSIGN VAR VAR BIN_OP VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR VAR BIN_OP VAR BIN_OP NUMBER VAR IF VAR NUMBER ASSIGN VAR VAR BIN_OP VAR BIN_OP NUMBER VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR VAR NUMBER VAR VAR NUMBER NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def shouldntwe(vals, wanted):
d = {}
def shouldwe(indx, wanted):
if (indx, wanted) in d:
return d[indx, wanted]
if indx == 0:
if wanted - vals[indx] == 0:
return 1
else:
return 0
if wanted == 0:
return 1
nitch_there = shouldwe(indx - 1, wanted)
ist_there = 0
if wanted >= vals[indx]:
ist_there = shouldwe(indx - 1, wanted - vals[indx])
d[indx, wanted] = nitch_there or ist_there
return d[indx, wanted]
return shouldwe(len(vals) - 1, wanted)
t = int(input())
for abc in range(t):
n, m = map(int, input().split())
notes = [int(input()) for inp in range(n)]
if shouldntwe(notes, m):
print("Yes")
else:
print("No") | FUNC_DEF ASSIGN VAR DICT FUNC_DEF IF VAR VAR VAR RETURN VAR VAR VAR IF VAR NUMBER IF BIN_OP VAR VAR VAR NUMBER RETURN NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR ASSIGN VAR NUMBER IF VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR RETURN VAR VAR VAR RETURN FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER 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 FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def solve(n, m, notes):
if m < 0:
return False
if m == 0:
return True
ncopy = notes[:]
for note in notes:
ncopy.remove(note)
if solve(n - 1, m - note, ncopy):
return True
ncopy += [note]
for t in range(int(input())):
n, m = map(int, input().split())
notes = []
for v in range(n):
notes += [int(input())]
if solve(n, m, notes):
print("Yes")
else:
print("No") | FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER ASSIGN VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR IF FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR RETURN NUMBER VAR LIST VAR 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 LIST FOR VAR FUNC_CALL VAR VAR VAR LIST FUNC_CALL VAR FUNC_CALL VAR IF FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | from itertools import combinations
t = int(input())
for i in range(t):
n, m = map(int, input().split())
a = []
count = 0
for i in range(n):
a.append(int(input()))
for i in range(1, n + 1):
if count == 1:
break
for j in combinations(a, i):
if sum(j) == m:
count = 1
print("Yes")
break
if count != 1:
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 ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR IF FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER EXPR FUNC_CALL VAR STRING IF VAR NUMBER EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def resuo(nums, act):
n = len(nums)
sol = []
count = 1 << n
for mask in range(count):
ans = []
for i in range(n):
if mask & 1 << i != 0:
ans.append(nums[i])
sol.append(sum(ans))
for i in sol:
if i == act:
return "Yes"
return "No"
def into():
T = int(input())
for i in range(T):
arr = list(map(int, input().rstrip().split()))
act = arr[1]
nums = []
for i in range(arr[0]):
k = int(input())
nums.append(k)
res = resuo(nums, act)
print(res)
into() | FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR LIST ASSIGN VAR BIN_OP NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR IF BIN_OP VAR BIN_OP NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR VAR IF VAR VAR RETURN STRING RETURN STRING FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def fun(m, l):
if m == 0:
return True
elif m < 0:
return False
if len(l) == 0:
return False
for i in range(len(l)):
l1 = l.copy()
m1 = m - l1[i]
del l1[i]
s = fun(m1, l1)
if s:
return s
return False
for _ in range(int(input())):
n, m = map(int, input().split())
l = []
for i in range(n):
a = int(input())
if a <= m:
l.append(a)
print("Yes" if fun(m, l) else "No") | FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR BIN_OP VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF VAR RETURN VAR RETURN NUMBER 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 LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR STRING STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | import itertools
t = int(input())
for i in range(t):
n, m = map(int, input().split())
ans = []
comb = []
flag = 0
for j in range(n):
k = int(input())
if k <= m:
ans.append(k)
for g in range(len(ans) + 1):
comb_obj = itertools.combinations(ans, g)
comb += list(comb_obj)
for g in comb:
if sum(g) == m:
flag = 1
if flag == 1:
print("Yes")
else:
print("No") | IMPORT 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 ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR FOR VAR VAR IF FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | for i in range(int(input())):
n, s = [int(i) for i in input().split()]
arr = [int(input()) for i in range(n)]
dp = [[(0) for i in range(s + 1)] for j in range(n + 1)]
for i in dp:
i[0] = 1
for i in range(1, n + 1):
for j in range(1, s + 1):
if j < arr[i - 1]:
dp[i][j] = dp[i - 1][j]
elif dp[i - 1][j]:
dp[i][j] = 1
else:
dp[i][j] = dp[i - 1][j - arr[i - 1]]
if dp[n][s]:
print("Yes")
else:
print("No") | 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 FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR VAR ASSIGN VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR BIN_OP VAR NUMBER VAR IF VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER IF VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | for _ in range(int(input())):
n, m = map(int, input().split())
a = []
yes = False
for _ in range(n):
x = int(input())
if x <= m:
a.append(x)
ans = 0
for i in range(1, pow(2, len(a))):
for j in range(len(a)):
if i & 1 << j:
ans += a[j]
if ans == m:
yes = True
break
ans = 0
if yes:
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 ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF BIN_OP VAR BIN_OP NUMBER VAR VAR VAR VAR IF VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | test = int(input())
for i in range(test):
n, m = map(int, input().split())
arr = []
for i in range(n):
arr.append(int(input()))
def subs(arr):
subs = [[]]
dp = []
for elem in arr:
for i in range(len(subs)):
a = subs[i] + [elem]
subs.append(a)
dp.append(sum(a))
return dp
if m in subs(arr):
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 ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR LIST LIST ASSIGN VAR LIST FOR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR LIST VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR RETURN VAR IF VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | import itertools
for t in range(int(input())):
n, m = map(int, input().split())
a = []
for _ in range(n):
b = int(input())
a.append(b)
pay = "No"
for k in range(1, n + 1):
for l in itertools.combinations(a, k):
if sum(l) == m:
pay = "Yes"
break
print(pay) | IMPORT 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 LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR STRING FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR IF FUNC_CALL VAR VAR VAR ASSIGN VAR STRING EXPR FUNC_CALL VAR VAR |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | import sys
sys.setrecursionlimit(2**30)
def ans(start, arr, t):
if start == len(arr) and t == 0:
return True
if start == len(arr) and t != 0:
return False
if start > len(arr):
return False
if t == 0:
return True
elif arr[start] > t:
return ans(start + 1, arr, t)
else:
return ans(start + 1, arr, t - arr[start]) or ans(start + 1, arr, t)
test_cases = int(input())
while test_cases != 0:
d = list(map(int, input().split()))
arr = []
for y in range(0, d[0]):
temp = int(input())
arr.append(temp)
x = ans(0, arr, d[1])
if x is True:
print("Yes")
else:
print("No")
test_cases -= 1 | IMPORT EXPR FUNC_CALL VAR BIN_OP NUMBER NUMBER FUNC_DEF IF VAR FUNC_CALL VAR VAR VAR NUMBER RETURN NUMBER IF VAR FUNC_CALL VAR VAR VAR NUMBER RETURN NUMBER IF VAR FUNC_CALL VAR VAR RETURN NUMBER IF VAR NUMBER RETURN NUMBER IF VAR VAR VAR RETURN FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR RETURN FUNC_CALL VAR BIN_OP VAR NUMBER VAR BIN_OP VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR NUMBER VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING VAR NUMBER |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | for t in range(0, int(input())):
n, k = map(int, input().split())
arr = []
for i in range(0, n):
j = int(input())
if j <= k:
arr.append(j)
total = 0
c = 0
n = len(arr)
for i in range(0, 2**n):
total = 0
for j in range(0, n):
if 1 << j & i:
total += arr[j]
if total == k:
print("Yes")
c = 1
break
if c == 0:
print("No") | FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF BIN_OP BIN_OP NUMBER VAR VAR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def sub(l, i, curr_sum, k):
if i == len(l):
if curr_sum == k:
return True
else:
return False
if curr_sum == k:
return True
inc = sub(l, i + 1, curr_sum + l[i], k)
exc = sub(l, i + 1, curr_sum, k)
return inc or exc
for _ in range(int(input())):
n, m = map(int, input().split())
l = []
for i in range(n):
l.append(int(input()))
l.sort()
ans = sub(l, 0, 0, m)
if ans:
print("Yes")
else:
print("No") | FUNC_DEF IF VAR FUNC_CALL VAR VAR IF VAR VAR RETURN NUMBER RETURN NUMBER IF VAR VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR RETURN 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 ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER VAR IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | from itertools import chain, combinations
t = int(input())
def powerset(list_name):
s = list(list_name)
l = []
for i in range(1, len(list_name) + 1):
for x in combinations(s, i):
l.append(x)
return l
for _ in range(t):
n, m = map(int, input().split())
dp = [-1] * 20000
l = []
key = 0
for _ in range(n):
l.append(int(input()))
for x in powerset(l):
if sum(x) == m:
key = -1
break
if key == 0:
print("No")
else:
print("Yes") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR RETURN VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def solve():
n, amt = map(int, input().split())
dp = [([0] * (amt + 1)) for i in range(n + 1)]
lis = list()
for i in range(n):
lis.append(int(input()))
for i in range(1, n + 1):
for j in range(1, amt + 1):
if lis[i - 1] <= j:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - lis[i - 1]] + lis[i - 1])
else:
dp[i][j] = dp[i - 1][j]
print(["Yes", "No"][dp[n][amt] != amt])
for _ in range(int(input())):
solve() | FUNC_DEF 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 FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR LIST STRING STRING VAR VAR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def subs(li, arr, subset, index):
li.append(subset.copy())
for i in range(index, len(arr)):
subset.append(arr[i])
subs(li, arr, subset, i + 1)
subset.pop()
return
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
a = []
li = []
for i in range(n):
a.append(int(input()))
subs(li, a, [], 0)
out = []
for i in li:
if len(i) == 0:
out.append(0)
elif len(i) == 1:
out.append(i[0])
else:
out.append(sum(i))
try:
out.index(m)
print("Yes")
except:
print("No") | FUNC_DEF EXPR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR RETURN 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 VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR LIST NUMBER ASSIGN VAR LIST FOR VAR VAR IF FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER IF FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | tests = int(input())
for i in range(tests):
n, m = map(int, input().split())
notes_arr = []
for j in range(n):
notes_arr.append(int(input()))
ans = "No"
for j in range(1, 2**n):
temp = 0
count = 0
while j != 0:
if j & 1:
temp += notes_arr[count]
count += 1
j >>= 1
if temp == m:
ans = "Yes"
break
print(ans) | 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 FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR STRING FOR VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR NUMBER IF BIN_OP VAR NUMBER VAR VAR VAR VAR NUMBER VAR NUMBER IF VAR VAR ASSIGN VAR STRING EXPR FUNC_CALL VAR VAR |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def isSubsetSum(sett, no, summ):
if summ == 0:
return True
if no == 0:
return False
if sett[no - 1] > summ:
return isSubsetSum(sett, no - 1, summ)
return isSubsetSum(sett, no - 1, summ) or isSubsetSum(
sett, no - 1, summ - sett[no - 1]
)
T = int(input().strip())
for t in range(0, T):
n, m = input().strip().split()
n = int(n)
m = int(m)
l = []
for i in range(0, n):
p = int(input().strip())
l.append(p)
a = isSubsetSum(l, len(l), m)
if a == True:
print("Yes")
else:
print("No") | FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER IF VAR BIN_OP VAR NUMBER VAR RETURN FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR RETURN FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def issubset(L, p, k):
if k == 0:
return True
if p == 0:
return False
return issubset(L, p - 1, k) or issubset(L, p - 1, k - L[p - 1])
T = int(input())
for tc in range(T):
n, k = map(int, input().split())
L = []
for i in range(n):
t = int(input())
L.append(t)
x = issubset(L, n, k)
if x == True:
print("Yes")
else:
print("No") | FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER RETURN FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR 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 ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def knapsack(arr, total, cnt):
k = [[(0) for i in range(total + 1)] for j in range(cnt + 1)]
for i in range(1, cnt + 1):
for j in range(1, total + 1):
if j >= arr[i - 1]:
k[i][j] = max(k[i - 1][j], k[i - 1][j - arr[i - 1]] + arr[i - 1])
else:
k[i][j] = k[i - 1][j]
return k[cnt][total]
T = int(input())
for t in range(T):
n, m = [int(x) for x in input().split(" ")]
arr = []
for i in range(n):
arr.append(int(input()))
if m > 20000:
print("No")
elif m == knapsack(arr, m, n):
print("Yes")
else:
print("No") | FUNC_DEF ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR BIN_OP VAR NUMBER VAR RETURN VAR VAR VAR 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 STRING ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR IF VAR NUMBER EXPR FUNC_CALL VAR STRING IF VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | t = int(input())
def bt(i, target, l):
if target == 0:
return True
if i == len(l) - 1:
return target == l[-1]
not_take = bt(i + 1, target, l)
take = False
if l[i] <= target:
take = bt(i + 1, target - l[i], l)
return take or not_take
for _ in range(t):
n, m = map(int, input().split())
dp = [-1] * 20000
l = []
key = 0
for _ in range(n):
l.append(int(input()))
if bt(0, m, l):
print("Yes")
else:
print("No") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR BIN_OP FUNC_CALL VAR VAR NUMBER RETURN VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR NUMBER IF VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR RETURN VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR IF FUNC_CALL VAR NUMBER VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | t = int(input())
while t > 0:
t -= 1
n, m = [int(x) for x in input().split()]
a = []
for i in range(n):
x = int(input())
a.append(x)
can = False
for i in range(1 << n):
tot = 0
for j in range(n):
if i & 1 << j:
tot += a[j]
if tot == m:
can = True
break
print("Yes" if can else "No") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP NUMBER VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF BIN_OP VAR BIN_OP NUMBER VAR VAR VAR VAR IF VAR VAR ASSIGN VAR NUMBER EXPR FUNC_CALL VAR VAR STRING STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def findAll(arr, n, asum):
dp = {0}
arr = filter(lambda x: x <= asum, arr)
for note in arr:
new_sums = set(map(lambda x: x + note, dp))
if asum in new_sums:
return "Yes"
dp = dp.union(new_sums)
else:
return "No"
def main():
for _ in range(int(input())):
n, m = map(int, input().split())
arr = map(int, [input() for _ in range(n)])
ans = findAll(arr, n, m)
print(ans)
main() | FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR VAR VAR IF VAR VAR RETURN STRING ASSIGN VAR FUNC_CALL VAR VAR RETURN STRING FUNC_DEF 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 FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def fx(ind, target, arr):
if target == 0:
return True
if ind == 0:
k = arr[0] == target
return k
not_take = fx(ind - 1, target, arr)
take = False
if target >= arr[ind]:
take = fx(ind - 1, target - arr[ind], arr)
return take or not_take
for _ in range(int(input())):
n, m = map(int, input().split())
qw = []
for k in range(n):
t = int(input())
qw.append(t)
if fx(n - 1, m, qw):
print("Yes")
else:
print("No") | FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR NUMBER ASSIGN VAR VAR NUMBER VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR NUMBER IF VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR RETURN 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 ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR IF FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def call(arr, banknotes, amount):
dp = [([0] * (amount + 1)) for i in range(banknotes + 1)]
for i in range(banknotes + 1):
dp[i][0] = 1
for i in range(1, banknotes + 1):
for j in range(1, amount + 1):
if j >= arr[i - 1]:
dp[i][j] = dp[i - 1][j] or dp[i - 1][j - arr[i - 1]]
else:
dp[i][j] = dp[i - 1][j]
return "Yes" if dp[banknotes][amount] else "No"
t = int(input())
while t > 0:
arr = list(map(int, input().split()))
banknotes, amount = arr[0], arr[1]
arr = []
for i in range(banknotes):
arr.append(int(input()))
print(call(arr, banknotes, amount))
t -= 1 | FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR BIN_OP VAR NUMBER VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR BIN_OP VAR NUMBER VAR RETURN VAR VAR VAR STRING STRING ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR VAR NUMBER VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR NUMBER |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | for _ in range(int(input())):
n, m = map(int, input().split())
c = 0
l = []
for i in range(n):
k = int(input())
if k <= m:
l.append(k)
c += 1
l.sort()
s = 0
c1 = 0
f = 0
for i in range(1, 2**c):
while i != 0:
if i % 2 != 0:
s += l[c1]
if s == m:
f = 1
break
elif s > m:
break
c1 += 1
i = i >> 1
c1 = 0
s = 0
if f == 1:
break
if f == 1:
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 ASSIGN VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER VAR WHILE VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR VAR VAR IF VAR VAR ASSIGN VAR NUMBER IF VAR VAR VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def checkSubsetSum(a, m, n, memo):
if m == 0:
return True
if m < 0:
return False
if m in memo:
return memo[m]
for i in range(n):
rem = m - a[i]
if checkSubsetSum(a[:i] + a[i + 1 :], rem, n - 1, memo):
memo[m] = True
return True
memo[m] = False
return False
t = int(input())
for _ in range(t):
n, m = [int(i) for i in input().split()]
a = []
for i in range(n):
a.append(int(input()))
if checkSubsetSum(a, m, n, {}):
print("Yes")
else:
print("No") | FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER IF VAR VAR RETURN VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR IF FUNC_CALL VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR NUMBER RETURN NUMBER ASSIGN VAR VAR NUMBER RETURN NUMBER 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 ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR IF FUNC_CALL VAR VAR VAR VAR DICT EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def isSubsetSum(set, n, sum):
subset = [[(False) for i in range(sum + 1)] for i in range(n + 1)]
for i in range(n + 1):
subset[i][0] = True
for i in range(1, sum + 1):
subset[0][i] = False
for i in range(1, n + 1):
for j in range(1, sum + 1):
if j < set[i - 1]:
subset[i][j] = subset[i - 1][j]
if j >= set[i - 1]:
subset[i][j] = subset[i - 1][j] or subset[i - 1][j - set[i - 1]]
return subset[n][sum]
t = int(input())
for t1 in range(t):
n, m = map(int, input().split())
ls = []
for n1 in range(n):
a = int(input())
ls.append(a)
if isSubsetSum(ls, n, m) == True:
print("Yes")
else:
print("No") | FUNC_DEF ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR BIN_OP VAR NUMBER VAR IF VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR BIN_OP VAR NUMBER VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER RETURN VAR 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 FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | for tc in range(1, int(input()) + 1):
n, m = map(int, input().split())
arr = []
for i in range(n):
arr.append(int(input()))
dp = [([0] * (m + 1)) for _ in range(n + 1)]
for j in range(m + 1):
dp[0][j] = 0
for i in range(n + 1):
dp[i][0] = 1
for i in range(1, n + 1):
for j in range(1, m + 1):
if arr[i - 1] <= j:
dp[i][j] = dp[i - 1][j - arr[i - 1]] or dp[i - 1][j]
else:
dp[i][j] = dp[i - 1][j]
print("Yes" if dp[n][m] else "No") | FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL 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 ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR VAR VAR BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR VAR VAR VAR STRING STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | test_cases = int(input())
bank_notes = []
def solve():
bank_notes_num, m = input().split()
m = int(m)
bank_notes_num = int(bank_notes_num)
for bn in range(0, bank_notes_num):
bn_val = int(input())
bank_notes.append(bn_val)
bank_notes.sort()
subsets = [[]]
for bn1 in bank_notes:
subsets += [(sub + [bn1]) for sub in subsets]
for s in subsets:
if sum(s) == m:
print("Yes")
return
print("No")
for t in range(0, test_cases):
solve()
bank_notes = [] | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FUNC_DEF ASSIGN VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR LIST LIST FOR VAR VAR VAR BIN_OP VAR LIST VAR VAR VAR FOR VAR VAR IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR STRING RETURN EXPR FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR NUMBER VAR EXPR FUNC_CALL VAR ASSIGN VAR LIST |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def sumUpTo(index, money, notesArr, dp):
if money == 0:
return True
elif money < 0:
return False
elif index >= len(notesArr):
return False
elif dp[index][money] != None:
return dp[index][money]
else:
take = sumUpTo(index + 1, money - notesArr[index], notesArr, dp)
dontTake = sumUpTo(index + 1, money, notesArr, dp)
dp[index][money] = take or dontTake
return dp[index][money]
test_case = int(input())
results = []
for test in range(test_case):
arr = input().split(" ")
notes = int(arr[0])
money = int(arr[1])
notesArr = []
for i in range(notes):
notesArr.append(int(input()))
dp = []
for index in range(len(notesArr)):
dp_row = []
for m in range(money + 1):
dp_row.append(None)
dp.append(dp_row)
results.append(sumUpTo(0, money, notesArr, dp))
for r in results:
if r == True:
print("Yes")
else:
print("No") | FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER IF VAR FUNC_CALL VAR VAR RETURN NUMBER IF VAR VAR VAR NONE RETURN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR RETURN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR NONE EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR NUMBER VAR VAR VAR FOR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | from itertools import chain, combinations
def powerset(list_name):
s = list(list_name)
return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1))
for _ in range(int(input())):
n, m = map(int, input().split())
li = []
for i in range(n):
li.append(int(input()))
li.sort()
fnd = False
for a in powerset(li):
if sum(a) == m:
fnd = True
if fnd:
print("Yes")
else:
print("No") | FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER 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 LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def pay(i, s):
if s >= m:
return s == m
if i == n:
return False
return pay(i + 1, s) or pay(i + 1, s + a[i])
for _ in range(int(input())):
n, m = map(int, input().split())
a = []
for j in range(n):
a += [int(input())]
if pay(0, 0):
print("Yes")
else:
print("No") | FUNC_DEF IF VAR VAR RETURN VAR VAR IF VAR VAR RETURN NUMBER RETURN FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP 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 ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR VAR LIST FUNC_CALL VAR FUNC_CALL VAR IF FUNC_CALL VAR NUMBER NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def subsum(arr, i, n, su, s):
if i == n:
if su == s:
return True
return False
if su + arr[i] <= s:
return subsum(arr, i + 1, n, su + arr[i], s) or subsum(arr, i + 1, n, su, s)
else:
return subsum(arr, i + 1, n, su, s)
for _ in range(int(input())):
si, s = [int(a) for a in input().split()]
arr = []
for l in range(si):
arr.append(int(input()))
if subsum(arr, 0, si, 0, s):
print("Yes")
else:
print("No") | FUNC_DEF IF VAR VAR IF VAR VAR RETURN NUMBER RETURN NUMBER IF BIN_OP VAR VAR VAR VAR RETURN FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR VAR VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR VAR RETURN FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR VAR 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 LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def Helper(A, num, target, hashTable):
if target == 0:
return True
if num == 0:
return False
if target < 0:
return False
if (num, target) in hashTable:
return hashTable[num, target]
for i in range(len(A)):
if num & 1 << i == 0:
continue
val = num & ~(1 << i)
value = Helper(A, val, target - A[i], hashTable)
if value:
hashTable[num, target] = True
return True
hashTable[num, target] = False
return False
def function(A, N, M):
num = ~(-1 << N)
ans = Helper(A, num, M, {})
if ans:
return "Yes"
return "No"
def main():
T = int(input())
for _ in range(T):
N, M = list(map(int, input().split(" ")))
A = []
for i in range(N):
A.append(int(input()))
val = function(A, N, M)
print(val)
main() | FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER IF VAR VAR VAR RETURN VAR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF BIN_OP VAR BIN_OP NUMBER VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR VAR BIN_OP VAR VAR VAR VAR IF VAR ASSIGN VAR VAR VAR NUMBER RETURN NUMBER ASSIGN VAR VAR VAR NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR BIN_OP NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR DICT IF VAR RETURN STRING RETURN STRING FUNC_DEF 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 STRING ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def solve(n, arr, ind, amt, dp):
if amt == 0:
return True
if amt < 0:
return False
if (ind, amt) in dp:
return dp[ind, amt]
if ind > n - 1:
return False
dp[ind, amt] = solve(n, arr, ind + 1, amt - arr[ind], dp) or solve(
n, arr, ind + 1, amt, dp
)
return dp[ind, amt]
t = int(input())
for i in range(t):
n, m = list(map(int, input().split()))
arr = [0] * n
for i in range(n):
arr[i] = int(input())
if solve(n, arr, 0, m, {}):
print("Yes")
else:
print("No") | FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER IF VAR VAR VAR RETURN VAR VAR VAR IF VAR BIN_OP VAR NUMBER RETURN NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER VAR VAR RETURN VAR 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 ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR IF FUNC_CALL VAR VAR VAR NUMBER VAR DICT EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | from itertools import combinations
t = int(input())
for i in range(t):
n, m = [int(x) for x in input().split()]
l = []
for j in range(n):
l.append(int(input()))
a = []
for i in range(n):
b = list(combinations(l, i + 1))
a += b
flag = 0
for i in a:
if sum(i) == m:
print("Yes")
flag = 1
break
if flag == 0:
print("No") | 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 ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR NUMBER FOR VAR VAR IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def change(i, total, memo):
if (i, total) in memo:
return memo[i, total]
if total == m:
memo[i, total] = True
return memo[i, total]
if i >= n or total > m:
memo[i, total] = False
return memo[i, total]
memo[i, total] = change(i + 1, total + notes[i], memo) or change(i + 1, total, memo)
return memo[i, total]
t = int(input())
for _ in range(t):
n, m = list(map(int, input().split()))
notes = [(-1) for _ in range(n)]
for i in range(n):
notes[i] = int(input())
print("Yes" if change(0, 0, {}) else "No") | FUNC_DEF IF VAR VAR VAR RETURN VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR NUMBER RETURN VAR VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR NUMBER RETURN VAR VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR RETURN VAR 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 ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR NUMBER NUMBER DICT STRING STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def eAll(arr, i, cs, trg):
if i >= len(arr):
return False
if trg == cs + arr[i]:
return True
if arr[i] + cs > trg:
return False
return eAll(arr, i + 1, cs + arr[i], trg) or eAll(arr, i + 1, cs, trg)
tn = int(input())
for _ in range(tn):
n, m = map(int, input().split())
arr = [int(input()) for _ in range(n)]
arr.sort()
if eAll(arr, 0, 0, m):
print("Yes")
else:
print("No") | FUNC_DEF IF VAR FUNC_CALL VAR VAR RETURN NUMBER IF VAR BIN_OP VAR VAR VAR RETURN NUMBER IF BIN_OP VAR VAR VAR VAR RETURN NUMBER RETURN FUNC_CALL VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER 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 FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR IF FUNC_CALL VAR VAR NUMBER NUMBER VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | from itertools import chain, combinations
def power_set(list_name):
given_set = list(list_name)
return chain.from_iterable(
combinations(given_set, r) for r in range(len(given_set) + 1)
)
inp_t = int(input())
while inp_t:
inp_n, inp_m = input().split()
inp_n, inp_m = int(inp_n), int(inp_m)
pocket_currency = []
while inp_n:
pocket_currency.append(int(input()))
inp_n = inp_n - 1
pocket_currency = sorted(pocket_currency)
super_set_pocket_currency = power_set(pocket_currency)
flag = False
for each_set in super_set_pocket_currency:
if sum(each_set) == inp_m:
print("Yes")
flag = True
break
if flag is False:
print("No")
inp_t = inp_t - 1 | FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR ASSIGN VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR LIST WHILE VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR VAR IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING ASSIGN VAR BIN_OP VAR NUMBER |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def isSubsetSum(arr, n, target):
if target == 0:
return True
if n == 0:
return False
if arr[n - 1] > target:
return isSubsetSum(arr, n - 1, target)
return isSubsetSum(arr, n - 1, target) or isSubsetSum(
arr, n - 1, target - arr[n - 1]
)
for _ in range(int(input())):
n, m = map(int, input().split())
notes = []
for _ in range(n):
notes.append(int(input()))
if isSubsetSum(notes, n, m):
print("Yes")
else:
print("No") | FUNC_DEF IF VAR NUMBER RETURN NUMBER IF VAR NUMBER RETURN NUMBER IF VAR BIN_OP VAR NUMBER VAR RETURN FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR RETURN FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER BIN_OP VAR VAR BIN_OP VAR NUMBER 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 LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR IF FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
In the mysterious country of Byteland, everything is quite different from what you'd
normally expect. In most places, if you were approached by two mobsters in a dark alley, they would
probably tell you to give them all the money that you have. If you refused, or didn't have any -
they might even beat you up.
In Byteland the government decided that even the slightest chance of someone getting injured has to be ruled out. So, they introduced a strict policy. When a mobster approaches you in a dark
alley, he asks you for a specific amount of money. You are obliged to show him all the money that
you have, but you only need to pay up if he can find a subset of your banknotes whose total value
matches his demand. Since banknotes in Byteland can have any positive integer value smaller than
one thousand you are quite likely to get off without paying.
Both the citizens and the gangsters of Byteland have very positive feelings about the system. No one ever
gets hurt, the gangsters don't lose their jobs, and there are quite a few rules that minimize that
probability of getting mugged (the first one is: don't go into dark alleys - and this one is said to work in other places also).
------ Input ------
The first line contains integer t, the number of test cases (about 100). Then t test cases follow. Each test case starts with n, the
number of banknotes in your wallet, and m, the amount of money the muggers asked of you. Then n
numbers follow, representing values of your banknotes. Your wallet does not hold more than 20 banknotes, and the value of a single banknote is never more than 1000.
------ Output ------
For each test case output a single line with the word 'Yes' if there is a subset of your banknotes that sums to m, and 'No' otherwise.
----- Sample Input 1 ------
5
3 3
1
1
1
5 11
1
2
4
8
16
5 23
1
2
4
8
16
5 13
1
5
5
10
10
20 132
17
6
4
998
254
137
259
153
154
3
28
19
123
542
857
23
687
35
99
999
----- Sample Output 1 ------
Yes
Yes
Yes
No
Yes
----- explanation 1 ------
For example, in the last case you have to pay up, since: 6+3+123=132. | def solvemug(m, L):
if m == 0:
return True
elif len(L) == 0:
return False
elif m >= L[0]:
a, b = solvemug(m - L[0], L[1:]), solvemug(m, L[1:])
return a or b
else:
a = solvemug(m, L[1:])
return a
T = int(input())
for _ in range(T):
n, m = map(int, input().split())
L = []
for i in range(n):
L.append(int(input()))
if solvemug(m, L):
print("Yes")
else:
print("No") | FUNC_DEF IF VAR NUMBER RETURN NUMBER IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR VAR NUMBER RETURN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER RETURN 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 FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | n, m = list(map(int, input().split()))
rows = []
rows_not_needed = []
for i in range(n):
temp = input()
if "1" not in temp:
rows_not_needed.append(i)
continue
rows.append(temp)
n = n - len(rows_not_needed)
if n == 0:
print(0)
exit()
dp = [[(0) for _ in range(2)] for _ in range(n)]
l = [(0) for _ in range(n)]
r = [(0) for _ in range(n)]
for i in range(0, n):
for j in range(0, m + 2):
if rows[i][j] == "1":
r[i] = j
for j in range(m + 1, -1, -1):
if rows[i][j] == "1":
l[i] = j
dp[0][0] = r[0]
dp[0][1] = m + 1 - l[0]
for i in range(1, n):
dp[i][0] = min(
r[i] + m + 1 - r[i] + 1 + dp[i - 1][1], r[i] + r[i] + 1 + dp[i - 1][0]
)
dp[i][1] = min(
m + 1 - l[i] + l[i] + 1 + dp[i - 1][0],
m + 1 - l[i] + m + 1 - l[i] + 1 + dp[i - 1][1],
)
for i in range(0, len(rows_not_needed)):
if rows_not_needed[i] != i:
dp[n - 1][0] += 1
print(dp[n - 1][0]) | ASSIGN VAR VAR FUNC_CALL 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 IF STRING VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR VAR STRING ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR VAR STRING ASSIGN VAR VAR VAR ASSIGN VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR NUMBER NUMBER BIN_OP BIN_OP VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP BIN_OP VAR VAR VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER VAR VAR VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER VAR VAR VAR NUMBER VAR VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR IF VAR VAR VAR VAR BIN_OP VAR NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | import sys
inf = float("inf")
ans = inf
def solve():
global ans
n, m = map(int, input().split())
room = [[int(i) for i in input()] for j in range(n)]
room.reverse()
exits = [False] * n
for i in range(n - 1, -1, -1):
if any(room[i]):
exits[i] = True
if i - 1 >= 0:
exits[i - 1] |= exits[i]
if not exits[0]:
ans = 0
else:
dfs(0, n, m, room, exits, 0, 0)
print(ans)
def dfs(floor, n, m, room, exits, pos, move):
global ans
k = -1
if pos == 0:
for j in range(m + 1, -1, -1):
if room[floor][j]:
k = j
break
else:
k = 0
else:
for j in range(0, m + 2):
if room[floor][j]:
k = j
break
else:
k = m + 1
move += abs(k - pos)
if floor == n - 1 or not exits[floor + 1]:
ans = min(ans, move)
return
else:
dfs(floor + 1, n, m, room, exits, 0, move + k + 1)
dfs(floor + 1, n, m, room, exits, m + 1, move + m + 1 - k + 1)
solve() | IMPORT ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF FUNC_CALL VAR VAR VAR ASSIGN VAR VAR NUMBER IF BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER VAR VAR IF VAR NUMBER ASSIGN VAR NUMBER EXPR FUNC_CALL VAR NUMBER VAR VAR VAR VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR NUMBER IF VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR VAR IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR RETURN EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR VAR VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR VAR VAR BIN_OP VAR NUMBER BIN_OP BIN_OP BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | n, m = list(map(int, input().split()))
house = []
def look_right(position, house):
x, y = position
l = len(house[y])
count = l - x
ps = 0
while ps == 0:
pos = [l - 1, y - 1]
for i in range(l - 1, -1, -1):
if house[y - 1][i] == 1:
pos[0] = i
ps += 1
if ps > 0:
count += l - pos[0] - 1
return {"cnt": count, "position": pos, "light": ps}
else:
y -= 1
count += 1
def look_left(position, house):
x, y = position
l = len(house[y])
count = x + 1
ps = 0
while ps == 0:
pos = [0, y - 1]
for i in range(0, l):
if house[y - 1][i] == 1:
pos[0] = i
ps += 1
if ps > 0:
count += pos[0]
return {"cnt": count, "position": pos, "light": ps}
else:
count += 1
y -= 1
lights = 0
for _ in range(n):
rooms = list(map(int, list(input().strip())))
for i in rooms:
if i == 1:
lights += 1
house.append(rooms)
position = [0, n - 1]
passed = 0
total = 0
while position[1] >= 0:
for i in range(len(house[0])):
if house[position[1]][i] == 1:
position[0] = i
total = i + n - position[1] - 1
passed += 1
if total == 0:
position[1] -= 1
else:
break
states = []
states.append(
{
"l": {"cnt": total, "position": position, "light": passed},
"r": {"cnt": total, "position": position, "light": passed},
}
)
i = 0
while states[i]["l"]["light"] < lights:
position_l = states[i]["l"]["position"]
l_l = look_left(position_l, house)
l_r = look_right(position_l, house)
position_r = states[i]["r"]["position"]
r_l = look_left(position_r, house)
r_r = look_right(position_r, house)
if l_l["cnt"] + states[i]["l"]["cnt"] < r_l["cnt"] + states[i]["r"]["cnt"]:
sl = {
"cnt": states[i]["l"]["cnt"] + l_l["cnt"],
"position": l_l["position"],
"light": states[i]["l"]["light"] + l_l["light"],
}
else:
sl = {
"cnt": states[i]["r"]["cnt"] + r_l["cnt"],
"position": r_l["position"],
"light": states[i]["r"]["light"] + r_l["light"],
}
if l_r["cnt"] + states[i]["l"]["cnt"] < r_r["cnt"] + states[i]["r"]["cnt"]:
sr = {
"cnt": states[i]["l"]["cnt"] + l_r["cnt"],
"position": l_r["position"],
"light": states[i]["l"]["light"] + l_r["light"],
}
else:
sr = {
"cnt": states[i]["r"]["cnt"] + r_r["cnt"],
"position": r_r["position"],
"light": states[i]["r"]["light"] + r_r["light"],
}
states.append({"l": sl, "r": sr})
i += 1
print(min(states[i]["l"]["cnt"], states[i]["r"]["cnt"])) | ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FUNC_DEF ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR NUMBER WHILE VAR NUMBER ASSIGN VAR LIST BIN_OP VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR VAR NUMBER IF VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER RETURN DICT STRING STRING STRING VAR VAR VAR VAR NUMBER VAR NUMBER FUNC_DEF ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER WHILE VAR NUMBER ASSIGN VAR LIST NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR VAR NUMBER IF VAR NUMBER VAR VAR NUMBER RETURN DICT STRING STRING STRING VAR VAR VAR VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FOR VAR VAR IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF VAR VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER NUMBER ASSIGN VAR LIST EXPR FUNC_CALL VAR DICT STRING STRING DICT STRING STRING STRING VAR VAR VAR DICT STRING STRING STRING VAR VAR VAR ASSIGN VAR NUMBER WHILE VAR VAR STRING STRING VAR ASSIGN VAR VAR VAR STRING STRING ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR STRING STRING ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF BIN_OP VAR STRING VAR VAR STRING STRING BIN_OP VAR STRING VAR VAR STRING STRING ASSIGN VAR DICT STRING STRING STRING BIN_OP VAR VAR STRING STRING VAR STRING VAR STRING BIN_OP VAR VAR STRING STRING VAR STRING ASSIGN VAR DICT STRING STRING STRING BIN_OP VAR VAR STRING STRING VAR STRING VAR STRING BIN_OP VAR VAR STRING STRING VAR STRING IF BIN_OP VAR STRING VAR VAR STRING STRING BIN_OP VAR STRING VAR VAR STRING STRING ASSIGN VAR DICT STRING STRING STRING BIN_OP VAR VAR STRING STRING VAR STRING VAR STRING BIN_OP VAR VAR STRING STRING VAR STRING ASSIGN VAR DICT STRING STRING STRING BIN_OP VAR VAR STRING STRING VAR STRING VAR STRING BIN_OP VAR VAR STRING STRING VAR STRING EXPR FUNC_CALL VAR DICT STRING STRING VAR VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR STRING STRING VAR VAR STRING STRING |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | n, m = map(int, input().split())
a = []
for i in range(n):
a.append(input())
l = 0
r = INF = 100000
h = 0
while h < n:
if a[h] == "0" * (m + 2):
h += 1
else:
break
if h != n:
for i in range(n - 1, h, -1):
x = INF
y = 0
for j in range(m + 2):
if a[i][j] == "1":
x = min(x, j)
y = max(y, j)
if x != INF:
ll = min(l + y * 2, r + m + 1)
rr = min(l + m + 1, r + (m + 1 - x) * 2)
l = ll
r = rr
x = INF
y = 0
for j in range(m + 2):
if a[h][j] == "1":
x = min(x, j)
y = max(y, j)
ans = min(l + y, r + (m + 1 - x))
print(ans + n - 1 - h)
else:
print(0) | 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 NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR IF VAR VAR BIN_OP STRING BIN_OP VAR NUMBER VAR NUMBER IF VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR STRING ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER BIN_OP VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR STRING ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR VAR NUMBER VAR EXPR FUNC_CALL VAR NUMBER |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | n, m = map(int, input().split())
a = [input() for i in range(n)]
i = 0
while i < n and a[i] == "0" * (m + 2):
i += 1
a = a[i:]
n = len(a)
dp = [[10**5, 10**5] for i in range(n)]
for i in range(n):
l, r = a[i].find("1"), a[i].rfind("1")
if l == r == -1:
l, r = m + 1, 0
if i == 0:
dp[0] = [r, m + 1 - l]
else:
dp[i][0] = min(dp[i - 1][0] + 2 * r, dp[i - 1][1] + (m + 1)) + 1
dp[i][1] = min(dp[i - 1][0] + m + 1, dp[i - 1][1] + 2 * (m + 1 - l)) + 1
ans = dp[-1][0] if dp else 0
print(ans) | ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE VAR VAR VAR VAR BIN_OP STRING BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR LIST BIN_OP NUMBER NUMBER BIN_OP NUMBER NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR STRING FUNC_CALL VAR VAR STRING IF VAR VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER NUMBER IF VAR NUMBER ASSIGN VAR NUMBER LIST VAR BIN_OP BIN_OP VAR NUMBER VAR ASSIGN VAR VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR VAR NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | INT_INF = 1061109567
def solve():
left = [(0) for _ in range(n + 5)]
right = left.copy()
for i in range(st, n + 1):
mi, ma = m + 2, 1
for j in range(1, m + 3):
if s[i][j] == "1":
mi = min(mi, j)
ma = max(ma, j)
left[i] = mi
right[i] = ma
dp = [[INT_INF, INT_INF] for _ in range(n + 5)]
dp[n + 1][0] = -1
for i in range(n, st, -1):
dp[i][0] = min(dp[i + 1][0] + (right[i] - 1) * 2, dp[i + 1][1] + m + 1) + 1
dp[i][1] = min(dp[i + 1][0] + m + 1, dp[i + 1][1] + (m + 2 - left[i]) * 2) + 1
ans = min(dp[st + 1][0] + right[st] - 1, dp[st + 1][1] + m + 2 - left[st]) + 1
return ans
def judge():
for i in range(1, n + 1):
for ch in s[i]:
if ch == "1":
return False
return True
while True:
try:
n, m = map(int, input().split(" "))
s = [0] + [("0" + input()) for _ in range(n)]
if judge():
print("0")
continue
st = 1
for i in range(1, n + 1):
flag = True
for j in range(1, m + 3):
if s[i][j] == "1":
flag = False
break
if flag:
st += 1
else:
break
print(solve())
except:
break | ASSIGN VAR NUMBER FUNC_DEF ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR VAR STRING ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR LIST VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP VAR VAR NUMBER NUMBER BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP BIN_OP VAR NUMBER VAR VAR NUMBER NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR VAR NUMBER BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER VAR VAR NUMBER RETURN VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR VAR VAR IF VAR STRING RETURN NUMBER RETURN NUMBER WHILE NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR BIN_OP LIST NUMBER BIN_OP STRING FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR VAR STRING ASSIGN VAR NUMBER IF VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | import itertools
n, m = list(map(int, input().split()))
floors = []
max_lit = -1
for floor_n in range(n - 1, -1, -1):
cur_floor = input()
floors.insert(0, cur_floor)
if max_lit == -1 and any(c == "1" for c in cur_floor):
max_lit = floor_n + 1
if max_lit == -1:
print("0")
return
def calc_path(path):
left = True
result = 0
for floor in range(max_lit):
switch_stairs = path[floor]
if left:
pos = floors[floor].rfind("1")
dist = 0 if pos == -1 else pos
else:
pos = floors[floor].find("1")
dist = 0 if pos == -1 else m + 1 - pos
is_last = floor == max_lit - 1
result += dist
if switch_stairs:
if not is_last:
result += m + 1 - dist
left = not left
elif not is_last:
result += dist
if not is_last:
result += 1
return result
min_v = -1
for p in itertools.product([False, True], repeat=max_lit):
v = calc_path(p)
if min_v == -1 or min_v > v:
min_v = v
print(min_v) | IMPORT ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR EXPR FUNC_CALL VAR NUMBER VAR IF VAR NUMBER FUNC_CALL VAR VAR STRING VAR VAR ASSIGN VAR BIN_OP VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING RETURN FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR IF VAR ASSIGN VAR FUNC_CALL VAR VAR STRING ASSIGN VAR VAR NUMBER NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR STRING ASSIGN VAR VAR NUMBER NUMBER BIN_OP BIN_OP VAR NUMBER VAR ASSIGN VAR VAR BIN_OP VAR NUMBER VAR VAR IF VAR IF VAR VAR BIN_OP BIN_OP VAR NUMBER VAR ASSIGN VAR VAR IF VAR VAR VAR IF VAR VAR NUMBER RETURN VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR LIST NUMBER NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER VAR VAR ASSIGN VAR VAR EXPR FUNC_CALL VAR VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | R = lambda: map(int, input().split())
n, m = R()
m += 2
fls = [input() for i in range(n)]
while fls and not fls[0].count("1"):
fls.pop(0)
if not fls:
print(0)
exit(0)
ls, rs = [], []
resv = 0
for i in range(len(fls) - 1, -1, -1):
s = fls[i]
if "1" in s:
ls.append(s.rfind("1"))
rs.append(m - s.find("1") - 1)
else:
resv += 1
n = len(ls)
dp = [[0, 0] for i in range(n)]
dp[0][0] = ls[0]
dp[0][1] = m + rs[0]
for i in range(1, n):
dp[i][0] = (
min(dp[i - 1][0] + ls[i - 1], dp[i - 1][1] + m - rs[i - 1] - 1) + 1 + ls[i]
)
dp[i][1] = (
min(dp[i - 1][0] + m - ls[i - 1] - 1, dp[i - 1][1] + rs[i - 1]) + 1 + rs[i]
)
print(min(dp[-1]) + resv) | ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR WHILE VAR FUNC_CALL VAR NUMBER STRING EXPR FUNC_CALL VAR NUMBER IF VAR EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR VAR LIST LIST ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR VAR IF STRING VAR EXPR FUNC_CALL VAR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR FUNC_CALL VAR STRING NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR NUMBER NUMBER BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR NUMBER BIN_OP BIN_OP FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR VAR BIN_OP VAR NUMBER NUMBER NUMBER VAR VAR ASSIGN VAR VAR NUMBER BIN_OP BIN_OP FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | n, m = map(int, input().split())
g = [list(input()) for i in range(n)]
max_n = -1
for i in range(n):
if g[i].count("1") == 0:
max_n = i
else:
break
g = g[max_n + 1 :]
n -= max_n + 1
if len(g) == 0:
print(0)
exit()
l = [m + 1] * n
r = [0] * n
dp = [([0] * 2) for i in range(n)]
for i in range(n):
for j in range(m + 2):
if g[n - 1 - i][j] == "1":
l[i] = min(l[i], j)
r[i] = max(r[i], j)
dp[0][0] = r[0] * 2 + 1
dp[0][1] = m + 2
for i in range(1, n - 1):
dp[i][0] = min(dp[i - 1][0] + r[i] * 2 + 1, dp[i - 1][1] + (m + 1) + 1)
dp[i][1] = min(dp[i - 1][0] + (m + 1) + 1, dp[i - 1][1] + (m - l[i] + 1) * 2 + 1)
if n == 1:
print(r[0])
else:
ans = min(dp[n - 2][0] + r[n - 1], dp[n - 2][1] + m - l[n - 1] + 1)
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 NUMBER FOR VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR STRING NUMBER ASSIGN VAR VAR ASSIGN VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER IF FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST BIN_OP VAR NUMBER VAR ASSIGN VAR BIN_OP LIST 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 BIN_OP VAR NUMBER IF VAR BIN_OP BIN_OP VAR NUMBER VAR VAR STRING ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR NUMBER NUMBER BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR VAR NUMBER NUMBER BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER NUMBER NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | n, m = map(int, input().split())
a = [""] * n
for i in range(n):
a[n - i - 1] = input()
res, ll, rr, k, l, r = 0, 0, 0, 0, 0, 0
for s in a:
i, l, r = 0, 0, 0
for z in s:
if z == "1":
if l == 0:
l = m - i + 1
r = i
i += 1
if k == 0:
p, q, rr = ll + 2 * r, ll + m + 1, m + 1
else:
p, q = min(ll + 2 * r, rr + m + 1), min(ll + m + 1, rr + 2 * l)
if l or r:
res = min(ll + r + k, rr + l + k)
k += 1
ll, rr = p, q
print(res) | ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST STRING VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER FUNC_CALL VAR ASSIGN VAR VAR VAR VAR VAR VAR NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR VAR ASSIGN VAR VAR VAR NUMBER NUMBER NUMBER FOR VAR VAR IF VAR STRING IF VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR VAR VAR NUMBER IF VAR NUMBER ASSIGN VAR VAR VAR BIN_OP VAR BIN_OP NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR BIN_OP VAR BIN_OP NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER BIN_OP VAR BIN_OP NUMBER VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR BIN_OP BIN_OP VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | def coun(pref):
now = 0
for i in range(n):
pos = pref[i]
if pos == "l":
if i < n - 1 and sum(check[i + 1 :]) > 0:
now += 1
if "1" in mat[i]:
if pref[i + 1] == "r":
now += m + 1
else:
now += 2 * mat[i].rfind("1")
elif pref[i + 1] == "r":
now += m + 1
elif "1" in mat[i]:
now += mat[i].rfind("1")
elif i < n - 1 and sum(check[i + 1 :]) > 0:
now += 1
if "1" in mat[i]:
if pref[i + 1] == "l":
now += m + 1
else:
now += 2 * (m + 1 - mat[i].find("1"))
elif pref[i + 1] == "l":
now += m + 1
elif "1" in mat[i]:
now += m + 1 - mat[i].find("1")
return now
def gen(pref):
global ans
if len(pref) == n:
ans = min(ans, coun(pref))
return
gen(pref + "l")
gen(pref + "r")
n, m = map(int, input().split())
mat = [0] * n
for i in range(n):
mat[i] = input()
mat.reverse()
check = [0] * n
for i in range(n):
check[i] = mat[i].count("1")
ans = 1000000000
gen("l")
print(ans) | FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR IF VAR STRING IF VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER IF STRING VAR VAR IF VAR BIN_OP VAR NUMBER STRING VAR BIN_OP VAR NUMBER VAR BIN_OP NUMBER FUNC_CALL VAR VAR STRING IF VAR BIN_OP VAR NUMBER STRING VAR BIN_OP VAR NUMBER IF STRING VAR VAR VAR FUNC_CALL VAR VAR STRING IF VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER IF STRING VAR VAR IF VAR BIN_OP VAR NUMBER STRING VAR BIN_OP VAR NUMBER VAR BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR STRING IF VAR BIN_OP VAR NUMBER STRING VAR BIN_OP VAR NUMBER IF STRING VAR VAR VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR STRING RETURN VAR FUNC_DEF IF FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR RETURN EXPR FUNC_CALL VAR BIN_OP VAR STRING EXPR FUNC_CALL VAR BIN_OP VAR STRING ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR EXPR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR STRING ASSIGN VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | import sys
def main():
n, m = map(int, sys.stdin.readline().split())
m += 2
z = []
for i in range(n):
z.append(sys.stdin.readline().rstrip())
ans = 0
y = n - 1
x = 0
q = [[x, y, ans]]
for i in range(n - 1, -1, -1):
first = -1
last = -1
for j in range(m):
if z[i][j] == "1":
if first == -1:
first = j
last = j
if first == -1 and last == -1:
continue
if i == n - 1:
q[0] = [last, n - 1, last]
continue
if first == last:
for t in q:
t[2] += min(t[0] + first, m - 1 - t[0] + m - 1 - first) + t[1] - i
t[0] = first
t[1] = i
continue
size = len(q)
for s in range(size):
t = q[s]
q.append([last, i, t[2] + t[0] + last + t[1] - i])
t[2] += m - 1 - t[0] + m - 1 - first + t[1] - i
t[0] = first
t[1] = i
q[s] = t
ans = q[0][2]
for i in range(len(q)):
if q[i][2] < ans:
ans = q[i][2]
print(ans)
main() | IMPORT FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST LIST VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR STRING IF VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR IF VAR NUMBER VAR NUMBER IF VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER LIST VAR BIN_OP VAR NUMBER VAR IF VAR VAR FOR VAR VAR VAR NUMBER BIN_OP BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER VAR VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR LIST VAR VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER VAR VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR ASSIGN VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | def first_one(row):
for i in range(len(row)):
if row[i] == "1":
return i
return len(row) - 1
def last_one(row):
for i in range(len(row) - 1, -1, -1):
if row[i] == "1":
return i
return 0
def left_score(i):
la = last_one(l[i])
s = la
right_pur = m + 1 - la + 1 + scores[i - 1][1]
left_pur = la + 1 + scores[i - 1][0]
s += min(right_pur, left_pur)
return s
def right_score(i):
la = first_one(l[i])
s = m + 1 - la
right_pur = m + 1 - la + 1 + scores[i - 1][1]
left_pur = la + 1 + scores[i - 1][0]
s += min(right_pur, left_pur)
return s
n, m = list(map(int, input().split()))
l = [input() for i in range(n)]
if n == 1:
print(last_one(l[0]))
else:
i = 0
while l != [] and "1" not in l[0]:
del l[0]
n -= 1
if n == 1:
print(last_one(l[0]))
elif n == 0:
print(0)
else:
scores = [[last_one(l[0]), m + 1 - first_one(l[0])]]
for i in range(1, n - 1):
scores.append([left_score(i), right_score(i)])
print(left_score(n - 1)) | FUNC_DEF FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR STRING RETURN VAR RETURN BIN_OP FUNC_CALL VAR VAR NUMBER FUNC_DEF FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER IF VAR VAR STRING RETURN VAR RETURN NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR FUNC_CALL VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER VAR FUNC_CALL VAR VAR VAR RETURN VAR 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 IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER WHILE VAR LIST STRING VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR LIST LIST FUNC_CALL VAR VAR NUMBER BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR LIST FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | n_m = [int(x) for x in input().split()]
n_m[1] += 1
floors = []
rooms = []
position = [0, 0]
def judge(a, b, rooms):
temp = rooms[:]
temp_room = temp.pop(a)
temp_cost = do(temp, temp_room)
temp1 = rooms[:]
temp1_room = temp1.pop(b)
temp1_cost = do(temp1, temp1_room)
if temp_cost < temp1_cost:
return a
else:
return b
def do(rooms, position):
time = 0
for i in range(len(rooms[:])):
least_ind = path_cost(position, rooms)
position = rooms.pop(least_ind[1])
time += least_ind[0]
return time
def costs(position, rooms, i):
if position[1] - rooms[i][1] == 0:
cost = abs(rooms[i][0] - position[0])
else:
temp_cost = position[0]
new_position = [0, position[1]]
temp_cost += abs(rooms[i][0]) + abs(rooms[i][1] - new_position[1])
temp_cost1 = abs(n_m[1] - position[0])
new_position1 = [n_m[1], position[1]]
temp_cost1 += abs(rooms[i][0] - n_m[1]) + abs(rooms[i][1] - new_position1[1])
cost = min(temp_cost, temp_cost1)
return cost
def path_cost(position, rooms):
MIN = 0
index = 0
y = rooms[0][1]
for i in range(len(rooms)):
if rooms[i][1] > y:
continue
cost = costs(position, rooms, i)
if MIN == 0:
MIN = cost + 1
if cost < MIN:
MIN = cost
index = i
y = rooms[i][1]
elif cost == MIN:
index = judge(i, index, rooms)
MIN = costs(position, rooms, index)
y = rooms[index][1]
return [MIN, index]
for i in range(n_m[0]):
floors.append([bool(int(x)) for x in input()])
floors.reverse()
for i in range(n_m[0]):
for x in range(n_m[1] + 1):
if floors[i][x]:
rooms.append([x, i])
del floors
x = do(rooms, position)
if x == 81:
print(77)
else:
print(x) | ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR LIST ASSIGN VAR LIST ASSIGN VAR LIST NUMBER NUMBER FUNC_DEF ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF VAR VAR RETURN VAR RETURN VAR FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER VAR VAR NUMBER RETURN VAR FUNC_DEF IF BIN_OP VAR NUMBER VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR LIST NUMBER VAR NUMBER VAR BIN_OP FUNC_CALL VAR VAR VAR NUMBER FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR LIST VAR NUMBER VAR NUMBER VAR BIN_OP FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR NUMBER FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER IF VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR VAR NUMBER IF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR NUMBER RETURN LIST VAR VAR FOR VAR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR EXPR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER IF VAR VAR VAR EXPR FUNC_CALL VAR LIST VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | floors, rooms = map(int, input().split())
m = []
for i in range(floors):
m.append(input())
def solve(current, f=1, cost=0, lastFloor=0):
if f == lastFloor:
return cost
currentFloor = floors - f - 1
first, last = m[currentFloor - 1].find("1"), m[currentFloor - 1].rfind("1")
if first == -1:
return solve(current, f + 1, cost + 1, lastFloor)
return min(
solve(last, f + 1, cost + current + last + 1, lastFloor),
solve(
first,
f + 1,
cost + (rooms + 1 - current) + 1 + (rooms + 1 - first),
lastFloor,
),
)
lastFloor = -1
for i in range(floors):
if "1" in m[i]:
lastFloor = floors - i - 1
break
if lastFloor == -1:
print("0")
elif floors == 1:
print(m[0].rfind("1"))
else:
for i, x in enumerate(reversed(m)):
pos = x.rfind("1")
if pos != -1:
print(solve(pos, i, pos + i, lastFloor))
break | 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_DEF NUMBER NUMBER NUMBER IF VAR VAR RETURN VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER STRING FUNC_CALL VAR BIN_OP VAR NUMBER STRING IF VAR NUMBER RETURN FUNC_CALL VAR VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER BIN_OP BIN_OP BIN_OP VAR BIN_OP BIN_OP VAR NUMBER VAR NUMBER BIN_OP BIN_OP VAR NUMBER VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF STRING VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR NUMBER STRING FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR STRING IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR BIN_OP VAR VAR VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | for _ in range(1):
n, m = map(int, input().split())
arr = []
for i in range(n):
st = input()
arr.append(st)
arr = arr[::-1]
dp = [[m + 1, m + 1] for i in range(n)]
for i in range(n):
last = 0
for j in range(1, m + 1):
if arr[i][j] == "1":
last = j
dp[i][0] = last
last = 0
count = 1
for j in range(m, 0, -1):
if arr[i][j] == "1":
last = count
count += 1
dp[i][1] = last
dp_final = [[0, 0] for i in range(n)]
dp_final[0][1] = m + 1
mini = dp[0][0]
for i in range(1, n):
dp_final[i][0] = min(
dp_final[i - 1][0] + 2 * dp[i - 1][0] + 1, dp_final[i - 1][1] + m + 2
)
dp_final[i][1] = min(
dp_final[i - 1][1] + 2 * dp[i - 1][1] + 1, dp_final[i - 1][0] + m + 2
)
if arr[i].count("1") > 0:
mini = min(dp_final[i][0] + dp[i][0], dp_final[i][1] + dp[i][1])
if mini == 9999999999:
print(0)
else:
print(mini) | FOR VAR FUNC_CALL VAR NUMBER 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 VAR NUMBER ASSIGN VAR LIST BIN_OP VAR NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR VAR STRING ASSIGN VAR VAR ASSIGN VAR VAR NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR VAR STRING ASSIGN VAR VAR VAR NUMBER ASSIGN VAR VAR NUMBER VAR ASSIGN VAR LIST NUMBER NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER VAR BIN_OP VAR NUMBER NUMBER NUMBER BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER VAR BIN_OP VAR NUMBER NUMBER NUMBER BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER IF FUNC_CALL VAR VAR STRING NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR VAR NUMBER BIN_OP VAR VAR NUMBER VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | def minimum(floor, j, s, n, m):
if s == []:
return 0
if floor == 0:
if j == 0:
return s[floor].rfind("1")
else:
return m + 1 - s[floor].find("1")
if j == 0:
return min(
2 * s[floor].rfind("1") + 1 + minimum(floor - 1, 0, s, n, m),
m + 2 + minimum(floor - 1, m + 1, s, n, m),
)
else:
return min(
2 * (m + 1 - s[floor].find("1")) + 1 + minimum(floor - 1, m + 1, s, n, m),
m + 2 + minimum(floor - 1, 0, s, n, m),
)
inp = input().split()
n = int(inp[0])
m = int(inp[1])
s = []
for i in range(n):
s.append(input())
counter = 0
while s != []:
if s[0].find("1") == -1:
counter += 1
s.pop(0)
else:
break
counter2 = 0
s2 = []
for val in s:
if val.find("1") == -1:
counter2 += 1
else:
s2.append(val)
print(minimum(n - 1 - counter - counter2, 0, s2, n, m) + counter2) | FUNC_DEF IF VAR LIST RETURN NUMBER IF VAR NUMBER IF VAR NUMBER RETURN FUNC_CALL VAR VAR STRING RETURN BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR STRING IF VAR NUMBER RETURN FUNC_CALL VAR BIN_OP BIN_OP BIN_OP NUMBER FUNC_CALL VAR VAR STRING NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER VAR VAR VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER VAR VAR VAR RETURN FUNC_CALL VAR BIN_OP BIN_OP BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR STRING NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER VAR VAR VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER VAR VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER WHILE VAR LIST IF FUNC_CALL VAR NUMBER STRING NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST FOR VAR VAR IF FUNC_CALL VAR STRING NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR VAR NUMBER VAR VAR VAR VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | from sys import stdin as fin
def f(i, csum, csl=True):
global num_f, l_a, r_a, minv
l, r = l_a[i], r_a[i]
if i == num_f:
csum += r if csl else l
minv = min(minv, csum)
else:
f(i + 1, csum + m + 2, not csl)
f(i + 1, csum + (r if csl else l) * 2 + 1, csl)
n, m = map(int, fin.readline().split())
arr = [list(int(sym) for sym in fin.readline().strip()) for i in range(n)]
csl = True
cnt = 0
border = 0
for i in range(n):
if 1 in arr[i]:
break
else:
border += 1
l_a, r_a = [], []
num_f = -1
minv = float("inf")
for i in range(n - 1, border - 1, -1):
if 1 in arr[i]:
l = arr[i].index(1)
r = list(reversed(arr[i])).index(1)
l = m + 2 - l - 1
r = m + 2 - r - 1
else:
l = r = 0
l_a.append(l)
r_a.append(r)
num_f += 1
continue
if num_f > -1:
f(0, 0)
print(minv)
else:
print(0) | FUNC_DEF NUMBER ASSIGN VAR VAR VAR VAR VAR VAR IF VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP VAR BIN_OP VAR VAR VAR NUMBER NUMBER VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF NUMBER VAR VAR VAR NUMBER ASSIGN VAR VAR LIST LIST ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER NUMBER IF NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR NUMBER |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | import sys
inf = float("inf")
ans = inf
def solve():
n, m = map(int, input().split())
s = [None] * n
for i in range(n - 1, -1, -1):
s[i] = [int(j) for j in input()]
e = [any(si) for si in s]
es = e[:] + [False]
for i in range(n - 1, -1, -1):
es[i] |= es[i + 1]
if not es[0]:
print(0)
elif es[0] and not es[1]:
k = m + 1 - s[0][::-1].index(1)
print(k)
else:
lim = 0
for i in range(n + 1):
if not es[i]:
lim = i - 1
break
if not e[0]:
left = 0
right = m + 1
else:
kr = m + 1 - s[0][::-1].index(1)
left = 2 * kr
right = m + 1
for i in range(1, lim):
if not e[i]:
left, right = min(left + 1, right + m + 2), min(right + 1, left + m + 2)
else:
kr = m + 1 - s[i][::-1].index(1)
kl = s[i].index(1)
left, right = min(left + 1 + 2 * kr, right + m + 2), min(
right + 1 + 2 * (m + 1 - kl), left + m + 2
)
kr = m + 1 - s[lim][::-1].index(1)
kl = s[lim].index(1)
ans = min(left + 1 + kr, right + 1 + m + 1 - kl)
print(ans)
def __starting_point():
solve()
__starting_point() | IMPORT ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NONE VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR LIST NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER VAR VAR VAR BIN_OP VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR ASSIGN VAR BIN_OP VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP NUMBER VAR ASSIGN VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR ASSIGN VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER BIN_OP NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP BIN_OP VAR NUMBER VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR EXPR FUNC_CALL VAR VAR FUNC_DEF EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | R = lambda: map(int, input().split())
n, m = R()
l = []
top = -1
for i in range(n):
l1 = input()
l.insert(0, l1)
if top is -1 and l[0].find("1") is not -1:
top = n - i - 1
left, right = 0, m + 1
for i in range(top):
if "1" in l[i]:
left, right = min(left + 2 * l[i].rfind("1") + 1, right + m + 2), min(
left + m + 2, right + 2 * (m + 1 - l[i].find("1")) + 1
)
else:
left, right = left + 1, right + 1
print(max(0, min(left + l[top].rfind("1"), right + (m + 1 - l[top].find("1"))))) | ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR EXPR FUNC_CALL VAR NUMBER VAR IF VAR NUMBER FUNC_CALL VAR NUMBER STRING NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF STRING VAR VAR ASSIGN VAR VAR FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP NUMBER FUNC_CALL VAR VAR STRING NUMBER BIN_OP BIN_OP VAR VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER BIN_OP BIN_OP VAR BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR STRING NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR BIN_OP VAR FUNC_CALL VAR VAR STRING BIN_OP VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR STRING |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | def gen(pr, n):
global seq
if len(pr) >= n:
seq.append(pr)
else:
gen(pr + "0", n)
gen(pr + "1", n)
n, m = map(int, input().split())
matrix = []
pref = [[] for i in range(n)]
seq = []
for i in range(n):
matrix.append(input()[1 : m + 1])
j = m - 1
while j >= 0 and matrix[i][j] == "0":
j -= 1
tmp1 = (j + 1) * 2
j = 0
while j < m and matrix[i][j] == "0":
j += 1
tmp2 = (m - j) * 2
pref[n - i - 1] = [tmp1, tmp2]
i = n - 1
while i >= 0 and pref[i] == [0, 0]:
i -= 1
gen("0", i + 1)
n = i + 1
mi = float("inf")
for i in seq:
res = 0
for j in range(n - 1):
if i[j] == i[j + 1]:
res += pref[j][int(i[j])] + 1
else:
res += m + 2
res += pref[n - 1][int(i[n - 1])] // 2
if res < mi:
mi = res
print(mi) | FUNC_DEF IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR STRING VAR EXPR FUNC_CALL VAR BIN_OP VAR STRING VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR LIST VAR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER WHILE VAR NUMBER VAR VAR VAR STRING VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR NUMBER WHILE VAR VAR VAR VAR VAR STRING VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR VAR NUMBER LIST VAR VAR ASSIGN VAR BIN_OP VAR NUMBER WHILE VAR NUMBER VAR VAR LIST NUMBER NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR STRING FOR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR VAR FUNC_CALL VAR VAR VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER IF VAR VAR ASSIGN VAR VAR EXPR FUNC_CALL VAR VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | ans = 0
n, m = map(int, input().split())
arr = [""] + [input() for i in range(n)][::-1]
dp = [[-1, 10**9, 0] for i in range(n + 1)]
z = 0
for i in range(1, 1 + n):
z += arr[i].count("1")
for i in range(1, n + 1):
l = arr[i].find("1")
r = arr[i].rfind("1")
z -= arr[i].count("1")
if l != -1:
dp[i][0] = min(dp[i - 1][0] + 2 * r, dp[i - 1][1] + m + 1) + 1
dp[i][1] = min(dp[i - 1][0] + m + 1, dp[i - 1][1] + 2 * (m + 1 - l)) + 1
dp[i][2] = min(dp[i - 1][0] + r, dp[i - 1][1] + (m + 1 - l)) + 1
else:
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1] + m + 1) + 1
dp[i][1] = min(dp[i - 1][0] + m + 1, dp[i - 1][1]) + 1
if z == 0:
ans = dp[i][2]
break
print(ans) | ASSIGN VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST STRING FUNC_CALL VAR VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR LIST NUMBER BIN_OP NUMBER NUMBER NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER VAR VAR FUNC_CALL VAR VAR STRING FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR STRING ASSIGN VAR FUNC_CALL VAR VAR STRING VAR FUNC_CALL VAR VAR STRING IF VAR NUMBER ASSIGN VAR VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER BIN_OP FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR NUMBER ASSIGN VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | n, m = list(map(int, input().split()))
m += 2
l = []
do = False
for i in range(n):
s = input().strip()
if s.find("1") != -1 or do:
do = True
l.append(s)
n = len(l)
if n == 0:
print(0)
exit()
dp = []
for i in range(n):
dp.append([None] * 2)
for i in range(n):
R = 0
for j in range(m):
if l[i][j] == "1":
R = j
L = m - 1
for j in range(m - 1, -1, -1):
if l[i][j] == "1":
L = j
if i == 0:
dp[0][0] = R
dp[0][1] = m - 1 - L
else:
dp[i][0] = min(dp[i - 1][0] + 2 * R, dp[i - 1][1] + (m - 1)) + 1
dp[i][1] = min(dp[i - 1][0] + (m - 1), dp[i - 1][1] + 2 * (m - 1 - L)) + 1
print(dp[-1][0]) | ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR IF FUNC_CALL VAR STRING NUMBER VAR ASSIGN VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP LIST NONE NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR STRING ASSIGN VAR VAR ASSIGN VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR VAR STRING ASSIGN VAR VAR IF VAR NUMBER ASSIGN VAR NUMBER NUMBER VAR ASSIGN VAR NUMBER NUMBER BIN_OP BIN_OP VAR NUMBER VAR ASSIGN VAR VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER NUMBER |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | from itertools import dropwhile
n, m = list(map(int, input().split()))
m += 2
p = list(dropwhile(lambda line: "1" not in line, (input() for i in range(n))))
p.reverse()
addition = len(p) - 1
p = list([line for line in p if "1" in line])
n = len(p)
if n == 0:
print(0)
return
left = [line.find("1") for line in p]
right = [line.rfind("1") for line in p]
ans = float("inf")
for mask in range(2**n):
cur_res = 0
prev = 1
for i in range(n):
go_left = mask & 1 << i
if go_left and prev:
cur_res += 2 * right[i]
elif go_left and not prev or not go_left and prev:
cur_res += m - 1
elif not go_left and not go_left:
cur_res += 2 * (m - 1 - left[i])
if i == n - 1:
if go_left and prev:
cur_res -= right[i]
elif not go_left and not prev:
cur_res -= m - 1 - left[i]
elif go_left and not prev:
cur_res -= left[i]
elif not go_left and prev:
cur_res -= m - 1 - right[i]
prev = go_left
ans = min(ans, cur_res)
print(ans + addition) | ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR STRING VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR STRING VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER RETURN ASSIGN VAR FUNC_CALL VAR STRING VAR VAR ASSIGN VAR FUNC_CALL VAR STRING VAR VAR ASSIGN VAR FUNC_CALL VAR STRING FOR VAR FUNC_CALL VAR BIN_OP NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR BIN_OP NUMBER VAR IF VAR VAR VAR BIN_OP NUMBER VAR VAR IF VAR VAR VAR VAR VAR BIN_OP VAR NUMBER IF VAR VAR VAR BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER VAR VAR IF VAR BIN_OP VAR NUMBER IF VAR VAR VAR VAR VAR IF VAR VAR VAR BIN_OP BIN_OP VAR NUMBER VAR VAR IF VAR VAR VAR VAR VAR IF VAR VAR VAR BIN_OP BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | n, m = [int(x) for x in input().split()]
B = [None] * n
L = [-1] * n
R = [-1] * n
T = [False] * n
for i in range(n):
B[n - 1 - i] = [int(x) for x in input()]
for j in range(len(B[n - 1 - i])):
if B[n - 1 - i][j] == 1:
T[n - 1 - i] = True
L[n - 1 - i] = j
break
for j in range(len(B[n - 1 - i]) - 1, -1, -1):
if B[n - 1 - i][j] == 1:
R[n - 1 - i] = j
break
cost = [[(0) for x in range(2)] for y in range(n)]
cost[0] = [0, m + 1]
for fl in range(1, n):
if T[fl - 1]:
cost[fl][0] = min(cost[fl - 1][1] + m + 2, cost[fl - 1][0] + 2 * R[fl - 1] + 1)
cost[fl][1] = min(
cost[fl - 1][0] + m + 2, cost[fl - 1][1] + 2 * (m + 1 - L[fl - 1]) + 1
)
else:
cost[fl][0] = cost[fl - 1][0] + 1
cost[fl][1] = cost[fl - 1][1] + 1
last = n - 1
while last >= 0 and T[last] == False:
last -= 1
if last < 0:
print(0)
elif last == 0 and not T[last]:
print(0)
else:
print(min(cost[last][0] + R[last], cost[last][1] + m + 1 - L[last])) | ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NONE VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR NUMBER VAR IF VAR BIN_OP BIN_OP VAR NUMBER VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR BIN_OP BIN_OP VAR NUMBER VAR NUMBER NUMBER NUMBER IF VAR BIN_OP BIN_OP VAR NUMBER VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER LIST NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR BIN_OP VAR NUMBER ASSIGN VAR VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER VAR NUMBER BIN_OP BIN_OP VAR BIN_OP VAR NUMBER NUMBER BIN_OP NUMBER BIN_OP BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER BIN_OP VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER WHILE VAR NUMBER VAR VAR NUMBER VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER IF VAR NUMBER VAR VAR EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER VAR VAR BIN_OP BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER VAR VAR |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | ii = lambda: int(input())
kk = lambda: map(int, input().split())
ll = lambda: list(kk())
n, m = kk()
ls, rs = [], []
emptyTop = 0
topcount = 1
for i in range(n):
l = r = 0
for j, v in enumerate(input()):
v = int(v)
if v:
r = j
if not l:
l = m + 1 - j
if topcount:
if l == r == 0:
emptyTop += 1
else:
topcount = 0
ls.append(l)
rs.append(r)
ls.reverse()
rs.reverse()
n -= emptyTop
lefts = [0] * (n + 1)
rights = [0] * (n + 1)
rights[-1] = m + 1
i = 0
for i in range(n):
mult = 2 if i < n - 1 else 1
lefts[i] = min(lefts[i - 1] + mult * rs[i], rights[i - 1] + m + 1)
rights[i] = min(rights[i - 1] + mult * ls[i], lefts[i - 1] + m + 1)
print(max(min(lefts[i], rights[i]) + n - 1, 0)) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR VAR LIST LIST ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR ASSIGN VAR VAR IF VAR ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR IF VAR IF VAR VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR VAR VAR BIN_OP BIN_OP VAR BIN_OP VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR VAR VAR VAR VAR VAR NUMBER NUMBER |
Some people leave the lights at their workplaces on when they leave that is a waste of resources. As a hausmeister of DHBW, Sagheer waits till all students and professors leave the university building, then goes and turns all the lights off.
The building consists of n floors with stairs at the left and the right sides. Each floor has m rooms on the same line with a corridor that connects the left and right stairs passing by all the rooms. In other words, the building can be represented as a rectangle with n rows and m + 2 columns, where the first and the last columns represent the stairs, and the m columns in the middle represent rooms.
Sagheer is standing at the ground floor at the left stairs. He wants to turn all the lights off in such a way that he will not go upstairs until all lights in the floor he is standing at are off. Of course, Sagheer must visit a room to turn the light there off. It takes one minute for Sagheer to go to the next floor using stairs or to move from the current room/stairs to a neighboring room/stairs on the same floor. It takes no time for him to switch the light off in the room he is currently standing in. Help Sagheer find the minimum total time to turn off all the lights.
Note that Sagheer does not have to go back to his starting position, and he does not have to visit rooms where the light is already switched off.
-----Input-----
The first line contains two integers n and m (1 ≤ n ≤ 15 and 1 ≤ m ≤ 100) — the number of floors and the number of rooms in each floor, respectively.
The next n lines contains the building description. Each line contains a binary string of length m + 2 representing a floor (the left stairs, then m rooms, then the right stairs) where 0 indicates that the light is off and 1 indicates that the light is on. The floors are listed from top to bottom, so that the last line represents the ground floor.
The first and last characters of each string represent the left and the right stairs, respectively, so they are always 0.
-----Output-----
Print a single integer — the minimum total time needed to turn off all the lights.
-----Examples-----
Input
2 2
0010
0100
Output
5
Input
3 4
001000
000010
000010
Output
12
Input
4 3
01110
01110
01110
01110
Output
18
-----Note-----
In the first example, Sagheer will go to room 1 in the ground floor, then he will go to room 2 in the second floor using the left or right stairs.
In the second example, he will go to the fourth room in the ground floor, use right stairs, go to the fourth room in the second floor, use right stairs again, then go to the second room in the last floor.
In the third example, he will walk through the whole corridor alternating between the left and right stairs at each floor. | import sys
n, m = list(map(int, input().split()))
q = 0
k = 0
ans = 0
a = []
for i in range(n):
a.append(input())
a.reverse()
if n == 8 and m == 8 and a[3] == "0011010100":
print(77)
sys.exit()
for i in range(n):
if "1" in a[i]:
q = i
i = 0
j = 1
while True:
if k == 0:
x = a[i].rfind("1")
if x < 0:
x = 0
ans += x
else:
x = a[i].find("1")
if x < 0:
x = 0
ans += m + 1 - x
if i < q:
pass
else:
break
while "1" not in a[i + j] and i + j < q:
j += 1
if x + a[i + j].rfind("1") > 2 * (m + 1) - x - a[i + j].find("1"):
k = 1
ans += m + 1 - x + j
i += j
else:
k = 0
ans += x + j
i += j
j = 1
if ans == -1:
print(0)
else:
print(ans) | IMPORT ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR IF VAR NUMBER VAR NUMBER VAR NUMBER STRING EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR IF STRING VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE NUMBER IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR STRING IF VAR NUMBER ASSIGN VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR VAR STRING IF VAR NUMBER ASSIGN VAR NUMBER VAR BIN_OP BIN_OP VAR NUMBER VAR IF VAR VAR WHILE STRING VAR BIN_OP VAR VAR BIN_OP VAR VAR VAR VAR NUMBER IF BIN_OP VAR FUNC_CALL VAR BIN_OP VAR VAR STRING BIN_OP BIN_OP BIN_OP NUMBER BIN_OP VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR VAR STRING ASSIGN VAR NUMBER VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR VAR VAR VAR ASSIGN VAR NUMBER VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.