learngo/08-numbers-and-strings/02-strings/questions/questions.md

What's the result of this expression?

"\"Hello\\"" + ` \"World\"`

1. "Hello" "World"
2. "Hello" "World" CORRECT
3. "Hello" "World"
4. ""Hello" \"World\""

1: Go doesn't interpret the escape sequences in raw string literals.

2: That's right. Go interprets \" as " but it doesn't do so for \"World\".

What's the best way to represent the following text in the code?

<xml>
  <items>
    <item>"Teddy Bear"</item>
  </items>
</xml>

1. CORRECT

`<xml>
    <items>
        <item>"Teddy Bear"</item>
    </items>
</xml>`

"<xml>
    <items>
        <item>"Teddy Bear"</item>
    </items>
</xml>"

"<xml>
    <items>
        <item>\"Teddy Bear\"</item>
    </items>
</xml>"

`<xml>
    <items>
        <item>\"Teddy Bear\"</item>
    </items>
</xml>`

2-3: You can't write a string literal like that. It can't be multiple-lines.

4: You don't need to use escape sequences inside raw string literals.

What's the result of the following expression?

len("lovely")

1. 7
2. 8
3. 6 CORRECT
4. 0

2: Remember! "a" is 1 char. a is also 1 char.

What's the result of the following expression?

len("very") + len(`\"cool\"`)

1. 8
2. 12 CORRECT
3. 16
4. 10

1: There are also double-quotes, count them as well.

2: That's right. Go doesn't interpreted " in raw string literals.

3: Remember! "very" is 4 characters. very is also 4 characters.

4: Remember! Go doesn't interpreted " in raw string literals.

What's the result of the following expression?

len("very") + len("\"cool\"")

1. 8
2. 12
3. 16
4. 10 CORRECT

1: There are also double-quotes, count them as well.

2: Remember! Go interprets escape sequences in string literals.

4: That's right. Go does interpret " in a string literal. So, """ means ", which is 1 character.

What's the result of the following expression?

len("péripatéticien")

HINT: é is 2 bytes long. And, the len function counts the bytes not the letters.

USELESS INFORMATION: "péripatéticien" means "wanderer".

1. 14
2. 16 CORRECT
3. 18
4. 20

1: Remember! é is 2 bytes long.

2: An english letter is 1 byte long. However, é is 2 bytes long. So, that makes up 16 bytes. Cool.

3: You didn't count the double-quotes, did you?

How can you find the correct length of the characters in this string literal?

"péripatéticien"

1. len(péripatéticien)
2. len("péripatéticien")
3. utf8.RuneCountInString("péripatéticien") CORRECT
4. unicode/utf8.RuneCountInString("péripatéticien")

1: Where are the double-quotes?

2: This only finds the bytes in a string value.

4: You're close. But, the package's name is utf8 not unicode/utf8.

What's the result of the following expression?

utf8.RuneCountInString("péripatéticien")

1. 16
2. 14 CORRECT
3. 18
4. 20

1: This is its byte count. RuneCountInString counts the runes (codepoints) not the bytes.

2: That's right. RuneCountInString returns the number of runes (codepoints) in a string value.

Which package contains string manipulation functions?

1. string
2. unicode/utf8
3. strings CORRECT
4. unicode/strings

What's the result of this expression?

strings.Repeat("*x", 3) + "*"

HINT: Repeat function repeats the given string.

1. *x*x*x
2. x*x*x
3. *x3
4. *x*x*x* CORRECT

1: You're close but you missed the concatenation at the end.

2: Look closely.

3: Wow! You should really watch the lectures again. Sorry.

4: That's right. Repeat function repeats the given string. And, the concatenation operator combines the strings.

What's the result of this expression?

strings.ToUpper("bye bye ") + "see you!"

1. bye bye see you!
2. BYE BYE SEE YOU!
3. bye bye + see you!
4. BYE BYE see you! CORRECT

1: You missed the ToUpper?

2: You're close but look closely. ToUpper only changes the first part of the string there.

3: Not even close. Sorry.

4: Perfect! Good catch! ToUpper only changes the first part of the string there.