learngo/09-go-type-system/questions/01-questions-predeclared-types.md

## Which one is **not** a predeclared data type of Go?
1. int
2. float64
3. uint64
4. uint
5. duration *CORRECT*
6. int8
7. rune
8. byte
9. float32
10. complex128


## What's a predeclared data type?
1. A data type used only in the compiler
2. A built-in data type that comes with Go that you can use it from anywhere without importing any package *CORRECT*
3. The data type of a variable


## By using only 8 bits, how many different numbers or states can you represent?
1. 8
2. 16
3. 256 *CORRECT*
4. 65536

> 3. 2^8 is 256, so you can represent 256 different states.


## How many bits 2 bytes contains?
1. 2
2. 8
3. 16 *CORRECT*
4. 32
5. 64


## What's the output of following code?
```go
fmt.Printf("%08b = %d", 2)
```
1. 00000001
2. 00000010 *CORRECT*
3. 00000100
4. 00001000

> EXPLANATION = From right to left, each bit goes from 2^0 to 2^(n - 1).

> 1. EXPLANATION. Here: 1 is the first digit from the right. So, it is 2^(1 - 1) = 2^0 = 1.
> 2. EXPLANATION. Here: 1 is the second digit from the right. So, it is 2^(2 - 1) = 2^1 = 2.
> 3. EXPLANATION. Here: 1 is the third digit from the right. So, it is 2^(3 - 1) = 2^2 = 4.
> 4. EXPLANATION. Here: 1 is the fourth digit from the right. So, it is 2^(4 - 1) = 2^3 = 8.


## How many bytes of memory does an int64 value use?
1. 4
2. 8 *CORRECT*
3. 32
4. 64

> 2. 1 byte is 8 bits and int64 is 64 bits. So, 64/8=8 bytes.


## How many bytes are needed to store a value of uint32 type?
1. 4 *CORRECT*
2. 8
3. 32
4. 64

> 2. 1 byte is 8 bits and uint32 is 32 bits. So, 32/8=4 bytes.


## What's the size of int data type?
1. Depends: 32 bits or 64 bits. *CORRECT*
2. 32 bits
3. 64 bits

> 1. That's right. Go can change its size at the compile-time depending on which target machine you're compiling your program into.


## English letters can be represented by the numbers within the range of: 0-255. For example, 'A' can be 65. Or, 'B' can be 66. So, what's the best data type for storing an English letter?

1. byte *CORRECT*
2. rune
3. int64
4. float64

> 1. That's right. A byte can represent 0-255 different values. So, it's a great fit for representing English letters, and numbers.
> 2. In practice, you can do it with a rune value. However, rune is 32-bits long and it can store almost every letter in existince. I'm asking for the optimal data type. Try again.
> 3. That would be too large for only 255 different numbers.
> 4. Float is not the best data type for numbers without fractional parts.



## What does the following code print?
```go
var letter uint8 = 255
fmt.Print(letter + 5)
```
1. 0
2. 4 *CORRECT*
3. 5
4. 260

> 2. Unsigned integers wrap around after their maximum capacity. Uint8's max is 255, so, if 255 + 1 is 0, then 255 + 5 is 4.
> 3. You're very close.
> 4. Uint8's max capacity is 255. It can't be 260.


## What does the following code print?
```go
var num int8 = -128
fmt.Print(num - 3)
```
1. -131
2. 125 *CORRECT*
3. -125

> 1. int8's min capacity is -128. It can't be -131.
> 2. Signed integers wrap around after their minimum capacity. int8's min is -128, so, if -128 - 1 is 127, then -128 - 3 is 125.