Ответ на «Отформатируйте строку без ее вывода»

Легче всего это сделать с помощью fmt.Sprintf(), которая возвращает строку, не выводя ее на экран.

Например:

package main

import "fmt"

func main() {
  s := fmt.Sprintf("Size: %d MB.", 85)
  fmt.Println(s)
}

#задача

Задача. Сумма квадратов

Реализуйте функцию SumOfSquares, получающую целое число c и возвращающую сумму всех квадратов между 1 и c. Вам потребуется использовать инструкции select, горутины и каналы.

Например, ввод 5 приведет к возвращению 55, потому что $1² + 2² + 3² + 4² + 5² = 55$.

В качестве отправной точки можно взять этот код:

package main
import "fmt"
func SumOfSquares(c, quit chan int) {
// ваш код
}
func main() {
  mychannel := make(chan int)
  quitchannel:= make(chan int)
  sum:= 0
  go func() {
    for i := 0; i < 6; i++ {
      sum += <-mychannel
    }
    fmt.Println(sum)
  }()
  SumOfSquares(mychannel, quitchannel)
}

Код с решением будет завтра.

#задача

Ответ на «Сумма квадратов»

package main
import "fmt"
func SumOfSquares(c, quit chan int) {
  y := 1
  for {
    select {
    case c <- (y*y):
      y++
    case <-quit:
      return
    }
  }
}
func main() {
  mychannel := make(chan int)
  quitchannel:= make(chan int)
  sum:= 0
  go func() {
    for i := 1; i <= 5; i++ {
      sum += <-mychannel
    }
    fmt.Println(sum)
    quitchannel <- 0
  }()
  SumOfSquares(mychannel, quitchannel)
}

Рассмотрим функцию SumOfSquares. Сначала на строке 4 мы объявляем переменную y, после чего переходим к циклу For-Select. В инструкциях select прописано два кейса.

• case c <- (y*y): служит для отправки квадрата y по каналу c, который принимается в горутине, созданной в основной рутине.
• case <-quit: служит для получения сообщения из основной рутины, которое вернется из функции.

#задача

Задача. Merge sort

Реализуйте конкурентное решение merge sort (сортировка слиянием), используя горутины и каналы.

В качестве опорной точки можно взять эту последовательную реализацию:

package main
import "fmt"
func Merge(left, right [] int) [] int{
  merged := make([] int, 0, len(left) + len(right))
  for len(left) > 0 || len(right) > 0{
    if len(left) == 0 {
      return append(merged,right...)
    }else if len(right) == 0 {
      return append(merged,left...)
    }else if left[0] < right[0] {
      merged = append(merged, left[0])
      left = left[1:]
    }else{
      merged = append(merged, right [0])
      right = right[1:]
    }
  }
  return merged
}
func MergeSort(data [] int) [] int {
  if len(data) <= 1 {
    return data
  }
  mid := len(data)/2
  left := MergeSort(data[:mid])
  right := MergeSort(data[mid:])
  return Merge(left,right)
}
func main(){
  data := [] int{9,4,3,6,1,2,10,5,7,8}
  fmt.Printf("%v\n%v\n", data, MergeSort(data))
}

Код с решением будет завтра.

#задача

Ответ на «Merge sort»

package main
import "fmt"
func Merge(left, right [] int) [] int{
  merged := make([] int, 0, len(left) + len(right))
  for len(left) > 0 || len(right) > 0{
    if len(left) == 0 {
      return append(merged,right...)
    }else if len(right) == 0 {
      return append(merged,left...)
    }else if left[0] < right[0] {
      merged = append(merged, left[0])
      left = left[1:]
    }else{
      merged = append(merged, right [0])
      right = right[1:]
    }
  }
  return merged
}
func MergeSort(data [] int) [] int {
  if len(data) <= 1 {
    return data
  }
  done := make(chan bool)
  mid := len(data)/2
  var left [] int
  go func(){
    left = MergeSort(data[:mid])
    done <- true
  }()
  right := MergeSort(data[mid:])
  <-done
  return Merge(left,right)
}
func main(){
  data := [] int{9,4,3,6,1,2,10,5,7,8}
  fmt.Printf("%v\n%v\n", data, MergeSort(data))
}

В начале при сортировке слиянием мы рекурсивно разделяем массив на right и left стороны и на строках 30-34 вызываем MergeSort для обеих сторон.

Теперь нужно сделать так, чтобы Merge(left, right) выполнялась после получения возвращаемых значений от обоих рекурсивных вызовов, то есть и left и right должны обновляться до того, как Merge(left, right) сможет быть выполнена. Для этого на строке 26 мы вводим канал типа bool и отправляем в него true сразу после выполнения left = MergeSort(data[:mid] (строка 32).

Операция <-done блокирует код на строке 35 до инструкции Merge(left,right), чтобы она не продолжилась, пока горутина не завершится. После завершения горутины и получения true в канале done код переходит к инструкции Merge(left, right) на строке 36.

#задача

Вопрос с собеседования. Какие есть способы достать данные из JSON?

Ответ завтра.

#собеседование

Ответ на «Какие есть способы достать данные из JSON?»

Тут можно либо демаршализовать (Unmarshal) JSON и разлить его данные в объект с фиксированной структурой. Либо можно залить данные в пустой интерфейс.

Для всего этого используется json.Unmarshal()

Ответ на «Что такое горутины и зачем они нужны?»

Горутина (goroutine) — это функция, которая выполняется асинхронно. Чтобы запустить горутину нужно лишь написать что-то вроде этого:

go someFunc(args…) {
  //тут действия
  }()

Весит одна горутина около 4кб. Так что, если у вас 4ГБ оперативной памяти, то можно одновременно запустить немало горутин 🙂

Они нужны, если нам параллельно требуется сделать несколько действий. Например, ваш скрипт должен опросить множество сторонних сервисов и поработать с ответом. А что делать, если некоторые из сервисов долго отвечают? Как говорится, семеро одного не ждут! Каждому по горутине, и тогда не придется ждать «отстающих».

Ответ на «Расскажите об ООП в Golang»

Формально оно в Go есть, но не совсем в том виде, в каком оно есть в PHP или Java.

В Go мы создаем структуры (читайте «классы») с определенными полями (свойствами), и далее создаем «экземпляры» этих структур. Методы описываются отдельно, а не внутри структур.