elixir KERNEL 1

Question 1

1 === 1.0

Answer 1

=> false

*Note: returns true if items have same value and of the same type

Question 2

1 > 2

Answer 2

=> false

Question 3

3 >= 2

Answer 3

=> true

Question 4

is_atom(:hello)

Answer 4

=> true

Question 5

is_boolean(false)

Answer 5

=> true

Question 6

1 !== 2

Answer 6

=> true

Question 7

1 !== 1.0

Answer 7

=> true

Question 8

1 != 2

Answer 8

=> true

Question 9

1 != 1.0

Answer 9

=> false

Question 10

1 * 2

Answer 10

=> 2

Question 11

1 * 2.3

Answer 11

=> 2.3

Question 12

[1] ++ ‘a’

Answer 12

=> [1, 97]

Question 13

[1] ++ [2]

Answer 13

=> [1, 2]

Question 14

1 - 2

Answer 14

=> -1

Question 15

-2 + 1 - -1

Answer 15

=> 0

Question 16

[1, 2, 3] – [1, 2]

Answer 16

=> [3]

Question 17

1 / 2

Answer 17

=> 0.5

Question 18

-5 / 1

Answer 18

=> -5.0

Question 19

1 < 2

Answer 19

=> true

Question 20

1 <= 2

Answer 20

=> true

Question 21

“elixir” =~ ~r/l(i)/

Answer 21

=> true

Question 22

“elixir” =~ ~r/b/

Answer 22

=> false

Question 23

“elixir” =~ “el”

Answer 23

=> true

Question 24

“elixir” =~ “er”

Question 25

“elixir” =~ “”

Answer 25

=> true

Question 26

!”hello”

Answer 26

=> false

Question 27

!nil

Answer 27

=> true

Question 28

!!nil

Answer 28

=> false

Question 29

1..4

Answer 29

=> 1 . . 4

Question 30

is_binary(‘hello’)

Answer 30

=> false

Question 31

What error would be returned?

1 / 0

Answer 31

**(ArithmeticError)

bad argument in arithmetic expression: 1 / 0

Question 32

is_binary(<<0, 1, 2>>)

Answer 32

=> true

Question 33

What type of error would be raised?

x <> “ John” = “bear John”

Answer 33

ArgumentError

**(ArgumentError) the left argument of <> operator inside a match should always be a literal binary as its size can’t be verified.

got: x

Question 34

Some functions are marked as

inlined by the compiler.

What does this mean?

Answer 34

Most of the inlined functions can be seen when capturing the function:

iex> &Kernel.is_atom/1

&:erlang.is_atom/1

BIFs (built-in internal functions) in Erlang-land. Some of them are allowed in guards and others are used for compiler optimizations.

Question 35

How can you tell Elixir not to import the if/2 macro?

Answer 35

import Kernel, except: [if: 2]

Question 36

is_atom(Hello)

Answer 36

=> true

Question 37

What error would be raised?

“he” ++ “llo”

Answer 37

ArgumentError

*Note: You can perform ‘he’ ++ ‘llo’ on codepoints,

but not on a String

Question 38

[1] ++ [2 | 3]

Answer 38

=> [1, 2 | 3]

Question 39

[1] ++ 2

Answer 39

=> [1 | 2]

*returns improper list

Question 40

[1, 2, 3, 2, 1] – [1, 2, 2]

Answer 40

=> [3, 1]

The complexity of a–b is proportional to length(a) * length(b), meaning that it will be very slow if both a and b are long lists. In such cases, consider using MapSet.difference/2

Question 41

1 == 1.0

Answer 41

=> true

Question 42

is_binary(“hello”)

Answer 42

=> true

Question 43

‘he’ ++ ‘llo’

Answer 43

=> ‘hello’

Question 44

is_boolean(nil)

Answer 44

=> false

Question 45

defmodule Person do

@name “Keith”

def fun, do: @name

@name “James”

def clever, do: @name

end

[Person.fun, Person.clever]

Answer 45

=> [“Keith”, “James”]

It is important to note that reading an attribute takes a snapshot of its current value.

In other words, the value is read at compilation time and not at runtime.

Try to avoid rebinding module attributes.

Question 46

is_boolean(1) &&

is_float(1.2)

Answer 46

=> false

Question 47

is_integer(1) &&

is_atom(:a)

Answer 47

=> true

Question 48

Map.get(1..4, :first)

Answer 48

=> 1

Question 49

Map.get(1..4, :last)

Answer 49

=> 4

Question 50

%Range{

first: _a,
last: b

} = 1..4

b

Answer 50

=> 4

Question 51

“bear “ <> x = “bear John”

x

Answer 51

=> “John”

Question 52

Which operation is preferable?

def inc([], acc), do: acc

def inc([h | t], acc), do: inc(t, acc ++ [h+1])

vs

def inc([], acc), do: Enum.reverse(acc)

def inc([h | t], acc), do: inc(t, [h + 1 | acc])

Answer 52

The complexity of a ++ b is proportional to length(a), so avoid repeatedly appending to lists of arbitrary length. Instead, consider prepending via [head | tail] and then reversing.

Question 53

is_boolean(false) &&

nil &&

is_atom(:hello)

Answer 53

=> nil

*Note: returns first falsey value or the last value

Question 54

is_number(2.3) &&

is_list(5) &&

is_float(1.2)

Answer 54

=> false

*Note: returns first falsey value or true