Here is a Julia version of exercises with solutions which is based on the exercises given here: https://github.com/rougier/numpy-100

####
1. Import the julia package LinearAlgebra under the name `la`

```
import LinearAlgebra as la #or
import LinearAgebra
const la = LinearAlgebra
```

#### 2. Print the version of julia package Javis

```
]
status Javis
```

#### 3. Create a zero vector of size 10 and of type Int64

```
a = zeros(Int64,10)
```

#### 4. How to find the memory size of any array in bytes

```
sizeof(a)
length(a)*sizeof(eltype(a))
```

#### 5. How to get the documentation of the Julia zero function from the command line?

```
?zeros
```

#### 6. Create a Int vector of size 10 but the fifth value which is 1 (in two lines of code)

```
a = zeros(Int,10)
a[5] = 1
```

#### 7. Create a vector with values ranging from 10 to 49

```
a = [10:49;]
a = collect(10:49)
```

#### 8. Return the reverse of a vector (first element becomes last)

```
a[end:-1:1] #faster
reverse(a)
reverse!(a) #inplace
```

#### 9. Create a 3x3 matrix with values ranging from 0 to 8

```
a = reshape(0:8,3,3)
```

#### 10. Find indices of non-zero elements from [1,2,0,0,4,0]

```
findall(!isequal(0),a)
findall(!iszero,a)
findall(!=(0),a)
```

#### 11. Create a 3x3 identity matrix

```
using LinearAlgebra
a = I(3)
a = Matrix(1.0I,3,3)
```

#### 12. Create a 3x3x3 array with random values

```
a = rand(3,3,3) #numbers in the range 0 to 1
b = randn(3,3,3) #Gaussian random numbers
```

#### 13. Create a 10x10 array with random values and find the minimum and maximum values

```
a = rand(10,10)
minm = minimum(a)
maxm = maximum(a)
minm, maxm = extrema(a)
```

#### 14. Create a random vector of size 30 and find the mean value

```
using Statistics
a = rand(30) #rand(30,)
b = mean(a)
```

#### 15. Create a 2d array with 1 on the border and 0 inside

```
a = zeros(5,5)
a[1,:] .= 1
a[end,:] .= 1
a[2:end-1,1] .= 1
a[2:end-1,end] .= 1
a[:,1] .= 1;a[:,end] .= 1 #Last two steps can be replaced by this line
```

#### 16. How to add a border (filled with 0's) around an existing array?

```
a = rand(5,5)
b = zeros(Float64,size(a,1)+2,size(a,2)+2)# b = zeros(eltype(a), size(a) .+ 1)
b[2:end-1,2:end-1] = a
```

#### 17. What is the result of the following expression? (â˜…â˜†â˜†)

```
(0 * NaN) >= NaN : false
NaN == NaN : false
NaN > NaN : false
NaN - NaN : NaN
NaN in Set([NaN]) : true
NaN in [NaN] : false
0.3 == 3 * 0.1 : false #floating point rounding error
isapprox(0.3 , 3 * 0.1) : true
```

#### 18. Create a 5x5 matrix with values 1,2,3,4 just below the diagonal

```
a = Bidiagonal(zeros(5,),collect(1:4),:L)
```

#### 19. Create a 8x8 matrix and fill it with a checkerboard pattern

```
a = zeros(Int64,8,8)
a[1:2:end,1:2:end] .= 1
a[2:2:end,2:2:end] .= 1 #or
a = [Int(isodd(i+j)) for i in 1:8, j in 1:8]
```

#### 20. Consider a (6,7,8) shape array, what is the index (x,y,z) of the 100th element?

```
m = 100
n,p,r = 6,7,8
page = Int64(ceil(m/n/p))
col = Int64(ceil((m-(page-1)*n*p)/n))
row = Int64(ceil((m-(page-1)*n*p-(col-1)*n)/n))
CartesianIndices((6,7,8))[m] #builtin command
```

#### 21. Create a checkerboard 8x8 matrix using the repeat function (â˜…â˜†â˜†)

```
repeat([1 0;0 1],4,4)
```

#### 22. Normalize a 5x5 random matrix (â˜…â˜†â˜†)

```
a = randn(5,5)
a = a .- minimum(a)
a = a./maximum(a)
```

#### 23. Create a custom dtype that describes a color as four unsigned bytes (RGBA) (â˜…â˜†â˜†)

```
mutable struct color
R::UInt8
G::UInt8
B::UInt8
A::UInt8
end
```

#### 24. Multiply a 5x3 matrix by a 3x2 matrix (real matrix product)

```
a = rand(5,3);b = rand(3,2)
c = a*b
```

#### 25. Given a 1D array, negate all elements which are between 3 and 8, in place. (â˜…â˜†â˜†)

```
a = 3;b = 8;
x = rand(1:10,20) # collect(1:10)
x[a .<= x .<= b] .= -x[a .<= x .<= b] #or
x[a .<= x .<= b] .*= -1.
```

#### 26. What is the output of the following script? (â˜…â˜†â˜†) [Python only]

```
```

