241. Yield priority to other threads
Explicitly decrease the priority of the current process, so that other execution threads have a better chance to execute now. Then resume normal execution and call function busywork.
将优先权让给其他线程
package main import ( "fmt" "runtime" "time" ) func main() { go fmt.Println("aaa") go fmt.Println("bbb") go fmt.Println("ccc") go fmt.Println("ddd") go fmt.Println("eee") runtime.Gosched() busywork() time.Sleep(100 * time.Millisecond) } func busywork() { fmt.Println("main") }
After Gosched, the execution of the current goroutine resumes automatically.
aaa eee ccc bbb ddd main
::std::thread::yield_now(); busywork();
242. Iterate over a set
Call a function f on each element e of a set x.
迭代一个集合
package main import "fmt" type T string func main() { // declare a Set (implemented as a map) x := make(map[T]bool) // add some elements x["A"] = true x["B"] = true x["B"] = true x["C"] = true x["D"] = true // remove an element delete(x, "C") for e := range x { f(e) } } func f(e T) { fmt.Printf("contains element %v \n", e) }
contains element A contains element B contains element D
use std::collections::HashSet; fn main() { let mut x = HashSet::new(); x.insert("a"); x.insert("b"); for item in &x { f(item); } } fn f(s: &&str) { println!("Element {}", s); }
x is a HashSet
Element a Element b
243. Print list
Print the contents of list a on the standard output.
打印 list
package main import ( "fmt" ) func main() { { a := []int{11, 22, 33} fmt.Println(a) } { a := []string{"aa", "bb"} fmt.Println(a) } { type Person struct { First string Last string } x := Person{ First: "Jane", Last: "Doe", } y := Person{ First: "John", Last: "Doe", } a := []Person{x, y} fmt.Println(a) } { x, y := 11, 22 a := []*int{&x, &y} fmt.Println(a) } }
[11 22 33] [aa bb] [{Jane Doe} {John Doe}] [0xc000018080 0xc000018088]
fn main() { let a = [11, 22, 33]; println!("{:?}", a); }
244. Print map
Print the contents of map m to the standard output: keys and values.
打印 map
package main import ( "fmt" ) func main() { { m := map[string]int{ "eleven": 11, "twenty-two": 22, } fmt.Println(m) } { x, y := 7, 8 m := map[string]*int{ "seven": &x, "eight": &y, } fmt.Println(m) } }
map[eleven:11 twenty-two:22] map[eight:0xc000100040 seven:0xc000100028]
use std::collections::HashMap; fn main() { let mut m = HashMap::new(); m.insert("Áron".to_string(), 23); m.insert("Béla".to_string(), 35); println!("{:?}", m); }
245. Print value of custom type
Print the value of object x having custom type T, for log or debug.
打印自定义类型的值
package main import ( "fmt" ) // T represents a tank. It doesn't implement fmt.Stringer. type T struct { name string weight int firePower int } // Person implement fmt.Stringer. type Person struct { FirstName string LastName string YearOfBirth int } func (p Person) String() string { return fmt.Sprintf("%s %s, born %d", p.FirstName, p.LastName, p.YearOfBirth) } func main() { { x := T{ name: "myTank", weight: 100, firePower: 90, } fmt.Println(x) } { x := Person{ FirstName: "John", LastName: "Doe", YearOfBirth: 1958, } fmt.Println(x) } }
Will be more relevant if T implements fmt.Stringer
{myTank 100 90} John Doe, born 1958
#[derive(Debug)] // T represents a tank struct T<'a> { name: &'a str, weight: &'a i32, fire_power: &'a i32, } fn main() { let x = T { name: "mytank", weight: &100, fire_power: &90, }; println!("{:?}", x); }
Implement fmt::Debug or fmt::Display for T
246. Count distinct elements
Set c to the number of distinct elements in list items.
计算不同的元素的数量
package main import ( "fmt" ) func main() { type T string items := []T{"a", "b", "b", "aaa", "c", "a", "d"} fmt.Println("items has", len(items), "elements") distinct := make(map[T]bool) for _, v := range items { distinct[v] = true } c := len(distinct) fmt.Println("items has", c, "distinct elements") }
items has 7 elements items has 5 distinct elements
use itertools::Itertools; fn main() { let items = vec!["víz", "árvíz", "víz", "víz", "ár", "árvíz"]; let c = items.iter().unique().count(); println!("{}", c); }
247. Filter list in-place
Remove all the elements from list x that don't satisfy the predicate p, without allocating a new list.
Keep all the elements that do satisfy p.
For languages that don't have mutable lists, refer to idiom #57 instead.
就地筛选列表
package main import "fmt" type T int func main() { x := []T{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} p := func(t T) bool { return t%2 == 0 } j := 0 for i, v := range x { if p(v) { x[j] = x[i] j++ } } x = x[:j] fmt.Println(x) }
or
package main import "fmt" type T int func main() { var x []*T for _, v := range []T{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} { t := new(T) *t = v x = append(x, t) } p := func(t *T) bool { return *t%2 == 0 } j := 0 for i, v := range x { if p(v) { x[j] = x[i] j++ } } for k := j; k < len(x); k++ { x[k] = nil } x = x[:j] for _, pt := range x { fmt.Print(*pt, " ") } }
fn p(t: i32) -> bool { t % 2 == 0 } fn main() { let mut x = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let mut j = 0; for i in 0..x.len() { if p(x[i]) { x[j] = x[i]; j += 1; } } x.truncate(j); println!("{:?}", x); }
or
fn p(t: &i64) -> bool { t % 2 == 0 } fn main() { let mut x: Vec<i64> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; x.retain(p); println!("{:?}", x); }
249. Declare and assign multiple variables
Define variables a, b and c in a concise way. Explain if they need to have the same type.
声明并分配多个变量
package main import ( "fmt" ) func main() { // a, b and c don't need to have the same type. a, b, c := 42, "hello", 5.0 fmt.Println(a, b, c) fmt.Printf("%T %T %T \n", a, b, c) }
42 hello 5 int string float64
fn main() { // a, b and c don't need to have the same type. let (a, b, c) = (42, "hello", 5.0); println!("{} {} {}", a, b, c); }
251. Parse binary digits
Extract integer value i from its binary string representation s (in radix 2) E.g. "1101" -> 13
解析二进制数字
package main import ( "fmt" "reflect" "strconv" ) func main() { s := "1101" fmt.Println("s is", reflect.TypeOf(s), s) i, err := strconv.ParseInt(s, 2, 0) if err != nil { panic(err) } fmt.Println("i is", reflect.TypeOf(i), i) }
s is string 1101 i is int64 13
fn main() { let s = "1101"; // binary digits let i = i32::from_str_radix(s, 2).expect("Not a binary number!"); println!("{}", i); }
252. Conditional assignment
Assign to variable x the value "a" if calling the function condition returns true, or the value "b" otherwise.
条件赋值
package main import ( "fmt" ) func main() { var x string if condition() { x = "a" } else { x = "b" } fmt.Println(x) } func condition() bool { return "Scorates" == "dog" }
x = if condition() { "a" } else { "b" };
258. Convert list of strings to list of integers
Convert the string values from list a into a list of integers b.
将字符串列表转换为整数列表
package main import ( "fmt" "strconv" ) func main() { a := []string{"11", "22", "33"} b := make([]int, len(a)) var err error for i, s := range a { b[i], err = strconv.Atoi(s) if err != nil { panic(err) } } fmt.Println(b) }
fn main() { let a: Vec<&str> = vec!["11", "-22", "33"]; let b: Vec<i64> = a.iter().map(|x| x.parse::<i64>().unwrap()).collect(); println!("{:?}", b); }
259. Split on several separators
Build list parts consisting of substrings of input string s, separated by any of the characters ',' (comma), '-' (dash), '_' (underscore).
在几个分隔符上拆分
package main import ( "fmt" "regexp" ) func main() { s := "2021-03-11,linux_amd64" re := regexp.MustCompile("[,\\-_]") parts := re.Split(s, -1) fmt.Printf("%q", parts) }
fn main() { let s = "2021-03-11,linux_amd64"; let parts: Vec<_> = s.split(&[',', '-', '_'][..]).collect(); println!("{:?}", parts); }
266. Repeating string
Assign to string s the value of string v, repeated n times and write it out.
E.g. v="abc", n=5 ⇒ s="abcabcabcabcabc"
重复字符串
package main import ( "fmt" "strings" ) func main() { v := "abc" n := 5 s := strings.Repeat(v, n) fmt.Println(s) }
fn main() { let v = "abc"; let n = 5; let s = v.repeat(n); println!("{}", s); }
