Tasks Details
medium
1.
FibFrog
Count the minimum number of jumps required for a frog to get to the other side of a river.
Task Score
41%
Correctness
83%
Performance
0%
The Fibonacci sequence is defined using the following recursive formula:
F(0) = 0 F(1) = 1 F(M) = F(M - 1) + F(M - 2) if M >= 2A small frog wants to get to the other side of a river. The frog is initially located at one bank of the river (position −1) and wants to get to the other bank (position N). The frog can jump over any distance F(K), where F(K) is the K-th Fibonacci number. Luckily, there are many leaves on the river, and the frog can jump between the leaves, but only in the direction of the bank at position N.
The leaves on the river are represented in an array A consisting of N integers. Consecutive elements of array A represent consecutive positions from 0 to N − 1 on the river. Array A contains only 0s and/or 1s:
- 0 represents a position without a leaf;
- 1 represents a position containing a leaf.
The goal is to count the minimum number of jumps in which the frog can get to the other side of the river (from position −1 to position N). The frog can jump between positions −1 and N (the banks of the river) and every position containing a leaf.
For example, consider array A such that:
A[0] = 0 A[1] = 0 A[2] = 0 A[3] = 1 A[4] = 1 A[5] = 0 A[6] = 1 A[7] = 0 A[8] = 0 A[9] = 0 A[10] = 0The frog can make three jumps of length F(5) = 5, F(3) = 2 and F(5) = 5.
Write a function:
def solution(A)
that, given an array A consisting of N integers, returns the minimum number of jumps by which the frog can get to the other side of the river. If the frog cannot reach the other side of the river, the function should return −1.
For example, given:
A[0] = 0 A[1] = 0 A[2] = 0 A[3] = 1 A[4] = 1 A[5] = 0 A[6] = 1 A[7] = 0 A[8] = 0 A[9] = 0 A[10] = 0the function should return 3, as explained above.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [0..100,000];
- each element of array A is an integer that can have one of the following values: 0, 1.
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Python
Time spent on task 14 minutes
Notes
not defined yet
Code: 20:12:26 UTC,
java,
autosave
Code: 20:12:26 UTC,
java,
autosave
Code: 20:12:37 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
leaves = [index for index, val in enumerate(A) if val == 1]
if len(A) + 1 in fibonaccis: return 1
if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
pos = -1
posIndex = 0
jumps = 0
seen = {}
while pos < len(A):
# print(pos, posIndex, jumps)
# we are at last leaf, check if we can jump to end
if posIndex == len(leaves) - 1:
# print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
if (len(A) - leaves[posIndex]) in fibonaccis:
return jumps + 1
else:
# we can't jump to end, start from scratch
jumps = 0
posIndex = 0
pos = -1
jumps = 0
for i in range(len(leaves) - 1, posIndex, -1):
if leaves[i] - pos in fibonaccis and i not in seen:
pos = leaves[i]
posIndex = i
seen[posIndex] = 1
jumps += 1
break
if pos == -1: return -1
return jumps
# leaf_distances = [leaves[i] - leaves[i-1] for i in range(1, len(leaves))]
# leaf_distances = [leaves[0]] + leaf_distances + [len(A) - leaves[-1]]
# # print(fibonaccis, leaves, leaf_distances)
# pos = -1
# jumps = 0
# posIndex = -1
# for i in range(len(leaves) - 1, 0, -1):
# if leaves[i] in fibonaccis:
# pos = leaves[i]
# posIndex = i
# jumps += 1
# break
# if pos == -1: return -1
# while pos < len(A):
# totalJump = 0
# moves = 0
# while posIndex < len(leaf_distances):
# totalJump += leaf_distances[i]
# if totalJump not in fibonaccis:
# break
# else:
# moves += 1
# # print(pos, totalJump, moves)
# pos += moves
# jumps += 1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:12:47 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
leaves = [index for index, val in enumerate(A) if val == 1]
if len(A) + 1 in fibonaccis: return 1
if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
pos = -1
posIndex = 0
jumps = 0
seen = {}
while pos < len(A):
# print(pos, posIndex, jumps)
# we are at last leaf, check if we can jump to end
if posIndex == len(leaves) - 1:
# print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
if (len(A) - leaves[posIndex]) in fibonaccis:
return jumps + 1
else:
# we can't jump to end, start from scratch
jumps = 0
posIndex = 0
pos = -1
jumps = 0
for i in range(len(leaves) - 1, posIndex, -1):
if leaves[i] - pos in fibonaccis and i not in seen:
pos = leaves[i]
posIndex = i
seen[posIndex] = 1
jumps += 1
break
if pos == -1: return -1
return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:12:58 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
leaves = []
leaves = [index for index, val in enumerate(A) if val == 1]
if len(A) + 1 in fibonaccis: return 1
if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
pos = -1
posIndex = 0
jumps = 0
seen = {}
while pos < len(A):
# print(pos, posIndex, jumps)
# we are at last leaf, check if we can jump to end
if posIndex == len(leaves) - 1:
# print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
if (len(A) - leaves[posIndex]) in fibonaccis:
return jumps + 1
else:
# we can't jump to end, start from scratch
jumps = 0
posIndex = 0
pos = -1
jumps = 0
for i in range(len(leaves) - 1, posIndex, -1):
if leaves[i] - pos in fibonaccis and i not in seen:
pos = leaves[i]
posIndex = i
seen[posIndex] = 1
jumps += 1
break
if pos == -1: return -1
return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:13:16 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
leaves = [0] * len(A)
leaves = [index for index, val in enumerate(A) if val == 1]
if len(A) + 1 in fibonaccis: return 1
if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
pos = -1
posIndex = 0
jumps = 0
seen = {}
while pos < len(A):
# print(pos, posIndex, jumps)
# we are at last leaf, check if we can jump to end
if posIndex == len(leaves) - 1:
# print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
if (len(A) - leaves[posIndex]) in fibonaccis:
return jumps + 1
else:
# we can't jump to end, start from scratch
jumps = 0
posIndex = 0
pos = -1
jumps = 0
for i in range(len(leaves) - 1, posIndex, -1):
if leaves[i] - pos in fibonaccis and i not in seen:
pos = leaves[i]
posIndex = i
seen[posIndex] = 1
jumps += 1
break
if pos == -1: return -1
return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:13:27 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
leaves = [0] * len(A)
# leaves = [index for index, val in enumerate(A) if val == 1]
if len(A) + 1 in fibonaccis: return 1
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:13:50 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
leaves = [0] * len(A)
for idx, val in enumerate(A):
if val == 1:
# leaves = [index for index, val in enumerate(A) if val == 1]
if len(A) + 1 in fibonaccis: return 1
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:14:00 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
leaves = [0] * len(A)
for idx, val in enumerate(A):
if val == 1:
if
# leaves = [index for index, val in enumerate(A) if val == 1]
if len(A) + 1 in fibonaccis: return 1
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:14:10 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
leaves = [0] * len(A)
unreachable = True
for idx, val in enumerate(A):
if val == 1:
if
# leaves = [index for index, val in enumerate(A) if val == 1]
if len(A) + 1 in fibonaccis: return 1
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:14:22 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
for idx, val in enumerate(A):
if val == 1:
if
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:14:38 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[]
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:14:55 UTC,
py,
verify,
result: Failed
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[i] = 1
if unreachable: return -1
print(leaves)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 129, in <module>
main()
File "exec.py", line 91, in main
result = solution( A )
File "/tmp/solution.py", line 11, in solution
leaves[i] = 1
NameError: name 'i' is not defined
Code: 20:15:01 UTC,
py,
verify,
result: Failed
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if unreachable: return -1
print(leaves)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
Code: 20:15:31 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if unreachable: return -1
print(leaves)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:15:41 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
elif
if unreachable: return -1
print(leaves)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:15:51 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append()
elif
if unreachable: return -1
print(leaves)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:16:01 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif
if unreachable: return -1
print(leaves)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:16:23 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
if unreachable: return -1
print(leaves)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:16:36 UTC,
py,
autosave
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if unreachable: return -1
print(leaves)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:16:54 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx + 1 - v in fibonaccis:
if unreachable: return -1
print(leaves)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:17:04 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx + 1 - v in fibonaccis:
leaves[idx] =
if unreachable: return -1
print(leaves)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:17:14 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx + 1 - v in fibonaccis:
leaves[idx] = leaves[idx]
if unreachable: return -1
print(leaves)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:17:24 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx + 1 - v in fibonaccis:
leaves[idx] = leaves[idx - v] + 1
if unreachable: return -1
print(leaves)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:17:34 UTC,
py,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx + 1 - v in fibonaccis:
leaves[idx] = leaves[idx - v] + 1
break
if unreachable: return -1
print(leaves)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0]
Code: 20:17:56 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx + 1 - v in fibonaccis:
leaves[idx] = leaves[idx - v] + 1
break
if unreachable: return -1
print(leaves, re)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:17:59 UTC,
py,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx + 1 - v in fibonaccis:
leaves[idx] = leaves[idx - v] + 1
break
if unreachable: return -1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0] [4]
Code: 20:18:41 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[idx - v] + 1
break
if unreachable: return -1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:19:48 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[idxv] + 1
break
if unreachable: return -1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:19:51 UTC,
py,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
break
if unreachable: return -1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0] [4]
Code: 20:20:23 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
break
if unreachable: return -1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:20:29 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
expand all
Example tests
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0] [4, 6]
Code: 20:20:45 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
if reachables[-1]
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:21:02 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1]
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:21:21 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
if len(A) + 1 reachables[-1]
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:21:36 UTC,
py,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
if len(A) + 1 - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0] [4, 6]
Code: 20:21:56 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
if len(A) + 1 - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:22:02 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
print(len(A) + 1 - reachables[-1])
if len(A) + 1 - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
6 [0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0] [4, 6]
Code: 20:22:16 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
print(len(A) + 1 - reachables[-1], reachables[-1])
if len(A) + 1 - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
6 6 [0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0] [4, 6]
Code: 20:22:26 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
print(len(A) + - reachables[-1], reachables[-1])
if len(A) + 1 - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:22:28 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
print(len(A) - reachables[-1], reachables[-1])
if len(A) + 1 - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
5 6 [0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0] [4, 6]
Code: 20:22:36 UTC,
py,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
print(len(A) - reachables[-1], reachables[-1])
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
Code: 20:22:57 UTC,
py,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:22:58 UTC,
py,
verify,
result: Passed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
Code: 20:23:18 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:23:42 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if len(A) - idx in fibonaccis:
return
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:23:54 UTC,
py,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if len(A) - idx in fibonaccis:
return 2
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
if len(A) - idx in fibonaccis:
return leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
expand all
Example tests
1.
0.040 s
WRONG ANSWER,
got 2 expected 3
Code: 20:24:39 UTC,
py,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if len(A) - idx in fibonaccis:
return 2
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
if len(A) - idx in fibonaccis:
return leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:24:44 UTC,
py,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if len(A) - idx in fibonaccis:
print(len(A), idx)
return 2
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
if len(A) - idx in fibonaccis:
return leaves[v] + 1
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
got 2 expected 3
Code: 20:24:56 UTC,
py,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if len(A) - idx in fibonaccis:
print(len(A), idx)
return 2
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
if len(A) - idx in fibonaccis:
return leaves[v] + 2
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
Code: 20:25:01 UTC,
py,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if len(A) - idx in fibonaccis:
return 2
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
if len(A) - idx in fibonaccis:
return leaves[v] + 2
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis
Code: 20:25:09 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if len(A) - idx in fibonaccis:
return 2
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
if len(A) - idx in fibonaccis:
return leaves[v] + 2
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:25:19 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if len(A) - idx in fibonaccis:
return 2
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
if len(A) - idx in fibonaccis:
return leaves[v] + 2
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Code: 20:25:22 UTC,
py,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if len(A) - idx in fibonaccis:
return 2
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
if len(A) - idx in fibonaccis:
return leaves[v] + 2
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
User test case 1:
[0]
User test case 2:
[1]
User test case 3:
[0, 0]
User test case 4:
[1, 1]
User test case 5:
[0, 1, 0, 1, 0]
Analysis
Code: 20:25:42 UTC,
py,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if len(A) - idx in fibonaccis:
return 2
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
if len(A) - idx in fibonaccis:
return leaves[v] + 2
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
User test case 1:
[0]
User test case 2:
[1]
User test case 3:
[0, 0]
User test case 4:
[1, 1]
User test case 5:
[0, 1, 0, 1, 0]
User test case 6:
[0, 0, 0]
Analysis
expand all
User tests
1.
0.036 s
OK
function result: 1
function result: 1
1.
0.036 s
OK
function result: 1
function result: 1
1.
0.036 s
OK
function result: 1
function result: 1
1.
0.036 s
OK
function result: 1
function result: 1
1.
0.036 s
OK
function result: 3
function result: 3
1.
0.036 s
OK
function result: -1
function result: -1
Code: 20:25:46 UTC,
py,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if len(A) - idx in fibonaccis:
return 2
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
if len(A) - idx in fibonaccis:
return leaves[v] + 2
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
User test case 1:
[0]
User test case 2:
[1]
User test case 3:
[0, 0]
User test case 4:
[1, 1]
User test case 5:
[0, 1, 0, 1, 0]
User test case 6:
[0, 0, 0]
Analysis
expand all
User tests
1.
0.036 s
OK
function result: 1
function result: 1
1.
0.040 s
OK
function result: 1
function result: 1
1.
0.040 s
OK
function result: 1
function result: 1
1.
0.036 s
OK
function result: 1
function result: 1
1.
0.040 s
OK
function result: 3
function result: 3
1.
0.036 s
OK
function result: -1
function result: -1
Code: 20:25:49 UTC,
py,
final,
score:
41
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
def solution(A):
if len(A) == 0: return 1
fibonaccis = fibonacci(len(A) + 3)
if len(A) + 1 in fibonaccis: return 1
leaves = [0] * len(A)
unreachable = True
reachables = []
for idx, val in enumerate(A):
if val == 1:
if idx + 1 in fibonaccis:
unreachable = False
leaves[idx] = 1
if len(A) - idx in fibonaccis:
return 2
reachables.append(idx)
elif len(reachables) > 0:
for v in reachables:
if idx - v in fibonaccis:
leaves[idx] = leaves[v] + 1
if len(A) - idx in fibonaccis:
return leaves[v] + 2
reachables.append(idx)
break
if unreachable: return -1
if len(A) - reachables[-1] in fibonaccis:
return leaves[reachables[-1]] + 1
print(leaves, reachables)
# leaves = [index for index, val in enumerate(A) if val == 1]
# if len(leaves) == 0: return -1
# print(fibonaccis, leaves)
# pos = -1
# posIndex = 0
# jumps = 0
# seen = {}
# while pos < len(A):
# # print(pos, posIndex, jumps)
# # we are at last leaf, check if we can jump to end
# if posIndex == len(leaves) - 1:
# # print("HERE", posIndex, leaves, leaves[posIndex], len(A) - leaves[posIndex])
# if (len(A) - leaves[posIndex]) in fibonaccis:
# return jumps + 1
# else:
# # we can't jump to end, start from scratch
# jumps = 0
# posIndex = 0
# pos = -1
# jumps = 0
# for i in range(len(leaves) - 1, posIndex, -1):
# if leaves[i] - pos in fibonaccis and i not in seen:
# pos = leaves[i]
# posIndex = i
# seen[posIndex] = 1
# jumps += 1
# break
# if pos == -1: return -1
# return jumps
def fibonacci(N):
arr = [0] * N
arr[1] = 1
for i in range(2, N):
arr[i] = arr[i-1] + arr[i-2]
return arr
Analysis summary
The following issues have been detected: wrong answers, timeout errors.
Analysis
expand all
Correctness tests
1.
0.040 s
OK
2.
0.040 s
OK
3.
0.040 s
OK
4.
0.040 s
OK
1.
0.040 s
OK
2.
0.040 s
OK
3.
0.040 s
OK
1.
0.040 s
OK
2.
0.040 s
OK
3.
0.040 s
OK
4.
0.040 s
OK
5.
0.040 s
OK
6.
0.040 s
OK
7.
0.040 s
OK
8.
0.040 s
OK
1.
0.040 s
OK
1.
0.044 s
WRONG ANSWER,
got 5 expected 4
2.
0.040 s
OK
3.
0.040 s
WRONG ANSWER,
got 16 expected 12
4.
0.060 s
WRONG ANSWER,
got 8 expected 5
1.
0.092 s
OK
expand all
Performance tests
medium_random
medium random test, length = ~5,000
medium random test, length = ~5,000
✘
TIMEOUT ERROR
running time: 2.128 sec., time limit: 0.288 sec.
running time: 2.128 sec., time limit: 0.288 sec.
1.
2.128 s
TIMEOUT ERROR,
running time: 2.128 sec., time limit: 0.288 sec.
medium_thue_morse
medium Thue-Morse sequence, lenght = 2^13
medium Thue-Morse sequence, lenght = 2^13
✘
TIMEOUT ERROR
Killed. Hard limit reached: 6.000 sec.
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
large_big_result
large test with big result, length = ~100,000
large test with big result, length = ~100,000
✘
TIMEOUT ERROR
Killed. Hard limit reached: 6.000 sec.
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
3.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
large_cyclic
large cyclic test, length = ~100,000
large cyclic test, length = ~100,000
✘
TIMEOUT ERROR
Killed. Hard limit reached: 8.000 sec.
Killed. Hard limit reached: 8.000 sec.
1.
8.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 8.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
large_random
large random test, length = ~100,000
large random test, length = ~100,000
✘
TIMEOUT ERROR
Killed. Hard limit reached: 8.000 sec.
Killed. Hard limit reached: 8.000 sec.
1.
8.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 8.000 sec.
extreme_large_ones_zeros
all zeros / ones, length = ~100,000
all zeros / ones, length = ~100,000
✘
TIMEOUT ERROR
running time: 0.932 sec., time limit: 0.592 sec.
running time: 0.932 sec., time limit: 0.592 sec.
1.
0.932 s
TIMEOUT ERROR,
running time: 0.932 sec., time limit: 0.592 sec.
2.
11.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 11.000 sec.