แแแแ แแแแแแแก แแแแแแแแแแแจแ แแ แแแงแแแแแแ Go-แก แแแแฎแแ แชแแแแแแแกแแแแก.
แจแแฅแแแแแแ แกแฃแกแขแ แแ แแแ แแแแกแขแแแแกแแแแก?
Go แซแแแแแ แแแแแแ แกแแกแฌแแแแแ, แแแแแแแ แแแ แขแแแ, แ แแ แจแแกแแแแแ แแ แ แกแแฆแแแแก แแแแญแแ แแ, แ แแก แจแแแแแแแช แฃแแแ แจแแแแซแแ แแ แแแฃแฅแขแแฃแแ แแแแแ แแแ. แฌแแแแก, แ แแแแแกแแช แแแกแฌแแแแแแ Go, แฐแฅแแแ
Google แแแขแแแชแแแก, แ แแ Go-แก แกแแแแ แขแแแ แแ แแก แแแกแ แแแงแแแแแก แฌแแ แขแแแ แแ แแแ แจแแฅแแแแแแ แแแแ แแฃแแแแแแก แแแฅแกแแแแแฃแ แ แแ แแแฃแฅแขแแฃแแแแแกแแแแก, แแแแ แแ แแ แแแแญแแแแ. แแ แแก แคแฃแแฅแชแแแแ, แ แแแแแแแช แแ แแแแแ แแ แแแแแแขแแ แแแขแแแฃแ แแแแ แแฆแฌแแ แแแ. แแ แแก แงแแแแแคแแ แ แแแแแแแแแ แแแแกแแแแ แแแแแแก แแแแแแแแแแก แแแแ, แแ แแแ แแฃแแแ, แ แแ แแแ แแ แจแแฃแซแแแแ แแ แแคแ แแก แแแแแแแแ แกแฌแแ แแ. แกแแแแ แขแแแแก แแก แกแฃแ แแแแ แแแแก แแแแแแแแ แแแแก แจแแแแแแฃแแ แแแแแฌแงแแแขแแแแแ แแงแ แแ แแแแกแแแแแก, แ แแ แกแ แฃแแแ แแแแแแแ, แ แแขแแ แแงแ แแก แกแแญแแ แ, แฃแแแ แแแแกแแแแแก แแแแแแแแแ แแแแก แแแขแแแแชแแ แแ แ แแก แแแฆแฌแแแแก แชแแแแแแแแแ Go-แจแ.
แ แแขแแ แแแแแแแ แแกแ แแแ แขแแแ? แแฅ แแ แแก แ แแแแแแแแ แชแแขแแขแ
แแแแแแ แ แแฅ แแ แแก แแก, แ แแ แฉแแแแ แแ แแแ แแแแกแขแแแ (แแแแฎแ.:
แแฃแแแแก แแแแแแจแ แแแแแแ ) แแ แแ แแแ แแแแแแแแ แแแ. แแกแแแ, แ แแแแ แช แฌแแกแ, แกแแแแแแ แแฎแแแแแแ แแแแ แแ แแแ, แฉแแแแแแ แกแฌแแแแแก แจแแแแแ แแแแแแ, แแแแแ Java-แก แกแฌแแแแแแแแแ, แแ C/C++-แก, แแ แแแแแแก. แแแ แแ แแกแแแ แจแแกแแแแจแแแแ แแแ, แแแแ แแ แแแแแ แแ แแก แฉแแแ แแแแแแ, แ แแ แแแ แจแแฅแแแแ แแแ แแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ. แแแแขแแ แแแแ แแแ แแแแแแแก แแแแแแ แแแกแแแแแ แแ แจแแกแแกแฌแแแแ แฃแแแ แแงแแก.
แแก แฃแแแ แแงแแก แแแชแแแแ, แฃแฎแแจแแ แ แแ แแแฅแแแ C-แแก แแกแแแแกแ. Google-แจแ แแแแฃแจแแแ แแ แแแ แแแแกแขแแแ แแแ แแแ แแก แแแ แ แแฌแงแแแแ แแ แซแแ แแแแแแ แแชแแแแแ แแ แแชแแแฃแ แฃแ แแแแแก, แแแแกแแแฃแแ แแแแ C แแฏแแฎแก. แแฎแแแ แแ แแแ แแแแ แแแแก แแแแจแ แกแฌแ แแคแ แแ แแแฃแฅแขแแฃแแแแแก แแแแฎแแแแ แแแจแแแแก, แ แแ แแแ แแ แฃแแแ แแงแแก แซแแแแแ แ แแแแแแแฃแ แ.
แฒ แ? แแกแ แ แแ, แ แแ แแแแแ แซแแ แแแแแแ แแแแแแก, แ แแ Google-แแก แแแแแแแแแ แแแ แแ แช แแฃ แแกแ แแแ แแแแ แแ แแแ, แแแแขแแ แจแแฅแแแแก แแแ แแแแแขแแแแกแแแแก (แแแแฎแ.: แแแแฃแแฏแแ) แ แแ แ แแฆแแชแแก แแแแแแแแ แจแแซแแแ. แ แแแแ แ แแแแแ แขแแแแแ แฃแงแฃแ แแแก แกแแแฃแแแ แแแแแแแแก? แแ แงแแแแแแแแก แแฏแแ แแแ, แ แแ Google-แแก แแแแแแแแแ แแแ แจแแ แฉแแฃแแแ แแ แแแ แงแแแแแแ แแแแแแ แแ แกแแฃแแแแแกแ แแแแแแแฌแแแ. แ แ แแฅแแ แฃแแแ, แแแ แจแแฃแซแแแแ แแแฃแแแแแแแแแ แ แแแแ แฃแคแ แ แ แแฃแแก?
แแแแแญแแ แแแแฃแแ แกแแแแ แขแแแแก แแ แขแแคแแฅแขแแแ
แฃแแ แแแแแแ แแแแแกแแแแ แ แแแแแแแแก แฆแแ แกแแฃแแ แแแแแแแ แแ แ แแฆแแช แแแ แขแแแแก แแแแแแแแ แ แแฃแแแ. แแฃแแชแ, แ แแฃแแ แแ แแแแแแแแแก แแแแแญแ แแก (แแ แแฃแแแแช แแแแแฎแแขแแแก) แแชแแแแแแแกแแก, แแแแฏแแ แ แแฃแแ แแแกแขแ แฃแแแแขแแ แกแแญแแ แ. แกแแ แแฃแแ แแ แกแแ แแฃแแ แแ แแ แแก แแ แแแ แแแแ แแแแก แแแแก แกแแฃแแแแแกแ แแแฎแแกแแแแแแแแ, แแแแ แแ แแ แกแแแแแก แกแแจแฃแแแ แแแ, แ แแแแแจแแช แแแแก แจแแฃแซแแแ แจแแฅแแแแก แแแแแแแขแฃแ แ แแแกแขแ แแฅแชแแแแ, แ แแแแแแแช แแแแแแแ แแแกแแแแแ แแ แแแแแกแแงแแแแแแแแ.
แแ แแ แแก แซแแแแแ แแฅแกแแ แแกแแฃแแ
แกแแแแ แขแแแแกแแแแ แแ แแแฃแแแแแก แแแแ, Go-แก แแแแแ แแแแกแขแ แฃแฅแขแแแ, แ แแแแแแแช แกแฎแแ แแแแแจแ แแฃแแแแ แแแแ แแฆแแฅแแแแ. แแก แจแแแซแแแแ แแแแแแแ แแแ แ แแแแแ แฉแแแแแก, แแแแ แแ แแ แแฅแขแแแแจแ แแก แแฌแแแแก แกแแขแงแแแแ แแแแก. แแแแก แแแแแแ แแจแแแ แ แฃแแแ แแงแแก - แแแแแแแแแ แแแก แฃแแแ แแแฃแแแแแแแแก แกแฎแแแกแ แแแแแก แฌแแแแแฎแแ, แแแแ แแ แกแแแแแแแแแแจแ แแก แแแแแ แขแแแแแแแ แแฎแแแแ แฌแแแแแฎแแแก แแแแแแแแก. Go-แจแ แแ แแ แแก แจแแแแแแแแแแ: แแ แแแแ แ แแ แแ แแคแแ แ.
แแแแแแแแแ, แแแแกแแแแก แแ แแแ แแแ, แ แแแแแแช แแแแฎแฃแแแแก stdin แแ แคแแแแก แแ แซแแแแแแก แฎแแแแก แแ แแฃแแแแขแแแแแแ, แแกแ แแแแแแงแฃแ แแแ:
package main
import (
"bufio"
"flag"
"fmt"
"log"
"os"
)
func main() {
flag.Parse()
flags := flag.Args()
var text string
var scanner *bufio.Scanner
var err error
if len(flags) > 0 {
file, err := os.Open(flags[0])
if err != nil {
log.Fatal(err)
}
scanner = bufio.NewScanner(file)
} else {
scanner = bufio.NewScanner(os.Stdin)
}
for scanner.Scan() {
text += scanner.Text()
}
err = scanner.Err()
if err != nil {
log.Fatal(err)
}
fmt.Println(text)
}
แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแก แแแแแช แชแแแแแแก แแงแแก แ แแช แจแแแซแแแแ แแแแแแ, Go-แก แแซแฃแแแแแแ แกแแขแงแแแแ แแแ แฎแแแก แฃแจแแแก แแ แจแแแแแแ, แแแ แขแแแ แแ แแแแแแแก แแแแแญแ แ แแฌแแแแก แแแแแก แแแ แ แแแแแแแแแก.
แแ, แแแแแแแแแ, แแแแแ แแ แแแแแแแก แแแแแฌแงแแแขแ
import std.stdio, std.array, std.conv;
void main(string[] args)
{
try
{
auto source = args.length > 1 ? File(args[1], "r") : stdin;
auto text = source.byLine.join.to!(string);
writeln(text);
}
catch (Exception ex)
{
writeln(ex.msg);
}
}
แแ แแแ แฃแคแ แ แแแแแฎแแแ แแฎแแ? แแ แฉแแแก แฎแแแก แแแแชแแ แ-แก. แแแกแ แแแแ แแแแ แแ แฃแคแ แ แแแแแฎแแแ, แ แแแแแ แแก แฃแคแ แ แแแแแแ แแฆแฌแแ แก แแแฅแแแแแแแแก. D แแงแแแแแก แแแแ แแ แฃแคแ แ แ แแฃแ แชแแแแแแก (แแแแฎแ.:
แแแแแ แแแแก แฏแแฏแแฎแแแ
แแแแฃแแแ แฃแแ แฌแแแแแแแแแ Go-แก แแแกแแฃแแฏแแแแกแแแแแ แแ แแก แแแแแแ. แแก แแแแแแฃแ แแแแแแแ แแแชแแแแแก แแแแแก แแ แแกแแญแแ แ แแแแแ แแแแก แงแแแแ แขแแแแก แแแแแชแแแแ แแฎแแ แแแกแแญแแ แแ. แแแแแแแแแ, แแแแแ แ แแชแฎแแแแแก แกแแแก แจแแฏแแแแแแก แคแฃแแฅแชแแ แแ แจแแแซแแแแ แแแแฎแแ แชแแแแแแก แกแฎแแ แแแแ, แแฃ แแ แ แแแกแ แซแแ แแแแแ แคแฃแแฅแชแแแก แแแแแ แแแ แแแแแแฃแแ แแแแแ แขแแแแกแแแแก; แกแฎแแ แแแ แแ แแ แกแแแแแก:
package main
import "fmt"
func int64Sum(list []int64) (uint64) {
var result int64 = 0
for x := 0; x < len(list); x++ {
result += list[x]
}
return uint64(result)
}
func int32Sum(list []int32) (uint64) {
var result int32 = 0
for x := 0; x < len(list); x++ {
result += list[x]
}
return uint64(result)
}
func int16Sum(list []int16) (uint64) {
var result int16 = 0
for x := 0; x < len(list); x++ {
result += list[x]
}
return uint64(result)
}
func int8Sum(list []int8) (uint64) {
var result int8 = 0
for x := 0; x < len(list); x++ {
result += list[x]
}
return uint64(result)
}
func main() {
list8 := []int8 {1, 2, 3, 4, 5}
list16 := []int16{1, 2, 3, 4, 5}
list32 := []int32{1, 2, 3, 4, 5}
list64 := []int64{1, 2, 3, 4, 5}
fmt.Println(int8Sum(list8))
fmt.Println(int16Sum(list16))
fmt.Println(int32Sum(list32))
fmt.Println(int64Sum(list64))
}
แแ แแก แแแแแแแแ แฎแแแแแฌแแ แแแ แขแแแแแแกแแแแกแแช แแ แแ แแฃแจแแแแก. แแก แแแแแแแ แกแ แฃแแแแ แแ แฆแแแแก แกแแแฃแแแ แ แแแแแก แแ แแแแแแแ แแแแก แแ แแแชแแแก (
แแแแแ แแแแแแแแ D-แแ:
import std.stdio;
import std.algorithm;
void main(string[] args)
{
[1, 2, 3, 4, 5].reduce!((a, b) => a + b).writeln;
}
แแแ แขแแแ, แแแแแแแขแฃแ แ แแ แแแ แแแแแ แ. แแฅ แแแแแงแแแแแฃแแ แคแฃแแฅแชแแ แแ แแก reduce
แจแแแแแแแก แขแแแแกแ แแ แแ แแแแแแขแแกแแแแก. แแแแฎ, แแก แแแแแ แฃแคแ แ แ แแฃแแแ, แแแแ แ Go แแแ แกแแ, แแแแ แแ แแ แช แแกแ แ แแฃแแ แแแกแแแแแ แแ แแแ แแแแกแขแแแแกแแแแก. แ แแแแแ แแแแแแแแแ แฃแคแ แ แแแแแแ แจแแกแแแแฎแ แแ แแแแแแแ แฌแแกแแแแแฎแ?
แแแ แขแแแ แขแแแแก แกแแกแขแแแแก แจแแแแแแแแ
แแ แฌแแ แแแแแแแแแแ, แ แแ Go-แก แแ แแแ แแแแกแขแแแ, แ แแแแแแแช แแแแก แแแแฎแฃแแแแแ, แแแ แจแ แฅแแคแก แแฌแแแแแ แแ แแงแแแ แแแแ: โแแ แแกแฌแแ แแ แแแแแแ!โ แแกแ, แแ แกแแแแแก แกแฎแแ แแแ, แ แแ แแแแแแแแ แแแแแแ แคแฃแแฅแชแแ แแ แขแแแแแ, แแแแ แแ แแก แแแแแแแแ แแ แฆแแแแก แขแแแแก แกแแกแขแแแแก!
แจแแฎแแแแ แแ แกแฃแแแแฃแ แ แแแแก แแแแแกแฌแแ แแแแก แแแแแแแแก แแ แแแแแแแก แแแแแกแแญแ แแแแ:
package main
import "fmt"
import "reflect"
func Reduce(in interface{}, memo interface{}, fn func(interface{}, interface{}) interface{}) interface{} {
val := reflect.ValueOf(in)
for i := 0; i < val.Len(); i++ {
memo = fn(val.Index(i).Interface(), memo)
}
return memo
}
func main() {
list := []int{1, 2, 3, 4, 5}
result := Reduce(list, 0, func(val interface{}, memo interface{}) interface{} {
return memo.(int) + val.(int)
})
fmt.Println(result)
}
แแก แแแแฎแแ แชแแแแแแ Reduce
แแแกแแกแฎแแแ แแงแ แกแขแแขแแแแแ interface{}
- แคแแ แกแ แแ แแแแจแ แแฎแแแแ แแแ แแคแแก แแแแ แแแก แแแแแแแ แกแแญแแ แ. แแก แแ แแก แชแแ แแแแ แแแขแแ แคแแแกแ แแ แงแแแแ แขแแแ แแฎแแ แชแแแแแแก แแแก, แ แแช แกแ แฃแ แแแแแกแฃแคแแแแแก แแซแแแแก แงแแแแแก. แแ แแแ แแแแ แแแแก แแก แกแขแแแ แกแแจแแแแแ แแแฎแแแฏแแ แแ แแก แงแแแแแคแแ แ แแ แแ แแก. แแกแแแแกแ แแแ แแแแขแฃแแ แกแแแฅแขแแแแแแ แแแแแฎแแแก แแแจแแแแแก แแ แแแก แแกแแฎแแแก แแแแแงแแแแแแก. แ แแ แแแแแกแแช แแ แแ แแแกแฌแแแก แแแแแแแแแแ, แ แแแแแแแช แแแแก แแแ แแขแแ แแงแแแแแแ, แ แแแแ แช แแแ แแแแแก แแ แ-แแ แ แ แแแแ แขแแแจแ แแฆแแแจแแ.
แแก แแ แแก แซแแแแ แ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แฃแแแ แแฅแแแก แแแแแงแแแแแฃแแ แกแแคแ แแฎแแแแ. แแก แแแแแแแ แฃแแแ แแฅแแแก แแชแแแแแฃแแ, แแแ แแ แแ แจแแแแฎแแแแแกแ, แ แแแแกแแช แแแแชแ แแ แแก แแฃแชแแแแแแแแ.
แแ แกแแกแฃแแแแแแแแก แแแชแแแแ แแแแฆแแแแ D แจแแแแแแแแก. แ แแแแ แจแแแซแแแแ แแแแแแ แแแแก แแฅแแ interface{}
แฃแคแ แ แแแแแฎแแแ แแฃ แแแ แแคแแ แฃแกแแคแ แแฎแ?
แแแแแแแแแแฃแแแแแก แแแ แแแแก แแ แแแแแแแแ
Go-แก แแฅแแก แฉแแจแแแแแฃแแ แแแแแแแแแแฃแแแแแก แกแแกแขแแแ, แ แแแแแแช แแแแแฃแแแ แแแแฃแแแ แฃแแ แฐแแกแขแแแแแก แแ แแแแแแแ แแแแ
แแ แแ แแแแแแแก แแแแแญแ แแก แจแแกแแฎแแ แแแแฎแแแแแก แแแกแแแก แจแแแแแ, Go-แก แแแแแแแแ แแแแก แฏแแฃแคแ แจแแแฅแแแ
แแฃแแขแฃแ แฃแแ แแแ แแ Xi-แแแ
แฉแแแ แแแ แแ, Go แจแแแฅแแแ แแ แแแแแแแแแแแก แแแแ , แ แแแแแแแช แแงแแแแแแแแ C-แก แแแแแ แชแฎแแแ แแแ แแ แแแ, แแแกแแช แแ แกแฃแ แแ แ แแแแ แแฎแแแก แแแกแแแฏแแ. แแแ แจแแแซแแแแ แแฆแฌแแ แแแ แแงแแก แ แแแแ แช C แแแแแขแแแแแ แแแ แแแแแแ (แฌแแ แแแจแแแแก.:
แแแแแ แแ แแ แกแแจแแแแแ แแ แแแแแแ แแก แแ แแก, แ แแ Go แแ แแก แแ แแชแแแฃแ แฃแแ แแแ (แ แแแแ แช C-แแก แฉแฃแแ แกแแจแแแแแแแ). แแฅแแแ แกแแแแแแแ แฌแแ แ แแแแก แแ แแชแแแฃแ แฃแแ แกแขแแแแ, แ แแแแแแช แแแ แซแแแแ แแ แฅแแฃแแแ แแ แแแซแแแแแแฃแแแ. แแ แแแชแ, แ แแ แแแแแฅแขแแ แแ แแแแขแแ แแแฃแแ แแ แแแ แแแแ แแแ แแ แแ แแก แแแ แชแฎแแแก แขแงแแแ, แแแแ แแ แแแ แแ แแฅแแแแแแ แแแขแแแแแแก แขแแแแแแ แแแกแขแ แแฅแชแแ แแ แแแแแคแกแฃแแแชแแแก แฃแแ แฃแแแแแงแแคแ.
แกแแแแ แขแแแ แกแแแฃแแแ แ แกแแ แแแแแแกแแแแก
Go แจแแฅแแแแแแ แแแแกแแแแแก, แ แแ แแงแแก แแแ แขแแแ แแ แแก แแ แแแแแแก แแฆแฌแแแก. แแก แแแแฌแแ แ แกแฃแกแขแ แแ แแแ แแแแกแขแแแแกแแแแก, แจแแแแแแแ แซแแแแ แแแแก แแแแแงแแแแแแ. แแแก แแแแฉแแแ แแแ แขแแแ แแแกแขแ แฃแแแแขแแแ แแแ แขแแแ แกแแฅแแแแแแก แแแกแแแแแแแแแ. แแแแแแ แฌแแกแแแแแฎแ แแ แแแ แขแแแ แแแแแกแแงแแแแแแแแ.
แแก แซแแแแแ แแ แชแแแ, แจแแแแแแญแแแแ แแ แชแฃแแแ แญแแแแแแ แแ แแแ แแแแกแขแแแแกแแแแก.
แแแแแแแ
แฌแงแแ แ: www.habr.com