From 4cf06d601c0d2e6be4aa83aae66470d0bfe21a2a Mon Sep 17 00:00:00 2001 From: Inanc Gumus Date: Mon, 22 Oct 2018 01:02:30 +0300 Subject: [PATCH] add: switch statement questions --- 12-switch/questions/questions.md | 190 ++++++++++++++++++++++++++++++- 1 file changed, 186 insertions(+), 4 deletions(-) diff --git a/12-switch/questions/questions.md b/12-switch/questions/questions.md index 28362a6..8af651e 100644 --- a/12-switch/questions/questions.md +++ b/12-switch/questions/questions.md @@ -1,4 +1,186 @@ -## ? -1. text *CORRECT* -2. text -E \ No newline at end of file +## What's the difference between if and switch statements? +1. If statement controls the execution flow but the switch statement does not +2. If statement is much more readable alternative to a switch statement +3. Switch statement is much more readable alternative to a if statement *CORRECT* + +> **1:** They both control the execution flow. +> +> **2:** Sometimes true, but, for complex if statements, switch statement can make them much more readable. + + +## What type of values you can use as a switch condition? +```go +switch condition { + // .... +} +``` +1. int +2. bool +3. string +4. Any type of values *CORRECT* + +> **4:** Unlike most other C based languages, in Go, a switch statement is actually a syntactic-sugar for a if statement. This means that, Go converts a switch statement into an if statement behind the scenes. So, any type of values can be used as a condition. + + +## What type of values you can use as the case conditions for the following switch statement? +```go +switch false { +case condition: + // ... +} +``` +1. int +2. bool *CORRECT* +3. string +4. Any type of values + +> **2:** Yes, you can only use bool values because in the example, the switch's condition is a bool. + + +## What type of values you can use as the case conditions for the following switch statement? +```go +switch "go" { +case condition: + // ... +} +``` +1. int +2. bool +3. string *CORRECT* +4. Any type of values + +> **3:** Yes, you can only use string values because in the example, the switch's condition is a string. + + +## What's the problem in the following code? +```go +switch 5 { +case 5: +case 6: +case 5: +} +``` +1. Case clauses don't have any statements +2. The same constants are used multiple times in case conditions *CORRECT* +3. Switch condition cannot be an untyped int + +> **2:** That's right. 5 is used by multiple case clauses as case conditions. It should be used only once. + + +## When the following code runs, which case will be executed? +```go +weather := "hot" +switch weather { +case "very cold", "cold": + // ... +case "very hot", "hot": + // ... +default: + // ... +} +``` +1. None of them +2. The first case clause +3. The second case clause *CORRECT* +4. The default clause + +> **3:** That's right. When switch's condition is either "hot" or "very hot", the 2nd case will be executed. + + +## When the following code runs, which clause will be executed? +```go +switch weather := "too hot"; weather { +default: + // ... +case "very cold", "cold": + // ... +case "very hot", "hot": + // ... +} +``` +1. None of them +2. The first case clause +3. The second case clause +4. The default clause *CORRECT* + +> **4:** That's right. The switch's condition doesn't match to any of the case conditions, so the default clause will be executed as a last resort. And the default clause can be in any place inside a switch statement. + + +## When the following code runs, which case will be executed? +```go +switch weather := "too hot"; weather { +case "very cold", "cold": + // ... +case "very hot", "hot": + // ... +} +``` +1. None of them *CORRECT* +2. The first case clause +3. The second case clause +4. The default clause + +> **1:** That's right. The switch's condition doesn't match to any of the case conditions, and there isn't a default clause. So, none of the clauses will be executed. + + +## What does the following program print? +```go +richter := 2.5 + +switch r := richter; { +case r < 2: + fallthrough +case r >= 2 && r < 3: + fallthrough +case r >= 5 && r < 6: + fmt.Println("Not important") +case r >= 6 && r < 7: + fallthrough +case r >= 7: + fmt.Println("Destructive") +} +``` +1. Nothing +2. "Not important" *CORRECT* +3. "Destructive" + +> **2:** That's right! When fallthrough is used, the following clause will be executed without checking its condition. + + +## What's the problem in the following code? +```go +richter := 14.5 + +switch r := richter; { +case r >= 5 && r < 6: + fallthrough + fmt.Println("Moderate") +default: + fmt.Println("Unknown") +case r >= 7: + fmt.Println("Destructive") +} +``` +1. default clause should be the last clause +2. default clause should have a fallthrough statement +3. The first case should use the fallthrough statement as its last statement *CORRECT* + +> **3:** That's right! In a case block, fallthrough can only be used as the last statement. + + +## What does the following program print? +```go +n := 8 + +switch { +case n > 5, n < 1: + fmt.Println("n is big") +case n == 8: + fmt.Println("n is 8") +} +``` +1. Nothing +2. "n is 8" +3. "n is big" *CORRECT* + +> **3:** That's right! Switch runs top-to-bottom and case conditions run left-to-right. Here, 1st case's 1st condition expression (which is n > 5) will yield true, so the 1st case will be executed. \ No newline at end of file