#### 27. Consider an integer vector Z, which of these expressions are legal?

```
Z.^Z #valid
2 << Z >> 2 #not valid
Z <- Z # Z < (-Z)
1im*Z #valid
Z/1/1 #valid,converted to float vector
Z<Z>Z #valid
```

#### 28. What are the result of the following expressions? (â˜…â˜†â˜†)

```
[0]/[0] : 1x1 Matrix Float64 0.0
[0] ./ [0] : NaN
[0]// [0] : MethodError
[0] .Ã· [0] : DivideError
Float64(Int64([NaN])) : MethodError
```

#### 29. How to round away from zero a float array ? (â˜…â˜†â˜†)

```
round.(-4.5, RoundNearestTiesAway)
```

#### 30. How to find common values between two arrays? (â˜…â˜†â˜†)

```
intersect(A,B) #A and B are sets
```

#### 31. How to ignore all Julia warnings (not recommended)? (â˜…â˜†â˜†)

#### 32. Is the following expressions true? [Python only]â˜…â˜†â˜†)

```
np.sqrt(-1) == np.emath.sqrt(-1)
```

#### 33. How to get the dates of yesterday, today and tomorrow? (â˜…â˜†â˜†)

```
using Dates
tod = today()
tom = tod + Day(1)
yes = tod + Day(-1)
```

#### 34. How to get all the dates corresponding to the month of July 2016? (â˜…â˜…â˜†)

```
using Dates
mon = collect(Date(2016,7,1):Day(1):Date(2016,7,31))
```

#### 35. How to compute ((A+B)*(-A/2)) in place (without copy)? (â˜…â˜…â˜†)

```
A = rand(2,2);B = rand(2,2)
@. A = ((A+B)*(-A/2))
```

#### 36. Extract the integer part of a random array of positive numbers using 4 different methods (â˜…â˜…â˜†)

```
A = 10*rand(1,10)
Int64.(trunc.(A))
B = parse.(Int64,[split(string(x),".")[1] for x in A])
Int64.(floor.(A))
Int64.(ceil.(A)) .- 1
```

#### 37. Create a 5x5 matrix with row values ranging from 0 to 4 (â˜…â˜…â˜†)

```
a = rand(0:4,5,5)
```

#### 38. Consider a generator function that generates 10 integers and use it to build an array (â˜…â˜†â˜†)

```
a = collect(1:10)
```

#### 39. Create a vector of size 10 with values ranging from 0 to 1, both excluded (â˜…â˜…â˜†)

```
a = rand(10)
```

#### 40. Create a random vector of size 10 and sort it (â˜…â˜…â˜†)

```
a = rand(10,)
sort!(a)
```

#### 41. How to sum a small array faster than np.sum?Python only

#### 42. Consider two random array A and B, check if they are equal (â˜…â˜…â˜†)

```
isequal(A,B)
```

#### 43. Make an array immutable (read-only) (â˜…â˜…â˜†)

#### 44. Consider a random 10x2 matrix representing cartesian coordinates, convert them to polar coordinates (â˜…â˜…â˜†)

```
a = rand(10,2);
ang = angle.(a[:,1] .+ 1im*a[:,2])
r = hypot.(a[:,1] .+ a[:,2])# sqrt.(a[:,1].^2 .+ a[:,2].^2)
p = r.*cis.(ang) # r.*exp.(1im*ang)
#or
to_polar(x, y) = hypot(x, y) * cis(angle(x+im*y))
[to_polar(x...) for x in eachrow(a)] #or
[to_polar(a[i, 1], a[i, 2]) for i in axes(a, 1)]
```

#### 45. Create random vector of size 10 and replace the maximum value by 0 (â˜…â˜…â˜†)

```
a = rand(10)
a[a .== maximum(a)] .= 0
```

####
46. Create a structured array with `x`

and `y`

coordinates covering the [0,1]x[0,1] area (â˜…â˜…â˜†)

```
mutable struct xy
x:Float64
y:Float64
end
```

#### 47. Given two arrays, X and Y, construct the Cauchy matrix C (Cij =1/(xi - yj)) (â˜…â˜…â˜†)

```
X = rand(5);Y = rand(5);
C = [1/(xi-yi) for xi in X, yi in Y]#or
C = 1 ./ (X .- Y')
```

#### 48. Print the minimum and maximum representable value for each Julia scalar type

```
typemin()
typemax()
```

#### 49. How to print all the values of an array? (â˜…â˜…â˜†)

```
print(a)
display(a)
foreach(println, a) #prints full array
```

#### 50. How to find the closest value (to a given scalar) in a vector? (â˜…â˜…â˜†)

```
a = rand(10)
x = 0.5 #given scalar
b = abs.(a .- x)
a[findmin(b)[2]]
```

I will update remaining exercises in due course.

## Top comments (2)

It would be great to get these setup and linked on GitHub as well! Let me know if you want to put them in the Julia Community GitHub organization.

I think #44 can be done more simply:

Similarly for #50:

(or

`minimum(a -> abs(a - x), A)`

if you just want the value of`abs(a - x)`

as in your solution)