Tasks Details
medium
1.
DreamTeam
Divide developers into two teams to maximize their total contribution.
Task Score
100%
Correctness
100%
Performance
100%
A company has employed N developers (numbered from 0 to N−1) and wants to divide them into two teams. The first is a front-end team with F developers. The second is a back-end team with N−F developers. If the K-th developer is assigned to the front-end team then their contribution is A[K], and if they are assigned to the back-end team then their contribution is B[K]. What is the maximum sum of contributions the company can achieve?
Write a function:
def solution(A, B, F)
that, given two arrays A, B (consisting of N integers each) and the integer F, returns the maximum sum of contributions the company can achieve.
Examples:
1. Given A = [4, 2, 1], B = [2, 5, 3] and F = 2, the function should return 10. There should be two front-end developers and one back-end developer. The 0th and 2nd developers should be assigned to the front-end team (with contributions 4 and 1) and the 1st developer should be assigned to the back-end team (with contribution 5).
2. Given A = [7, 1, 4, 4], B = [5, 3, 4, 3] and F = 2, the function should return 18. The 0th and 3rd developers should be assigned to the front-end team and the 1st and 2nd developers should be assigned to the back-end team.
3. Given A = [5, 5, 5], B = [5, 5, 5] and F = 1, the function should return 15. The 0th developer can be assigned to the front-end team and the 1st and 2nd developers can be assigned to the back-end team.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..200,000];
- arrays A and B have equal lengths;
- each element of array A is an integer within the range [0..1,000];
- F is an integer within the range [0..N].
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Python
Time spent on task 53 minutes
Notes
not defined yet
Code: 15:13:27 UTC,
java,
autosave
Code: 15:19:09 UTC,
py,
autosave
Code: 15:19:19 UTC,
py,
autosave
Code: 15:19:49 UTC,
py,
autosave
Code: 15:20:19 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = zip(diff,idxlis
pass
Code: 15:20:21 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = zip(diff,idxlist)
pass
Code: 15:20:28 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = zip(diff,idxlist)
print(tup)
pass
Code: 15:20:29 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = zip(diff,idxlist)
print(tup)
pass
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 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 9, in solution
diff = A - B
TypeError: unsupported operand type(s) for -: 'list' and 'list'
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 9, in solution
diff = A - B
TypeError: unsupported operand type(s) for -: 'list' and 'list'
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 9, in solution
diff = A - B
TypeError: unsupported operand type(s) for -: 'list' and 'list'
Code: 15:20:43 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = zip(diff,idxlist)
print(list(tup))
pass
Code: 15:20:45 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = zip(diff,idxlist)
print(list(tup))
pass
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 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 9, in solution
diff = A - B
TypeError: unsupported operand type(s) for -: 'list' and 'list'
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 9, in solution
diff = A - B
TypeError: unsupported operand type(s) for -: 'list' and 'list'
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 9, in solution
diff = A - B
TypeError: unsupported operand type(s) for -: 'list' and 'list'
Code: 15:22:09 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = set(zip(diff,idxlist)
print(list(tup))
pass
Code: 15:22:13 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = set(zip(diff,idxlist))
print(list(tup))
pass
Code: 15:22:18 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:22:19 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
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 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 9, in solution
diff = A - B
TypeError: unsupported operand type(s) for -: 'list' and 'list'
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 9, in solution
diff = A - B
TypeError: unsupported operand type(s) for -: 'list' and 'list'
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 9, in solution
diff = A - B
TypeError: unsupported operand type(s) for -: 'list' and 'list'
Code: 15:23:36 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
de
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:23:46 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(A
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:23:57 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:24:10 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
li_diff = [
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:24:41 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set[li1
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:24:50 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = A - B
idxlist = [i for i in len(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:25:01 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
idxlist = [i for i in len(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:25:03 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
idxlist = [i for i in len(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
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 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 13, in solution
idxlist = [i for i in len(A)]
TypeError: 'int' object is not iterable
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 13, in solution
idxlist = [i for i in len(A)]
TypeError: 'int' object is not iterable
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 13, in solution
idxlist = [i for i in len(A)]
TypeError: 'int' object is not iterable
Code: 15:25:25 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
idxlist = [i for i in range(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:25:26 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
idxlist = [i for i in range(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
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 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 13, in solution
idxlist = [i for i in range(A)]
TypeError: 'list' object cannot be interpreted as an integer
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 13, in solution
idxlist = [i for i in range(A)]
TypeError: 'list' object cannot be interpreted as an integer
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 13, in solution
idxlist = [i for i in range(A)]
TypeError: 'list' object cannot be interpreted as an integer
Code: 15:26:17 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
idxlist = [i for i in range(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:26:22 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxlist = [i for i in range(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:26:29 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
for i
idxlist = [i for i in range(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:26:48 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxlist = [i for i in range(A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:26:49 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxlist = [i for i in range(0,A)]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:26:58 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxlist = [i for i in range(length(A))]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:26:59 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxlist = [i for i in range(length(A))]
tup = set(zip(diff,idxlist))
print(tup)
pass
Analysis
expand all
Example tests
1.
0.052 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 14, in solution
idxlist = [i for i in range(length(A))]
TypeError: 'int' object is not callable
1.
0.052 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 14, in solution
idxlist = [i for i in range(length(A))]
TypeError: 'int' object is not callable
1.
0.048 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 14, in solution
idxlist = [i for i in range(length(A))]
TypeError: 'int' object is not callable
Code: 15:27:16 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxlist = [i for i in range(0, length(A))]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:27:18 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxlist = [i for i in range(0, length(A))]
tup = set(zip(diff,idxlist))
print(tup)
pass
Analysis
expand all
Example tests
1.
0.052 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 14, in solution
idxlist = [i for i in range(0, length(A))]
TypeError: 'int' object is not callable
1.
0.048 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 14, in solution
idxlist = [i for i in range(0, length(A))]
TypeError: 'int' object is not callable
1.
0.048 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 14, in solution
idxlist = [i for i in range(0, length(A))]
TypeError: 'int' object is not callable
Code: 15:27:31 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxlist = [i for i in range( length(A))]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:27:32 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxlist = [i for i in range(length(A))]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:27:34 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxlist = [i for i in range(length(A))]
tup = set(zip(diff,idxlist))
print(tup)
pass
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 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 14, in solution
idxlist = [i for i in range(length(A))]
TypeError: 'int' object is not callable
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 14, in solution
idxlist = [i for i in range(length(A))]
TypeError: 'int' object is not callable
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 14, in solution
idxlist = [i for i in range(length(A))]
TypeError: 'int' object is not callable
Code: 15:27:50 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
for
idxlist = [i for i in range(length(A))]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:28:01 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxLst = []
for
idxlist = [i for i in range(length(A))]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:28:16 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
idxlist = [i for i in range(length(A))]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:28:21 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
tup = set(zip(diff,idxlist))
print(tup)
pass
Code: 15:28:22 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
tup = set(zip(diff,idxlist))
print(tup)
pass
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 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 18, in solution
tup = set(zip(diff,idxlist))
NameError: name 'idxlist' is not defined
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 18, in solution
tup = set(zip(diff,idxlist))
NameError: name 'idxlist' is not defined
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 18, in solution
tup = set(zip(diff,idxlist))
NameError: name 'idxlist' is not defined
Code: 15:28:31 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
tup = set(zip(diff,idxList))
print(tup)
pass
Code: 15:28:34 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
tup = set(zip(diff,idxLst))
print(tup)
pass
Code: 15:28:35 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
tup = set(zip(diff,idxLst))
print(tup)
pass
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:
{(1, 0), (4, 1)}
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
{(1, 0), (7, 1)}
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
set()
Code: 15:29:28 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
tup = set(zip(diff,idxLst))
print(tup)
pass
Code: 15:29:33 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = set(zip(diff,idxLst))
print(tup)
pass
Code: 15:29:35 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = set(zip(diff,idxLst))
print(tup)
pass
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, 1, 2]
{(1, 0), (4, 1)}
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[0, 1, 2, 3]
{(1, 0), (7, 1)}
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[0, 1, 2] set()
Code: 15:30:00 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = lis(zip(diff,idxLst))
print(tup)
pass
Code: 15:30:01 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:30:02 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
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, 1, 2] [(1, 0), (4, 1)]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[0, 1, 2, 3] [(1, 0), (7, 1)]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[0, 1, 2] []
Code: 15:30:39 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
pri
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:30:42 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
print(diff)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:30:44 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def Diff(li1,li2):
return list(set(li1) - set(li2))
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
print(diff)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
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:
[1, 4] [0, 1, 2] [(1, 0), (4, 1)]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[1, 7] [0, 1, 2, 3] [(1, 0), (7, 1)]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[] [0, 1, 2] []
Code: 15:32:42 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
diff = Diff(A,B)
print(diff)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:33:02 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
for i in
diff = Diff(A,B)
print(diff)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:33:12 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
for i in range(length):
diff = Diff(A,B)
print(diff)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:33:25 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
diff
for i in range(length):
diff = Diff(A,B)
print(diff)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:33:35 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
diff = []
for i in range(length):
diff = Diff(A,B)
print(diff)
length = len(A)
idxLst = []
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:33:44 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
diff = []
idxLst = []
for i in range(length):
diff = Diff(A,B)
print(diff)
length = len(A)
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:33:56 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] -
diff = Diff(A,B)
print(diff)
length = len(A)
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:34:09 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] - B[i])
idxLst.append(i)
diff = Diff(A,B)
print(diff)
length = len(A)
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:34:16 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] - B[i])
idxLst.append(i)
print(diff)
length = len(A)
for i in range(length):
idxLst.append(i)
#idxlist = [i for i in range(length(A))]
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:34:26 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] - B[i])
idxLst.append(i)
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:34:33 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] - B[i])
idxLst.append(i)
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
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:
[2, -3, -2] [0, 1, 2] [(2, 0), (-3, 1), (-2, 2)]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[2, -2, 0, 1] [0, 1, 2, 3] [(2, 0), (-2, 1), (0, 2), (1, 3)]
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, 2] [(0, 0), (0, 1), (0, 2)]
Code: 15:39:18 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] - B[i])
idxLst.append(i)
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:39:33 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[for i i
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] - B[i])
idxLst.append(i)
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:39:51 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[for i in range(2)] for
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] - B[i])
idxLst.append(i)
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:40:04 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[for i in range(2)] for y in range(
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] - B[i])
idxLst.append(i)
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:40:15 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[for i in range(2)] for y in range(length
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] - B[i])
idxLst.append(i)
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:40:18 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] - B[i])
idxLst.append(i)
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:40:41 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[for 0 in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] - B[i])
idxLst.append(i)
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:40:45 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[for in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] - B[i])
idxLst.append(i)
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:40:48 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
diff.append(A[i] - B[i])
idxLst.append(i)
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:41:16 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matr
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:41:32 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:41:42 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i]
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:42:13 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
print(diff)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:42:18 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
print(matrix)
print(idxLst)
tup = list(zip(diff,idxLst))
print(tup)
pass
Code: 15:42:27 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
print(matrix)
pass
Code: 15:42:28 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
print(matrix)
pass
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, 2], [1, -3], [2, -2]]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[[0, 2], [1, -2], [2, 0], [3, 1]]
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], [1, 0], [2, 0]]
Code: 15:43:01 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
print(matrix)
pass
Code: 15:43:11 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
matrix.sort(
print(matrix)
pass
Code: 15:43:22 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
matrix.sort(key=operator.
print(matrix)
pass
Code: 15:43:32 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
matrix.sort(key=operator.itemgetter(
print(matrix)
pass
Code: 15:43:41 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
matrix.sort(key=operator.itemgetter(2))
print(matrix)
pass
Code: 15:43:43 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
matrix.sort(key=operator.itemgetter(2))
print(matrix)
pass
Analysis
expand all
Example tests
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 16, in solution
matrix.sort(key=operator.itemgetter(2))
IndexError: list index out of range
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 16, in solution
matrix.sort(key=operator.itemgetter(2))
IndexError: list index out of range
1.
0.040 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 16, in solution
matrix.sort(key=operator.itemgetter(2))
IndexError: list index out of range
Code: 15:43:51 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
matrix.sort(key=operator.itemgetter(1))
print(matrix)
pass
Code: 15:43:52 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
matrix.sort(key=operator.itemgetter(1))
print(matrix)
pass
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:
[[1, -3], [2, -2], [0, 2]]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[[1, -2], [2, 0], [3, 1], [0, 2]]
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], [1, 0], [2, 0]]
Code: 15:44:03 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
print(matrix)
matrix.sort(key=operator.itemgetter(1))
print(matrix)
pass
Code: 15:44:08 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
print(matrix)
matrix.sort(key=operator.itemgetter(1))
print(matrix)
pass
Code: 15:44:09 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
print(matrix)
matrix.sort(key=operator.itemgetter(1))
print(matrix)
pass
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, 2], [1, -3], [2, -2]] [[1, -3], [2, -2], [0, 2]]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[[0, 2], [1, -2], [2, 0], [3, 1]] [[1, -2], [2, 0], [3, 1], [0, 2]]
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], [1, 0], [2, 0]] [[0, 0], [1, 0], [2, 0]]
Code: 15:45:04 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
print(matrix)
matrix.sort(key=operator.itemgetter(1),re)
print(matrix)
pass
Code: 15:45:08 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=TRUE)
print(matrix)
pass
Code: 15:45:09 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=TRUE)
print(matrix)
pass
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 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 17, in solution
matrix.sort(key=operator.itemgetter(1),reverse=TRUE)
NameError: name 'TRUE' is not defined
stdout:
[[0, 2], [1, -3], [2, -2]]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 17, in solution
matrix.sort(key=operator.itemgetter(1),reverse=TRUE)
NameError: name 'TRUE' is not defined
stdout:
[[0, 2], [1, -2], [2, 0], [3, 1]]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 17, in solution
matrix.sort(key=operator.itemgetter(1),reverse=TRUE)
NameError: name 'TRUE' is not defined
stdout:
[[0, 0], [1, 0], [2, 0]]
Code: 15:45:23 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
pass
Code: 15:45:23 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
pass
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, 2], [1, -3], [2, -2]] [[0, 2], [2, -2], [1, -3]]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, int expected, <class 'NoneType'> found.stdout:
[[0, 2], [1, -2], [2, 0], [3, 1]] [[0, 2], [3, 1], [2, 0], [1, -2]]
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], [1, 0], [2, 0]] [[0, 0], [1, 0], [2, 0]]
Code: 15:46:07 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
pass
Code: 15:46:09 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
pass
Code: 15:46:28 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
for i in F:
pass
Code: 15:46:40 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
for i < F:
pass
Code: 15:47:01 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
for i in range(F):
pass
Code: 15:47:03 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
for i in range(F):
pass
Code: 15:47:50 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
for i in range(F):
idx
pass
Code: 15:48:04 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
for i in range(F):
idx = matrix[i][0]
pass
Code: 15:48:28 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
for i in range(F):
idx = matrix[i][0]
sumA =
pass
Code: 15:48:51 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#f
for i in range(F):
idx = matrix[i][0]
sumA =
pass
Code: 15:49:04 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
for i in range(F):
idx = matrix[i][0]
sumA =
pass
Code: 15:49:06 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
for i in range(F):
idx = matrix[i][0]
sumA =
pass
Code: 15:49:19 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA =
pass
Code: 15:49:23 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = A
pass
Code: 15:49:27 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = A[idx]
pass
Code: 15:49:32 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
pass
Code: 15:49:39 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
for i
pass
Code: 15:49:49 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
for i in range
pass
Code: 15:49:59 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
for i in range(
pass
Code: 15:50:06 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
for i in range(F,length-F):
pass
Code: 15:50:12 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
sumB = 0
for i in range(F,length-F):
pass
Code: 15:50:30 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB
pass
Code: 15:50:41 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
pass
Code: 15:50:49 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#front-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
pass
Code: 15:51:10 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
pass
Code: 15:51:12 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
pass
Code: 15:51:24 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
return (sumA + sumB)
Code: 15:51:26 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
return (sumA + sumB)
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
got 5 expected 10
1.
0.036 s
WRONG ANSWER,
got 11 expected 18
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 29, in solution
idx = matraix[i][0]
NameError: name 'matraix' is not defined
Code: 15:51:43 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
prin
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
return (sumA + sumB)
Code: 15:51:54 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print(
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
return (sumA + sumB)
Code: 15:52:08 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print(
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
return (sumA + sumB)
Code: 15:52:25 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, '
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
return (sumA + sumB)
Code: 15:52:47 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % {idx,sumA})
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
return (sumA + sumB)
Code: 15:52:53 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % {idx,sumA})
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumA=%d' % {idx,sumA})
return (sumA + sumB)
Code: 15:52:55 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % {idx,sumA})
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumA=%d' % {idx,sumA})
return (sumA + sumB)
Code: 15:52:57 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % {idx,sumA})
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumA=%d' % {idx,sumA})
return (sumA + sumB)
Code: 15:53:03 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % {idx,sumA})
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % {idx,sumA})
return (sumA + sumB)
Code: 15:53:09 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % {idx,sumA})
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % {idx,sumA})
return (sumA + sumB)
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 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 25, in solution
print('idx=%d, sumA=%d' % {idx,sumA})
TypeError: %d format: a number is required, not set
stdout:
[[0, 2], [2, -2], [1, -3]]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 25, in solution
print('idx=%d, sumA=%d' % {idx,sumA})
TypeError: %d format: a number is required, not set
stdout:
[[0, 2], [3, 1], [2, 0], [1, -2]]
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 25, in solution
print('idx=%d, sumA=%d' % {idx,sumA})
TypeError: %d format: a number is required, not set
stdout:
[[0, 0], [1, 0], [2, 0]]
Code: 15:53:24 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % {idx,sumA})
return (sumA + sumB)
Code: 15:53:29 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA})
return (sumA + sumB)
Code: 15:53:32 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Code: 15:53:33 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length-F):
idx = matraix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
got 5 expected 10
stdout:
[[0, 2], [2, -2], [1, -3]] idx=0, sumA=4 idx=2, sumA=5
1.
0.036 s
WRONG ANSWER,
got 11 expected 18
stdout:
[[0, 2], [3, 1], [2, 0], [1, -2]] idx=0, sumA=7 idx=3, sumA=11
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 29, in solution
idx = matraix[i][0]
NameError: name 'matraix' is not defined
stdout:
[[0, 0], [1, 0], [2, 0]] idx=0, sumA=5
Code: 15:54:53 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matraix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Code: 15:54:56 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matraix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
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 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 29, in solution
idx = matraix[i][0]
NameError: name 'matraix' is not defined
stdout:
[[0, 2], [2, -2], [1, -3]] idx=0, sumA=4 idx=2, sumA=5
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 29, in solution
idx = matraix[i][0]
NameError: name 'matraix' is not defined
stdout:
[[0, 2], [3, 1], [2, 0], [1, -2]] idx=0, sumA=7 idx=3, sumA=11
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 105, in main
result = solution( A, B, F )
File "/tmp/solution.py", line 29, in solution
idx = matraix[i][0]
NameError: name 'matraix' is not defined
stdout:
[[0, 0], [1, 0], [2, 0]] idx=0, sumA=5
Code: 15:55:29 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Code: 15:55:31 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[[0, 2], [2, -2], [1, -3]] idx=0, sumA=4 idx=2, sumA=5 idx=1, sumB=5
1.
0.036 s
OK
stdout:
[[0, 2], [3, 1], [2, 0], [1, -2]] idx=0, sumA=7 idx=3, sumA=11 idx=2, sumB=11 idx=1, sumB=11
1.
0.036 s
OK
stdout:
[[0, 0], [1, 0], [2, 0]] idx=0, sumA=5 idx=1, sumB=5 idx=2, sumB=5
Code: 15:56:08 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Code: 15:57:30 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Code: 15:57:48 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Code: 15:57:51 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
[[0, 2], [2, -2], [1, -3]] idx=0, sumA=4 idx=2, sumA=5 idx=1, sumB=5
1.
0.036 s
OK
stdout:
[[0, 2], [3, 1], [2, 0], [1, -2]] idx=0, sumA=7 idx=3, sumA=11 idx=2, sumB=11 idx=1, sumB=11
1.
0.036 s
OK
stdout:
[[0, 0], [1, 0], [2, 0]] idx=0, sumA=5 idx=1, sumB=5 idx=2, sumB=5
Code: 15:57:56 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Code: 15:58:13 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Code: 15:58:52 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
4matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Code: 15:59:02 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Code: 15:59:13 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0)
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Code: 15:59:32 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Code: 15:59:34 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
Code: 15:59:54 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumA))
return (sumA + sumB)
User test case 1:
[[4, 2, 1], [2, 5, 3], 0]
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
idx=0, sumA=4 idx=2, sumA=5 idx=1, sumB=5
1.
0.036 s
OK
stdout:
idx=0, sumA=7 idx=3, sumA=11 idx=2, sumB=11 idx=1, sumB=11
1.
0.036 s
OK
stdout:
idx=0, sumA=5 idx=1, sumB=5 idx=2, sumB=5
expand all
User tests
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
idx=0, sumB=0 idx=1, sumB=0 idx=2, sumB=0
Code: 16:00:27 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
Code: 16:00:28 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
User test case 1:
[[4, 2, 1], [2, 5, 3], 0]
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
idx=0, sumA=4 idx=2, sumA=5 idx=1, sumB=5
1.
0.036 s
OK
stdout:
idx=0, sumA=7 idx=3, sumA=11 idx=2, sumB=4 idx=1, sumB=7
1.
0.036 s
OK
stdout:
idx=0, sumA=5 idx=1, sumB=5 idx=2, sumB=10
expand all
User tests
1.
0.036 s
OK
function result: 10
function result: 10
stdout:
idx=0, sumB=2 idx=1, sumB=7 idx=2, sumB=10
Code: 16:01:16 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
Code: 16:01:20 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
Code: 16:01:22 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
User test case 1:
[[4, 2, 1], [2, 5, 3], 0]
Analysis
Code: 16:01:40 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
User test case 1:
[[4, 2, 1], [2, 5, 3], 3]
Analysis
Code: 16:02:10 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
Code: 16:02:25 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
A = random
Code: 16:03:00 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
im
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
A = random
Code: 16:03:02 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
A = random
Code: 16:03:10 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
A = random.
Code: 16:03:20 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
A = random.sample(
Code: 16:03:35 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
A = random.sample(range(
Code: 16:03:50 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
A = random.sample(range(1001),200000)
Code: 16:04:00 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
A = random.sample(range(1001),200000)
B =
Code: 16:04:01 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
A = random.sample(range(1001),200000)
B = random.sample(range(1001),200000)
Code: 16:04:03 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
A = random.sample(range(1001),200000)
B = random.sample(range(1001),200000)
Code: 16:04:13 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
A = random.sample(range(1001),200000)
B = random.sample(range(1001),200000)
solution(A,B,100)
Code: 16:04:15 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
A = random.sample(range(1001),200000)
B = random.sample(range(1001),200000)
solution(A,B,100)
User test case 1:
[[4, 2, 1], [2, 5, 3], 3]
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 143, in <module>
main()
File "exec.py", line 84, in main
sol = __import__('solution')
File "/tmp/solution.py", line 41, in <module>
A = random.sample(range(1001),200000)
File "/opt/lang/python3/lib/python3.6/random.py", line 318, in sample
raise ValueError("Sample larger than population or is negative")
ValueError: Sample larger than population or is negative
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 84, in main
sol = __import__('solution')
File "/tmp/solution.py", line 41, in <module>
A = random.sample(range(1001),200000)
File "/opt/lang/python3/lib/python3.6/random.py", line 318, in sample
raise ValueError("Sample larger than population or is negative")
ValueError: Sample larger than population or is negative
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 84, in main
sol = __import__('solution')
File "/tmp/solution.py", line 41, in <module>
A = random.sample(range(1001),200000)
File "/opt/lang/python3/lib/python3.6/random.py", line 318, in sample
raise ValueError("Sample larger than population or is negative")
ValueError: Sample larger than population or is negative
expand all
User tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 143, in <module>
main()
File "exec.py", line 84, in main
sol = __import__('solution')
File "/tmp/solution.py", line 41, in <module>
A = random.sample(range(1001),200000)
File "/opt/lang/python3/lib/python3.6/random.py", line 318, in sample
raise ValueError("Sample larger than population or is negative")
ValueError: Sample larger than population or is negative
Code: 16:05:33 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
Code: 16:05:35 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
User test case 1:
[[4, 2, 1], [2, 5, 3], 3]
Analysis
Code: 16:05:41 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
User test case 1:
[[4, 2, 1], [2, 5, 3], 3]
Analysis
Code: 16:05:43 UTC,
py,
final,
score:
100
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
import operator
import random
def solution(A, B, F):
# write your code in Python 3.6
# get the contrbution difference between front and back end for each devs
length = len(A)
if length == 0:
return 0
matrix = [[0 for i in range(2)] for y in range(length)]
diff = []
idxLst = []
for i in range(length):
matrix[i][0] = i
matrix[i][1] = A[i] - B[i]
#print(matrix)
if (F > 0):
matrix.sort(key=operator.itemgetter(1),reverse=True)
#print(matrix)
#front-end team contribution
sumA = 0
for i in range(F):
idx = matrix[i][0]
sumA = sumA + A[idx]
#print('idx=%d, sumA=%d' % (idx,sumA))
#back-end team contribution
sumB = 0
for i in range(F,length):
idx = matrix[i][0]
sumB = sumB + B[idx]
#print('idx=%d, sumB=%d' % (idx,sumB))
return (sumA + sumB)
Analysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(N*log(N)) or O(N)
expand all
Correctness tests
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
small_bigger_and_smaller_differences
N = 20. Some developers have small difference between A[i] and B[i].
N = 20. Some developers have small difference between A[i] and B[i].
✔
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
expand all
Correctness/performance tests
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
medium_bigger_and_smaller_differences
N = 300. Some developers have small difference between A[i] and B[i].
N = 300. Some developers have small difference between A[i] and B[i].
✔
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
expand all
Performance tests
1.
0.816 s
OK
2.
0.808 s
OK
3.
0.844 s
OK
1.
0.820 s
OK
2.
0.836 s
OK
3.
0.812 s
OK
large_bigger_and_smaller_differences
N = 200,000. Some developers have small difference between A[i] and B[i].
N = 200,000. Some developers have small difference between A[i] and B[i].
✔
OK
1.
0.820 s
OK
2.
0.840 s
OK
3.
0.852 s
OK
1.
0.612 s
OK
2.
0.628 s
OK
3.
0.708 s
OK