gaspersic/learngo
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add: questions for comparison and logical ops

Browse Source
This commit is contained in:
Inanc Gumus
2018-10-19 20:03:13 +03:00
parent e4f3be01e4
commit eb8d68981a
5 changed files with 263 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
11-if/questions/1-comparison-operators.md Normal file
View File

@ -0,0 +1,135 @@
## Which one below is not one of the equality operators of Go?
1. `==`
2. `!=`
3. `>` *CORRECT*
> **3:** That's the greater operator. It checks whether a ordered value is greater than the other or not.
## Which one below is not one of the comparison operators of Go?
1. `>`
2. `<=`
3. `==` *CORRECT*
4. `<`
> **3:** That's the equal operator. In an expression, it checks whether a value (operand) is equal to another value (operand).
## Which one of these types is returned by the comparison operators?
1. int
2. byte
3. bool *CORRECT*
4. float64
> **3:** That's right. All the comparison operators return an untyped bool value (true or false).
## Which one of these cannot be used as an operand to ordering operators (`>`, `<`, `>=`, `<=`)?
1. int value
2. byte value
3. string value
4. bool value *CORRECT*
5. all of them
> **1-2:** This is an ordered value, it can be used.
>
> **3:** String is an ordered value because it's a series of numbers. So, it can be used as an operand.
>
> **4:** That's right. A bool value is not an ordered value, so it cannot be used with ordering operators.
## Which one of these cannot be used as an operand to equality operators (`==`, `!=`)?
1. int value
2. byte value
3. string value
4. bool value
5. They all can be used *CORRECT*
> **5:** That's right. Every **comparable value** can be used as an operand to equality operators.
## What does this code print?
```go
fmt.Println("go" != "go!")
fmt.Println("go" == "go!")
```
1. true true
2. true false *CORRECT*
3. false true
4. false false
5. error
> **3-4:** Watch out for the exclamation mark at the end of the second string value.
## What does this code print?
```go
fmt.Println(1 == true)
```
1. true
2. 1
3. false
4. 2
5. error *CORRECT*
> **5:** That's right. A numeric constant cannot be compared to a bool value.
## What does this code print?
```go
fmt.Println(2.9 > 2.9)
fmt.Println(2.9 <= 2.9)
```
1. true true
2. true false
3. false true *CORRECT*
4. false false
5. error
## What does this code print?
```go
fmt.Println(1 >= true)
fmt.Println(0 <= false)
```
1. true true
2. true false
3. false true
4. false false
5. error *CORRECT*
> **5:** That's right. Bool values are not ordered values, so they cannot be compared using the comparison operators.
## How to fix this program without losing precision?
```go
package main
import "fmt"
func main() {
weight, factor := 500, 1.5
weight *= factor
fmt.Println(weight)
}
```
1. It cannot be fixed
2. `weight *= float64(factor)`
3. `weight *= int(factor)`
4. `weight = float64(weight) * factor`
5. `weight = int(float64(weight) * factor)` *CORRECT*
> **1:** It can be fixed.
>
> **2:** Type mismatch: weight is int.
>
> **3:** Lost precision: factor will be 1.
>
> **4:** Type mismatch: weight is int (cannot assign back).
>
> **5:** That's right. The result would be 750.

120
11-if/questions/2-logical-operators.md Normal file
View File

@ -0,0 +1,120 @@
## Which one below is not one of the logical operators of Go?
1. `||`
2. `!=` *CORRECT*
3. `!`
4. `&&`
> **2:** That's the "not equal" operator. It's a comparison operator, not a logical operator.
## Which one of these types is returned by a logical operator?
1. int
2. byte
3. bool *CORRECT*
4. float64
> **3:** That's right. All the logical operators return an untyped bool value (true or false).
## Which one of these can be used as an operand to a logical operator?
1. int
2. byte
3. bool *CORRECT*
4. float64
> **3:** That's right. All the logical operators expect a bool value (or a bool expression that yields a bool value).
## What does this program print?
```go
package main
import "fmt"
func main() {
var (
on = true
off = !on
)
fmt.Println(!on && !off)
fmt.Println(!on || !off)
}
```
1. true true
2. true false
3. false true *CORRECT*
4. false false
5. error
> **3:** `!on` is false. `!off` is true. So, `!on && !off` is false. And, `!on || !off` is true.
## What does this program print?
```go
package main
import "fmt"
func main() {
on := 1
fmt.Println(on == true)
}
```
1. true
2. false
3. error *CORRECT*
> **3:** `on` is int, while `true` is a bool. So, there's a type mismatch error here. Go is not like other C based languages where `1` equals to `true`.
## What does this code print?
```go
// Note: "a" comes before "b"
a := "a" > "b"
b := "b" <= "c"
fmt.Println(a || b)
```
1. "a"
2. "b"
3. true *CORRECT*
4. false
5. error
> **1-2:** Logical operators return a bool value only.
> **3:** Order is like so: "a", "b", "c". So, `"a" > "b"` is false. `"b" <= "c"` is true. So, `a || b` is true.
> **5:** There isn't an error. Strings are actually numbers, so, they're ordered and can be compared using the ordering operators.
## What does the following program print?
```go
// Let's say that there are two functions like this:
//
// `a()` which returns `true` and prints `"A"`.
// `b()` which returns `false` and prints `"B"`.
//
// Remember: Logical operators short-circuit.
_ = b() && a()
_ = a() || b()
```
1. "BAAB"
2. "BA"
3. "ABBA"
4. "AB"
> **1, 3:** Remember: Logical operators short-circuit.
> **2:** That's right.
>
> In: `b() && a()`, `b()` returns false, so, logical AND operator short-circuits and doesn't call `a()`; so it prints: `"B"`.
>
> Then, in: `a() || b()`, `a()` returns true, so, logical OR operator short circuits and doesn't call `b()`; so it prints `"A"`.
> **4:** Think again.
Example program is [here](https://play.golang.org/p/JqEFVh5kOCE).

7
11-if/questions/3-if.md Normal file
View File

@ -0,0 +1,7 @@
## What does control flow mean?
1. Changing the top-to-bottom execution of a program
2. Changing the left-to-right execution of a program
3. Controlling which statements are executed *CORRECT*
> 1. You can't change that.
> 2. You can't change that.

3
11-if/questions/questions.md
View File

@ -1,3 +0,0 @@
## ?
* text *CORRECT*
* text

2
13-loops/exercises/more-exercises.md
View File

@ -1,2 +1,2 @@
**You can find more exercises here:**
**You can also find more exercises here:**
* https://www.rosettacode.org/wiki/Category:Iteration