Напишите программу(или опишите алгоритм), которая (который),

package main

import (
    "strings"
    "log"
    "os"
    "net/url"
    "net/http"
    "io"
    "bytes"
    "encoding/json"
    "fmt"
    "sort"
    "bufio"
)

const (
    API_KEY  = "trnsl.1.1.20180523T112547Z.725c1553f076f23f.81ed61b7dafaf2282289001215c8fe8a4ddbc894"
    BASE_URL = "https://translate.yandex.net"
)

var (
    Debug   = log.New(os.Stdout, "[Debug] ", log.Ldate|log.Ltime|log.Lshortfile)
    Info    = log.New(os.Stdout, "[Info] ", log.Ldate|log.Ltime|log.Lshortfile)
    Warning = log.New(os.Stdout, "[Warning] ", log.Ldate|log.Ltime|log.Lshortfile)
    Error   = log.New(os.Stdout, "[Error] ", log.Ldate|log.Ltime|log.Lshortfile)
)

type Client struct {
    BaseURL   *url.URL
    UserAgent string

    httpClient *http.Client
}

type Translate struct {
    LanguageDetected string   `json:"lang"`
    Translation      []string `json:"text"`
    Word             string
    TranslateTo      string
}

func NewClient(httpClient *http.Client) *Client {
    if httpClient == nil {
        httpClient = http.DefaultClient
    }
    baseUrl, _ := url.Parse(BASE_URL)

    c := &Client{httpClient: httpClient, BaseURL: baseUrl, UserAgent: "TEST"}
    return c
}

func (c *Client) DetectLanguage(word string) (string, error) {
    req, err := c.newRequest("GET", "/api/v1.5/tr.json/detect", nil)

    q := req.URL.Query()
    q.Add("text", word)
    req.URL.RawQuery = q.Encode()

    if err != nil {
        return "", err
    }
    var translate Translate
    _, err = c.do(req, &translate)
    return translate.LanguageDetected, err
}

func (c *Client) TranslateWord(word string, lang string) ([]string, error) {
    req, err := c.newRequest("GET", "/api/v1.5/tr.json/translate", nil)

    q := req.URL.Query()
    q.Add("text", word)
    q.Add("lang", lang)
    req.URL.RawQuery = q.Encode()

    if err != nil {
        return nil, err
    }

    var translate Translate
    _, err = c.do(req, &translate)
    //Debug.Println(translate)
    return translate.Translation, err
}

func (c *Client) newRequest(method, path string, body interface{}) (*http.Request, error) {
    rel := &url.URL{Path: path}
    u := c.BaseURL.ResolveReference(rel)
    var buf io.ReadWriter
    if body != nil {
        buf = new(bytes.Buffer)
        err := json.NewEncoder(buf).Encode(body)
        if err != nil {
            return nil, err
        }
    }
    req, err := http.NewRequest(method, u.String(), buf)
    if err != nil {
        return nil, err
    }
    if body != nil {
        req.Header.Set("Content-Type", "application/json")
    }
    req.Header.Set("Accept", "application/json")
    req.Header.Set("User-Agent", c.UserAgent)
    q := req.URL.Query()
    q.Add("key", API_KEY)
    req.URL.RawQuery = q.Encode()

    return req, nil
}

func (c *Client) do(req *http.Request, v interface{}) (*http.Response, error) {
    resp, err := c.httpClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    err = json.NewDecoder(resp.Body).Decode(v)
    return resp, err
}

func main() {

    //Read string
    reader := bufio.NewReader(os.Stdin)
    fmt.Print("Enter text: ")
    text, _ := reader.ReadString('\n')

    //Parse string
    var ss = strings.Split(text, " ")

    //var ss = strings.Split("green яблоко mandorla buono amigo", " ")

    client := NewClient(nil)
    m := make(map[int]*Translate)

    for i, word := range ss {
        lang, err := client.DetectLanguage(word)

        if err != nil {
            Error.Println(err)
        }

        translate := &Translate{Word: word, LanguageDetected: lang}
        m[i] = translate
    }

    for i, t := range m {
        translate := m[i]

        switch t.LanguageDetected {
        case "ru":
            continue
        case "en":
            translate.TranslateTo = "en-ru"
        default:
            translate.TranslateTo = t.LanguageDetected + "-en"
        }

        translation, err := client.TranslateWord(t.Word, t.TranslateTo)
        translate.Translation = translation

        if err != nil {
            Error.Println(err)
        }
        //Info.Println("Word: ", m[i].Word)
        //Info.Println("Detected: ", m[i].LanguageDetected)
        //Info.Println("To: ", m[i].TranslateTo)
        //Info.Println("Translation: ", m[i].Translation)
    }

    var keys []int
    for k := range m {
        keys = append(keys, k)
    }
    sort.Ints(keys)

    for i := range keys {
        if (m[i].Translation == nil) {
            fmt.Printf("%s ", m[i].Word)

        } else if (i == len(m)-1) {
            fmt.Printf("%s", m[i].Word)
        } else {
            fmt.Printf("%s ", m[i].Translation[0])
        }
    }
}