numpy.txt

Setup
temperature = 0.7, topP = 0.95, turns = 10

A0: change example
A1: change logits(decimal places, array, etc)
A2: change output type (array -> dict, etc)
A3: analogy
A4: dimension(index) involved
A5: inverted operation
A6: order
A7: ±condition/operation

combinations involved, only show the highest level.


MAP
1.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
1
1
1
1
1
1
1
1
0.7
A1
0
0
0
0
1
0
0
1
1
1
1
0.4
A3
0
0
0
0
0
1
0
1
1
1
1
0.4


Origin:
Problem:
I want to multiply the columns of A with the elements in X in the following order: the first element of X multiplies to the first column of A, the second element to the second column and so on.

For example, given:
import numpy as np

X=np.array([10.        ,  2.46421304,  4.99073939,  5.79902063,  0.        ]
A=np.array([[0, 1, 1, 1, 0],
       [1, 0, 1, 0, 1],
       [1, 1, 0, 1, 1],
       [1, 0, 1, 0, 1],
       [0, 1, 1, 1, 0]])

I want to produce:
array([[0, 2.464, 4.991, 5.799, 0],
       [10, 0, 4.991, 0, 0],
       [10, 2.464, 0, 5.799, 0],
       [10, 0, 4.991, 0, 0],
       [0, 2.464, 4.991, 5.799, 0]])
       

A:

<code>
import numpy as np

X=np.array([10.        ,  2.46421304,  4.99073939,  5.79902063,  0.        ])
A=np.array([[0, 1, 1, 1, 0],
       [1, 0, 1, 0, 1],
       [1, 1, 0, 1, 1],
       [1, 0, 1, 0, 1],
       [0, 1, 1, 1, 0]])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(B)
</code>

test:
ans = A * X
try:
    np.testing.assert_array_equal(ans, B)
    print('Test passed!')
except:
    print('Test failed...')


A1:
Problem:
I want to multiply the columns of A with the elements in X in the following order: the first element of X multiplies to the first column of A, the second element to the second column and so on.

For example, given:
import numpy as np

X=np.array([10.        ,  2.46421304,  4.99073939,  5.79902063,  0.        ]
A=np.array([[0, 1, 1, 1, 0],
       [1, 0, 1, 0, 1],
       [1, 1, 0, 1, 1],
       [1, 0, 1, 0, 1],
       [0, 1, 1, 1, 0]])

I want to produce:
array([[0, 2.464, 4.991, 5.799, 0],
       [10, 0, 4.991, 0, 0],
       [10, 2.464, 0, 5.799, 0],
       [10, 0, 4.991, 0, 0],
       [0, 2.464, 4.991, 5.799, 0]])

Note that the result should be kept 3 decimal places just as the example.
       

A:

<code>
import numpy as np

X=np.array([10.        ,  2.46421304,  4.99073939,  5.79902063,  0.        ])
A=np.array([[0, 1, 1, 1, 0],
       [1, 0, 1, 0, 1],
       [1, 1, 0, 1, 1],
       [1, 0, 1, 0, 1],
       [0, 1, 1, 1, 0]])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(B)
</code>


test:
ans = np.round(A * X, 3)
try:
    np.testing.assert_array_equal(ans, B)
    print('Test passed!')
except:
    print('Test failed...')


A3:
Problem:
I want to multiply the columns of A with the elements in X in the following order: the first element of X multiplies to the first row of A, the second element to the second row and so on.

For example, given:
import numpy as np

X=np.array([10.        ,  2.46421304,  4.99073939,  5.79902063,  0.        ]
A=np.array([[0, 1, 1, 1, 0],
       [1, 0, 1, 0, 1],
       [1, 1, 0, 1, 1],
       [1, 0, 1, 0, 1],
       [0, 1, 1, 1, 0]])

I want to produce:
array([[0, 2.464, 4.991, 5.799, 0],
       [10, 0, 4.991, 0, 0],
       [10, 2.464, 0, 5.799, 0],
       [10, 0, 4.991, 0, 0],
       [0, 2.464, 4.991, 5.799, 0]])

Note that the result should be kept 3 decimal places just as the example.

A:

<code>
import numpy as np

X=np.array([10.        ,  2.46421304,  4.99073939,  5.79902063,  0.        ])
A=np.array([[0, 1, 1, 1, 0],
       [1, 0, 1, 0, 1],
       [1, 1, 0, 1, 1],
       [1, 0, 1, 0, 1],
       [0, 1, 1, 1, 0]])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(B)
</code>

Test:
ans = np.round((A.T * X).T, 3)
try:
    np.testing.assert_array_equal(ans, B)
    print('Test passed!')
except:
    print('Test failed...')



2.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
0
0
0
0
0
0


Origin:

Problem:
I have a NumPy record array of floats:

ar = np.array([(238.03, 238.0, 237.0),
               (238.02, 238.0, 237.01),
               (238.05, 238.01, 237.0)], 
              dtype=[('A', 'f'), ('B', 'f'), ('C', 'f')])

How can I determine min from each column of this record array?

desired:
[238.02 ,238.   ,237.  ]

A:
<code>
import numpy as np
ar = np.array([(238.03, 238.0, 237.0),
              (238.02, 238.0, 237.01),
              (238.05, 238.01, 237.0)],
              dtype=[('A', 'f'), ('B', 'f'), ('C', 'f')])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(result)
</code>

Test:
ar_view = ar.view((ar.dtype[0], len(ar.dtype.names)))
ans = ar_view.min(axis=0)
try:
    np.testing.assert_array_equal(ans, result)
    print('Test passed!')
except:
    print('Test failed...')


3.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
1
0
1
0
1
1
0
0
0
1
0.5
A2
1
1
1
1
1
1
0
1
1
1
1
0.9


Origin:
Problem:
Let x be an array [2, 2, 1, 5, 4, 5, 1, 2, 3]. Get two arrays of unique elements and their counts.

A:
<code>
import numpy as np
x = np.array([2, 2, 1, 5, 4, 5, 1, 2, 3])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(u, indices)
</code>

Test:
try:
    np.testing.assert_array_equal(u, np.array([1, 2, 3, 4, 5]))
    np.testing.assert_array_equal(indices, np.array([2, 3, 1, 1, 2]))
    print('Test passed!')
except:
    print('Test failed...')


A2:
Problem:
Let x be an array [2, 2, 1, 5, 4, 5, 1, 2, 3]. Get two arrays of unique elements and their counts.
Desired output(dict):
{1: 2, 2: 3, 3: 1, 4: 1, 5: 2}

A:
<code>
import numpy as np
x = np.array([2, 2, 2, 1, 5, 4, 5, 1, 2, 3])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(result)
</code>

test:
try:
    assert result == {2: 4, 1: 2, 5: 2, 4: 1, 3: 1}
    print('Test passed!')
except:
    print('Test failed...')







4.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
Using NumPy, complete the function below. The function should create and return the following 2-D array. You must find a way to generate the array without typing it explicitly:

[[1,  6, 11],
 [2,  7, 12],
 [3,  8, 13],
 [4,  9, 14],
 [5, 10, 15]]


A:
<code>
import numpy as np

def create_array():
    ### BEGIN SOLUTION
    [insert]
    ### END SOLUTION
    return result
</code>

test:

try:
    np.testing.assert_array_equal(create_array(), np.array([[1,6,11],[2,7,12],[3,8,13],[4,9,14],[5,10,15]]))
    print('Test passed!')
except:
    print('Test failed...')




5.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
Complete the function below. The function must return an array that contains the third column of the array "original" which is passed as an argument. The argument must be a 2-D array. If the argument is invalid, return None.

A:
<code>
import numpy as np

def new_array_second_column(original):
    ### BEGIN SOLUTION
   [insert]
    ### END SOLUTION
    return result
</code>


Test:
case = np.arange(16)[1:].reshape((3,5)).T
try:
    np.testing.assert_array_equal(new_array_second_column(case), np.array([[11],[12],[13],[14],[15]]))
    np.testing.assert_array_equal(new_array_second_column(np.array([1,2,3])), None)
    np.testing.assert_array_equal(new_array_second_column(np.array([[1,2],[4,5],[7,8]])), None)
    print('Test passed!')
except:
    print('Test failed...')




6.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
I have an array that looks like below:
array([[0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3, 3, 3], [4, 4, 4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6, 6, 6], [7, 7, 7, 7, 7, 7, 7, 7]])
How can I use reshape to divide it into 4 chucks, such that it looks like
array([[[0, 0, 0, 0], [1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]], [[0, 0, 0, 0], [1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]], [[4, 4, 4, 4], [5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7]], [[4, 4, 4, 4], [5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7]]])

A:
<code>
import numpy as np

a = np.arange(8)[:,None].repeat(8,axis=1)
#BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
b = a.reshape(2,4,2,4).transpose(0,2,1,3)

try:
    np.testing.assert_array_equal(ans, b)
    print('Test passed!')
except:
    print('Test failed...')




7.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
1
1
1
0
0
0
0
0
1
0
1
0.4
A4
1
0
0
0
0
0
0
0
1
0
1
0.2


Origin:
Problem:
I have a numpy array of shape (3, 3, k), where the length k is fixed. The array was processed to a flatten one dimensional one with:
mat2 = numpy.transpose(data, (1, 0, 2)).flatten('C')
How do I reverse this transpose / flattening process to get the original (3, 3, k) shape and ordering of the data array?

A:
<code>
import numpy as np
k = 10
a = np.linspace(0, 89, 90).reshape((3, 3, k))
b = np.transpose(a, (1, 0, 2)).flatten('C')

### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans.shape)
</code>

test:
try:
    assert id(ans) != id(a)
    np.testing.assert_array_equal(ans, a)
    print('Test passed!')
except:
    print('Test failed...')


A4:
Problem:
I have a numpy array of shape (3, 3, k), where the length k is fixed. The array was processed to a flatten one dimensional one with:
mat2 = numpy.transpose(data, (1, 2, 0)).flatten('C')
How do I reverse this transpose / flattening process to get the original (3, 3, k) shape and ordering of the data array?

A:
<code>
import numpy as np
k = 10
a = np.linspace(0, 89, 90).reshape((3, 3, k))
b = np.transpose(a, (1, 2, 0)).flatten('C')

### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans.shape)
</code>

test:
try:
    assert id(ans) != id(a)
    np.testing.assert_array_equal(ans, a)
    print('Test passed!')
except:
    print('Test failed...')





8.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
1
1
1
1
1
0
1
1
1
1
1
0.9
A5
1
0
1
1
0
1
1
0
1
1
1
0.7


Origin:
Problem:
I'm generating matrix representations of images with height*width size, and I need to transform them into a vector of pixels. To generate the images, I'm using the following instruction
np.array([[np.random.randint(0, 255, 3) for dummy_row in range(height)] for dummy_col in range(width)])
e.g., (2x2) image
array([[[132, 235, 40], [234, 1, 160]], [[ 69, 108, 218], [198, 179, 165]]])
when I'm requiring
array([[132, 235, 40], [234, 1, 160], [69, 108, 218], [198, 179, 165]])

A:
<code>
import numpy as np

def f(arr):
    ### BEGIN SOLUTION
    [insert]
    ### END SOLUTION
    return result
</code>

tset:
a = np.array([[[132, 235, 40], [234, 1, 160]], [[ 69, 108, 218], [198, 179, 165]]])
b = np.array([[132, 235, 40], [234, 1, 160], [69, 108, 218], [198, 179, 165]])
try:
    np.testing.assert_array_equal(f(a), b)
    print('Test passed!')
except:
    print('Test failed...')

A5:
Problem:
I'm generating matrix representations of images with height*width size, and I need to transform them into a vector of pixels. To generate the images, I'm using the following instruction
e.g., (2x2) image
array([[132, 235, 40], [234, 1, 160], [69, 108, 218], [198, 179, 165]])
when I'm requiring
array([[[132, 235, 40], [234, 1, 160]], [[ 69, 108, 218], [198, 179, 165]]])

A:
<code>
import numpy as np

def f(arr):
    ### BEGIN SOLUTION
    [insert]
    ### END SOLUTION
    return result
</code>

tset:
a = np.array([[[132, 235, 40], [234, 1, 160]], [[ 69, 108, 218], [198, 179, 165]]])
b = np.array([[132, 235, 40], [234, 1, 160], [69, 108, 218], [198, 179, 165]])
try:
    np.testing.assert_array_equal(f(b), a)
    print('Test passed!')
except:
    print('Test failed...')





9.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
1
1
1
1
1
0
1
1
1
1
1
0.9
A4
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
I have a df like this:
import pandas as pd
a=[['1/2/2014', 'a', '6', 'z1'], ['1/2/2014', 'a', '3', 'z1'], ['1/3/2014', 'c', '1', 'x3'], ]
df = pd.DataFrame.from_records(a[0:],columns=a[0])
I want to flatten the df so it is one continuous list like so:
['1/2/2014', 'a', '6', 'z1', '1/2/2014', 'a', '3', 'z1','1/3/2014', 'c', '1', 'x3']

A:
<code>
import pandas as pd
import numpy as np
a=[['1/2/2014', 'a', '6', 'z1'], ['1/2/2014', 'a', '3', 'z1'], ['1/3/2014', 'c', '1', 'x3'], ]
df = pd.DataFrame.from_records(a[0:],columns=a[0])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
try:
    np.testing.assert_array_equal(df.to_numpy().flatten(),ans)
    print('Test passed!')
except:
    print('Test failed...')

A4:
Problem:
I have a df like this:
import pandas as pd
a=[['1/2/2014', 'a', '6', 'z1'], ['1/2/2014', 'a', '3', 'z1'], ['1/3/2014', 'c', '1', 'x3'], ]
df = pd.DataFrame.from_records(a[0:],columns=a[0])
I want to flatten the df so it is one continuous list like so:
['1/2/2014', '1/2/2014', '1/3/2014', 'a', 'a', 'c', '6', '3', '1', 'z1', 'z1', 'x3']

A:
<code>
import pandas as pd
import numpy as np
a=[['1/2/2014', 'a', '6', 'z1'], ['1/2/2014', 'a', '3', 'z1'], ['1/3/2014', 'c', '1', 'x3'], ]
df = pd.DataFrame.from_records(a[0:],columns=a[0])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
try:
    np.testing.assert_array_equal(df.to_numpy().T.flatten(),ans)
    print('Test passed!')
except:
    print('Test failed...')



10.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
1
1
0
0
1
0.2
A4
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
I would like to find a way to quickly manipulate an array of arrays in Numpy like this one, which has a shape of (10,):
[array([0, 1, 3]) ,array([0, 1, 7]), array([2]), array([0, 3]), array([4]), array([5]), array([6]) ,array([1, 7]), array([8]), array([9])]
For instance, I'd like to compute the total number of array elements, which is 16 for the array above, but without doing a for loop since in practice my "nested array" will be quite large.

A:
<code>
import numpy as np
from numpy import array
a = [array([0, 1, 3]) ,array([0, 1, 7]), array([2]), array([0, 3]), array([4]),
 array([5]), array([6]) ,array([1, 7]), array([8]), array([9])]
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
try:
    np.testing.assert_array_equal(ans,len(np.concatenate(a).ravel()))
    print('Test passed!')
except:
    print('Test failed...')
+for elimination



A4:
Problem:
I would like to find a way to quickly manipulate an array of arrays in Numpy like this one, which has a shape of (10,):
[array([0, 1, 3]) ,array([[0, 1, 7]]), array([2]), array([[0, 3]]), array([4]), array([5]), array([6]) ,array([1, 7]), array([8]), array([9])]
For instance, I'd like to compute the total number of array elements, but without doing a for loop since in practice my "nested array" will be quite large.

A:
<code>
import numpy as np
from numpy import array
a = [array([0, 1, 3]) ,array([[0, 1, 7]]), array([2]), array([[0, 3]]), array([4]),
 array([5]), array([6]) ,array([1, 7]), array([8]), array([9])]
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
a = map(lambda x: x.flatten(), a)
result = sum(map(len, a))
try:
    assert result == ans
    print('Test passed!')
except:
    print('Test failed...')
+for elimination

11.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
1
1
0
0
0
1
0
1
0.3
A1
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
I have an array, R. I would like to remove elements corresponding to indices in Remove and then flatten them with the remaining elements. The desired output is attached.
R=np.array([[1.05567452e+11, 1.51583103e+11, 5.66466172e+08],
       [6.94076420e+09, 1.96129124e+10, 1.11642674e+09],
       [1.88618492e+10, 1.73640817e+10, 4.84980874e+09]])
Remove = [(0, 1),(0,2)] 
R1 = R.flatten()
print([R1])

The desired output is
array([1.05567452e+11, 6.94076420e+09, 1.96129124e+10, 1.11642674e+09,
       1.88618492e+10, 1.73640817e+10, 4.84980874e+09])

A:
<code>
import numpy as np
R = np.array([[1.05567452e+11, 1.51583103e+11, 5.66466172e+08],
              [6.94076420e+09, 1.96129124e+10, 1.11642674e+09],
              [1.88618492e+10, 1.73640817e+10, 4.84980874e+09]])
Remove = [(0, 1), (0, 2)]
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
a = np.array([1.05567452e+11,6.94076420e+09,1.96129124e+10,1.11642674e+09,
1.88618492e+10, 1.73640817e+10, 4.84980874e+09])

try:
    np.testing.assert_array_equal(a, ans)
    print('Test passed!')
except:
    print('Test failed...')

A1:
Problem:
I have an array, R. I would like to remove elements corresponding to indices in Remove and then flatten them with the remaining elements. The desired output is attached.
R=np.array([[1.05567452, 1.51583103, 5.66466172],
       [6.94076420, 1.96129124, 1.11642674],
       [1.88618492, 1.73640817, 4.84980874]])
Remove = [(0, 1),(0,2)] 
R1 = R.flatten()
print([R1])

and I want to just keep 2 decimal places.

The desired output is
array([1.06, 6.94, 1.96, 1.12, 1.89, 1.74, 4.85])

A:
<code>
import numpy as np
R = np.array([[1.05567452, 1.51583103, 5.66466172],
       [6.94076420, 1.808484, 1.11642674],
       [1.88618492, 1.73640817, 4.84980874]])
Remove = [(0, 1), (0, 2)]
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
a = np.array([1.06, 6.94, 1.81, 1.12, 1.89, 1.74, 4.85])

try:
    np.testing.assert_array_equal(a, ans)
    print('Test passed!')
except:
    print('Test failed...')






12.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
1
0
1
1
1
1
0
1
0.5
A4
0
0
1
0
0
0
0
0
0
0
1
0.1


Origin:
Problem:
Now I have a 3D numpy array with shape (2,3,4) as follows:
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]
 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
Now, I want to reshape the array to (2,4,3) by swapping the last 2 dimensions of the array as follows:
[[[ 0  4  8]
  [ 1  5  9]
  [ 2  6 10]
  [ 3  7 11]]
 [[12 16 20]
  [13 17 21]
  [14 18 22]
  [15 19 23]]]

A:
<code>
import numpy as np
arr = np.array([[[ 0 , 1, 2, 3], [ 4 , 5, 6, 7], [ 8 , 9, 10, 11]], [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
a = np.transpose(arr, axes=(0, 2, 1))

try:
    np.testing.assert_array_equal(a, ans)
    print('Test passed!')
except:
    print('Test failed...')


A4:
Problem:
Now I have a 3D numpy array with shape (2,3,4) as follows:
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]
 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
Now, I want to reshape the array by swapping the axes of the array as follows:
[[[ 0,  4,  8],
  [12, 16, 20]],
  [[ 1,  5,  9],
  [13, 17, 21]],
[[ 2,  6, 10],
  [14, 18, 22]],
  [[ 3,  7, 11],
  [15, 19, 23]]]

A:
<code>
import numpy as np
arr = np.array([[[ 0 , 1, 2, 3], [ 4 , 5, 6, 7], [ 8 , 9, 10, 11]], [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
a = np.transpose(arr, axes=(2, 0, 1))

try:
    np.testing.assert_array_equal(a, ans)
    print('Test passed!')
except:
    print('Test failed...')



13.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
1
0
0
0
0
1
0.1


Origin:
Problem:
I have a numpy array x = np.array([145100, [ 1,2,3  ], [6,5,4]]) and I wish to ravel it to this: [145100,  1,2,3 , 6,5,4]
I tried this, but it didn't give any results:
x = np.ravel(x)
As the shape was still (3,) instead of (5,). What am I missing?

A:
<code>
import numpy as np
x = np.array([145100, [1, 2, 3], [6,5,4]])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
a = np.hstack(x)
try:
    np.testing.assert_array_equal(a, ans)
    print('Test passed!')
except:
    print('Test failed...')



14.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
1
0
0
0
0
1
0
0
0
1
0.2


Origin:
Problem:
I have an array H of dimension MxN, and an array A of dimension M . I want to scale H rows with array A. I do it this way, taking advantage of element-wise behavior of Numpy
H = numpy.swapaxes(H, 0, 1)
H /= A
H = numpy.swapaxes(H, 0, 1)

It works, but the two swapaxes operations are not very elegant, and I feel there is a more elegant and concise way to achieve the result, without creating temporaries. Would you tell me how ?

A:
<code>
import numpy as np
H = np.array([[ 1.05550870e+00, -1.54640644e-01,  2.01796906e+00],
              [6.59741375e-02,  4.69242500e-01, -5.57339470e-03],
              [-2.12376646e-01, -9.17792113e-01, -1.20153176e+00],
              [3.68068789e-01, -9.98131619e+00, -1.14438249e+01]])
A = np.array([ 1.1845468 ,  1.30376536, -0.44912446,  0.04675434])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
a = H/A[:, None]
try:
    np.testing.assert_array_equal(a, ans)
    print('Test passed!')
except:
    print('Test failed...')
+for detection



15.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
1
0
0
0
0
0
0
0
0
0
1
0.1


Origin:
Problem:
I am trying to convert a string into n-dimensioned numpy array (x, 4, 4). Basic requirement is a 4x4 array with column major filling of values. We will use as many 4x4 arrays as per the length of the input string. For example if my string is:

'A quick brown fox jumps over dog'

The resultant array should look like this:

[[['A' 'i' 'b' 'n']
  [' ' 'c' 'r' ' ']
  ['q' 'k' 'o' 'f']
  ['u' ' ' 'w' 'o']]

 [['x' 'm' 'o' ' ']
  [' ' 'p' 'v' 'd']
  ['j' 's' 'e' 'o']
  ['u' ' ' 'r' 'g']]]
Note that instead of the conventional row-first filling of values requirement is for the filling to be column first within the 4x4 subarray.

A:
<code>
import numpy as np
string = 'A quick brown fox jumps over dog'
#BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

test:
matrix2 = np.array(list(string)).reshape(-1,4,4).swapaxes(1,2)
try:
    np.testing.assert_array_equal(matrix2, ans)
    print('Test passed!')
except:
    print('Test failed...')




16.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
Consider the following arrays:
a = np.array([0,1])[:,None]
b = np.array([1,2,3])
print(a)
array([[0],
       [1]])
print(b)
b = np.array([1,2,3])
Is there a simple way to concatenate these two arrays in a way that the latter is broadcast, in order to obtain the following?

array([[0, 1, 2, 3],
       [1, 1, 2, 3]])

A:
<code>
import numpy as np
a = np.array([0,1])[:,None]
b = np.array([1,2,3])
#BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

test:
b_new = np.broadcast_to(b,(a.shape[0],b.shape[0]))
c = np.concatenate((a,b_new),axis=1)

try:
    np.testing.assert_array_equal(c, ans)
    print('Test passed!')
except:
    print('Test failed...')



17.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
1
0
1
1
0
1
1
0
1
0
1
0.6
A4
0
0
0
0
0
0
0
0
1
0
1
0.1


Origin:
Problem:
Is there a Pythonic way to calculate the array z without using the loop?

import numpy as np
x = np.array([[1, 2, 3], [6, 7, 8]])
y = np.array([5, 8])
z = np.array([x[i] * y[i] for i in range(0, len(x))])

A:
<code>
import numpy as np
x = np.array([[1, 2, 3], [6, 7, 8]])
y = np.array([5, 8])
#BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

test:
z = x * np.expand_dims(y, 1)

try:
    np.testing.assert_array_equal(z, ans)
    print('Test passed!')
except:
    print('Test failed...')
+for detection

A0:
Problem:
Is there a Pythonic way to calculate the array z without using the loop?

import numpy as np
x = np.array([[1, 2, 3], [3, 4, 5], [6, 7, 8]])
y = np.array([5, 8, 10])
z = np.array([x[i] * y[i] for i in range(0, len(x))])

A:
<code>
import numpy as np
x = np.array([[1, 2, 3], [3, 4, 5], [6, 7, 8]])
y = np.array([5, 8, 10])
#BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
z = x * np.expand_dims(y, 1)

try:
    np.testing.assert_array_equal(z, ans)
    print('Test passed!')
except:
    print('Test failed...')
+for detection



18.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
I have a table in a Python script with numpy in the following shape:

[array([[a1, b1, c1], ..., [x1, y1, z1]]), 
 array([a2, b2, c2, ..., x2, y2, z2])
]
I would like to reshape it to a format like this:

(array([[a2],
        [b2],
         .
         .
         .
        [z2]],
        dtype = ...),
 array([[a1],
        [b1],
         .
         .
         .
        [z1]])
)
To be honest, I'm also quite confused about the different parentheses. array1, array2] is a list of arrays, right? What is (array1, array2), then?


A:
<code>
import numpy as np
a = [
    np.array([[1, 2, 3], [4, 5, 6]]),
    np.array([10, 11, 12, 13, 14])
    ]
#BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
b = (
    np.expand_dims(a[1], axis=1),
    np.expand_dims(a[0].flatten(), axis=1)
    )

try:
    np.testing.assert_array_equal(b, ans)
    print('Test passed!')
except:
    print('Test failed...')
+for detection


19.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
1
1
0
1
1
0
1
1
0
0
1
0.6
A4
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
I have a three dimensional numpy source array and a two-dimensional numpy array of indexes.

For example:

src = np.array([[[1,2,3],[4,5,6]],
                [[7,8,9],[10,11,12]]])
idx = np.array([[0,1],
                [1,2]])
I'd like to get a 2d array, where each element represents the indexed value in the innermost dimension in that position:

array([[1,5],
       [8,12]])
How do I do this with numpy?

A:
<code>
import numpy as np
src = np.array([[[1,2,3],[4,5,6]],
                [[7,8,9],[10,11,12]]])
idx = np.array([[0,1],
                [1,2]])
#BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
idx = np.expand_dims(idx, axis=-1)
res = np.take_along_axis(src, idx, axis=2).squeeze(-1)

try:
    np.testing.assert_array_equal(res, ans)
    print('Test passed!')
except:
    print('Test failed...')

A4:
Problem:
I have a three dimensional numpy source array and a two-dimensional numpy array of indexes.

For example:

src = np.array([[[1,2,3],[4,5,6]],
                [[7,8,9],[10,11,12]]])
idx = np.array([[0,2],
                [1,2]])
I'd like to get a 2d array:

array([[1,5],
       [9,12]])
For example, the 5 on the top right corresponds to the 1st element of [4, 5, 6], and the 9 on the bottom left corresponds to the 2nd element of [7, 8, 9]
In other words, the indices on idx[0, 1] and idx[1, 0] corresponds to src[1, 0] and src[0, 1]
How do I do this with numpy?

A:
<code>
import numpy as np
src = np.array([[[1,2,3],[4,5,6]],
                [[7,8,9],[10,11,12]]])
idx = np.array([[0,2],
                [1,2]])
#BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
idx = np.expand_dims(idx.T, axis=-1)
res = np.take_along_axis(src, idx, axis=2).squeeze(-1)

try:
    np.testing.assert_array_equal(res, ans)
    print('Test passed!')
except:
    print('Test failed...')
+for detection



20.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
0
0
1
0
1
0.1


Origin:
Problem:
I have an issue in applying argmax to an array which has multiple brackets. In real life I am getting this as a result of a pytorch tensor. Here I can put an example:

a = np.array([[1.0, 1.1],[2.1,2.0]])
np.argmax(a,axis=1)

array([1, 0])
It is correct. But:

a = np.array([[[1.0, 1.1]],[[2.1,2.0]]])
np.argmax(a,axis=1)

array([[0, 0],
       [0, 0]])
It does not give me what I expect. Consider that in reality I have this level of inner brackets:

a = np.array([[[[1.0, 1.1]]],[[[2.1,2.0]]]])

A:
<code>
import numpy as np
a = np.array([[[[1.0, 1.1]]], [[[2.1, 2.0]]]])
#BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
try:
    np.testing.assert_array_equal(np.argmax(a, axis=-1).squeeze(), ans)
    print('Test passed!')
except:
    print('Test failed...')




21.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
1
1
1
1
0
0
1
1
0.5


Origin:
Problem:
I have a large list files that contain 2D numpy arrays pickled through numpy.save. I am trying to read the first column of each file and create a new 2D array.

I currently read each column using numpy.load with a mmap. The 1D arrays are now in a list.

col_list = []
for f in file_list:
    Temp = np.load(f,mmap_mode='r')
    col_list.append(Temp[:,0])
How can I convert this into a 2D array?

A:
<code>
import numpy as np
def f(arrays):
    ### BEGIN SOLUTION
    [insert]
    ### END SOLUTION
    return result
</code>

test:
arrs = [np.array([1,2,3]), np.array([4,5,6]), np.array([7,8,9])]
try:
    np.testing.assert_array_equal(f(arrs), np.stack(arrs, axis=0))
    print('Test passed!')
except:
    print('Test failed...')

22.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
1
0
0
0
0
0
0
0
0
1
0.1


Origin:
Problem:
I.m facing a little issue to combine arrays in a certain manner. Let's say we have

a=array([[1,1,1],[2,2,2],[3,3,3]])

b=array([[10,10,10],[20,20,20],[30,30,30]])
I wish to get

c=array([[[1,1,1],[10,10,10]],[[2,2,2],[20,20,20]],[[3,3,3],[30,30,30]]])
The real issue is that my arrays a and b are much longer than 3 coordinates!

A:
<code>
import numpy as np
a = np.array([[1,1,1],[2,2,2],[3,3,3], [4,4,4]])
b = np.array([[10,10,10],[20,20,20],[30,30,30], [40, 40, 40]])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

test:
c = np.concatenate((a[:, None, :], b[:, None, :]), axis=1)
try:
    np.testing.assert_array_equal(c, ans)
    print('Test passed!')
except:
    print('Test failed...')

+for detection

23.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
1
0
0
1
0
0
1
0.2
A7
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
I currently looking for method in which i can split a ndarray into smaller ndarrays.

example: given ndarray with shape (78,1440,3), from which i want to extract a list of smaller ndarrays of the size (78,72,3), that would be 20 smaller sub ndarrays.

I tried using numpy.split.

numpy.split(matrix,72,axis=1)
which generates a list of length 72 and the first entry has the shape (78,20,3)..

Why am I not able to extract the size I need?

A:
<code>
import numpy as np
matrix = np.random.rand(78,1440,3)
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
c = np.split(matrix, matrix.shape[1]//72, axis=1)

try:
    np.testing.assert_array_equal(c, ans)
    print('Test passed!')
except:
    print('Test failed...')


A7:
Problem:
I currently looking for method in which i can split a ndarray into smaller ndarrays.

example: given ndarray with shape (78,1440,3), from which i want to extract a list of smaller ndarrays of the size (78,73,3).

Note that if shape[1] is not divisible by new size(in this example: 1440 is not divisible by 73), then fill zeros on the axis until it is dividible.

Why am I not able to extract the size I need?

A:
<code>
import numpy as np
matrix = np.random.rand(78,1440,3)
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
t = matrix.shape[1] // 73
if t * 73 < matrix.shape[1]:
    new_arr = np.zeros((78, (t+1)*73-1440, 3))
    matrix = np.hstack([matrix, new_arr])
c = np.split(matrix, matrix.shape[1] // 73, axis = 1)

try:
    np.testing.assert_array_equal(c, ans)
    print('Test passed!')
except:
    print('Test failed...')





24.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
Suppose I have an array like:

import numpy as np

np.array([[0, 0, 0],
          [1, 1, 1]])
Here has shape (2,3) but it can be (n,3). I would like to transform it into a list of arrays representing columns.

Desired Output

[array([[0],[1]]), array([[0],[1]]), array([[0],[1]])]
I tried list comprehension, reshape etc. but I did not manage to get there.

A:
<code>
import numpy as np

a=np.array([[0, 0, 0],[1, 1, 1]])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
c = [np.hsplit(a,3)]

try:
    np.testing.assert_array_equal(c, ans)
    print('Test passed!')
except:
    print('Test failed...')
+for detection

25.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
I have a numpy array of size nxm. I want the number of columns to be limited to k and the rest of the columns to be extended in new rows. Following is the scenario -

Initial array: nxm
Final array: pxk
where p = (m/k)*n

Eg. n = 2, m = 6, k = 2

Initial array:
[[1, 2, 3, 4, 5, 6,],
[7, 8, 9, 10, 11, 12]]

Final array:
[[1, 2],
[7, 8],
[3, 4],
[9, 10],
[5, 6],
[11, 12]]

I tried using reshape but I did not get the desired result.

A:
<code>
import numpy as np

q = np.array([[1, 2, 3, 4, 5, 6,], [7, 8, 9, 10, 11, 12]])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

test:
c = q.T.reshape(-1,2,2).swapaxes(1,2).reshape(-1,2)

try:
    np.testing.assert_array_equal(c, ans)
    print('Test passed!')
except:
    print('Test failed...')


26.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
Simple question here:

I'm trying to get an array that alternates values (1, -1, 1, -1.....) for a given length. np.repeat just gives me (1, 1, 1, 1,-1, -1,-1, -1). Thoughts?

A:
<code>
import numpy as np
def f(n):
    ### BEGIN SOLUTION
    [insert]
    ### END SOLUTION
    return result
</code>

test:
a = np.array([1, -1, 1, -1, 1, -1, 1, -1])
b = np.array([1, -1, 1, -1, 1, -1, 1, -1, 1])

try:
    np.testing.assert_array_equal(a, f(8))
    np.testing.assert_array_equal(b, f(9))
    print('Test passed!')
except:
    print('Test failed...')



27.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
Simple question here:

I am trying to break a numpy array into chunks with a fixed size and pad the last one with 0. For example: [1,2,3,4,5,6,7] into chunks of 3 returns [[1,2,3],[4,5,6],[7,0,0]].

A:
<code>
import numpy as np
l = np.array([1,2,3,4,5,6,7])
ans = l.copy()
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
t = l.copy()
t.resize((3,3), refcheck=False)

try:
    np.testing.assert_array_equal(ans, t)
    print('Test passed!')
except:
    print('Test failed...')


28.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
1
0
0
1
0
0
0
1
0.2


Origin:
Problem:
Suppose I have the following array:
a = np.array([1,0,2,3,0,4,5,0])

for each zero I would like to duplicate a zero and add it to the array such that I get:
np.array([1,0,0,2,3,0,0,4,5,0,0])

A:
<code>
import numpy as np
a = np.array([1, 0, 2, 3, 0, 4, 5, 0])
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(a)
</code>

test:
b = np.array([1, 0, 2, 3, 0, 4, 5, 0])
i = 0
while i < len(b):
    if b[i] == 0:
        b = np.insert(b, i, 0)
        i += 1
    i += 1

try:
    np.testing.assert_array_equal(a, b)
    print('Test passed!')
except:
    print('Test failed...')


29.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
1
0
0
0
0
0
0
0
0
1
0.1


Origin:
Problem:
Consider an array Z = [1,2,3,4,5,6,7,8,9,10,11,12,13,14], how to generate an array 
R = [[4,3,2,1], [5,4,3,2], [6,5,4,3], ..., [14,13,12,11]]

A:
<code>
import numpy as np
Z = np.arange(1, 15, dtype=np.uint32)
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(R)
</code>

test:
A = np.arange(11, dtype=np.uint32).reshape(-1, 1) + np.broadcast_to(Z[3::-1], (11, 4))

try:
    np.testing.assert_array_equal(A, R)
    print('Test passed!')
except:
    print('Test failed...')



30.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
Converts a 1-dimensional array to a binary representation matrix. For every row in the matrix, the i-th element is 0 or 1, representing 2^i. The order is from left to right.

example:
given:
[1,2,3,4]
desired:
[[1,0,0],
[0,1,0],
[1,1,0],
[0,0,1]]

A:
<code>
import numpy as np
A = np.array([1,2,3,4])
A = A.reshape((-1,1))
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(ans)
</code>

Test:
B = 2**np.arange(3)
M = A & B
M[M != 0] = 1

try:
    np.testing.assert_array_equal(ans, M)
    print('Test passed!')
except:
    print('Test failed...')
Numpy-100
15.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
1
1
1
1
1
1
1
1
0
1
0.8
A3
0
0
0
1
1
1
1
1
1
1
1
0.7


Origin:
Problem:
Create a 2d array with 1 on the border and 0 inside.

A:
<code>
import numpy as np
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(Z)
</code>

Test:
ans = np.ones((10,10))
ans[1:-1,1:-1] = 0

try:
    np.testing.assert_array_equal(ans, Z)
    print('Test passed!')
except:
    print('Test failed...')


A3:
Problem:
Create a 10*5 array with 2 on the border and 3 inside.

A:
<code>
import numpy as np
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(Z)
</code>

test:
ans = 2* np.ones((10,5))
ans[1:-1,1:-1] = 3

try:
    np.testing.assert_array_equal(ans, Z)
    print('Test passed!')
except:
    print('Test failed...')




18.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
1
1
0
1
1
0
1
1
1
1
1
0.8
A1
0
0
0
0
0
0
0
0
0
0
0
0
A3
1
1
1
0
1
1
1
1
0
0
1
0.7


Origin:
Problem:
Create a 5x5 matrix with values 1,2,3,4 just below the diagonal.

A:
<code>
import numpy as np
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(Z)
</code>

test:
ans = np.diag(1+np.arange(4), k=-1)

try:
    np.testing.assert_array_equal(ans, Z)
    print('Test passed!')
except:
    print('Test failed...')

A1:
Problem:
Create a 5x5 matrix with values 1,3,4,5 just below the diagonal.

A:
<code>
import numpy as np
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(Z)
</code>

test:
ans = np.diag(2+np.arange(4), k=-1)
ans[1][0] = 1

try:
    np.testing.assert_array_equal(ans, Z)
    print('Test passed!')
except:
    print('Test failed...')

A3:
Problem:
Create a 5x5 matrix with values 1,2,3,4 just above the diagonal.

A:
<code>
import numpy as np
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(Z)
</code>

test:
ans = np.diag(1+np.arange(4), k=1)

try:
    np.testing.assert_array_equal(ans, Z)
    print('Test passed!')
except:
    print('Test failed...')







20.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
1
1
0
1
0
0
0
1
0
1
0.4
A1
0
0
0
0
0
0
0
0
0
0
0
0
A6
0
0
0
1
0
0
0
0
0
0
1
0.1


Origin:
Problem:
Consider a (6,7,8) shape array, what is the index (x,y,z) of the 100th element?

A:
<code>
import numpy as np
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(index)
</code>

Test:
try:
    np.testing.assert_array_equal(index, np.unravel_index(99, (6,7,8)))
    print('Test passed!')
except:
    print('Test failed...')

A1:
Problem:
Consider a (6,7,8) shape array, what is the index (x,y,z) of the 99th element?

A:
<code>
import numpy as np
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(index)
</code>

Test:
try:
    np.testing.assert_array_equal(index, np.unravel_index(98, (6,7,8)))
    print('Test passed!')
except:
    print('Test failed...')


A6:
Problem:
Consider a (6,7,8) shape array, what is the index (x,y,z) of the 100th element from back to front?

A:
<code>
import numpy as np
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(index)
</code>

Test:
try:
    np.testing.assert_array_equal(index, np.unravel_index(6*7*8-100, (6,7,8)))
    print('Test passed!')
except:
    print('Test failed...')



25.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
Given a 1D array, negate all elements which are between 3 and 8, or (3, 8), in place.

A:
<code>
import numpy as np
Z = np.arange(11)
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(Z)
</code>

Test:
test_Z = np.arange(11)
test_Z[(3<test_Z) & (test_Z <8)] *= -1
try:
    np.testing.assert_array_equal(Z, test_Z)
    print('Test passed!')
except:
    print('Test failed...')



37.
Score:



1
2
3
4
5
6
7
8
9
10
Top-10
Avg
Origin
1
1
1
1
1
1
1
1
1
1
1
1
A1
0
0
0
0
0
0
0
0
0
0
0
0


Origin:
Problem:
Create a 5x5 matrix with row values ranging from 0 to 4.

A:
<code>
import numpy as np
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(Z)
</code>

Test:
test_Z = np.zeros((5, 5))
test_Z += np.arange(5)

try:
    np.testing.assert_array_equal(Z, test_Z)
    print('Test passed!')
except:
    print('Test failed...')

A1:
Problem:
Create a 5x5 matrix with row values equals 1, 3, 4, 5, 6.

A:
<code>
import numpy as np
### BEGIN SOLUTION
[insert]
### END SOLUTION
print(Z)
</code>

test:
test_Z = np.ones((5, 5))
test_Z += np.arange(5)
test_Z[:, 1:] += 1

try:
    np.testing.assert_array_equal(Z, test_Z)
    print('Test passed!')
except:
    print('Test failed...')