這個網(wǎng)站 可以列出某門編程語言的常用語法，也可以對比兩種語言的基本語法差別。

在此對比Go和Rust

1. Print Hello World

打印Hello World

package?main

import?"fmt"


func?main()?{
?fmt.Println("Hello?World")
}

fn?main()?{
????println!("Hello?World");
}

Rust 輸出文字的方式主要有兩種：println!() 和 **print!()**。這兩個"函數(shù)"都是向命令行輸出字符串的方法，區(qū)別僅在于前者會在輸出的最后附加輸出一個換行符。當(dāng)用這兩個"函數(shù)"輸出信息的時候，第一個參數(shù)是格式字符串，后面是一串可變參數(shù)，對應(yīng)著格式字符串中的"占位符"，這一點與 C 語言/ Go語言 中的 printf 函數(shù)很相似。但是，Rust 中格式字符串中的占位符不是"% + 字母"的形式，而是一對 {}。

2. Print Hello 10 times

打印10次Hello World

package?main

import?(
?"fmt"
)

func?main()?{
?for?i?:=?0;?i?<?10;?i++?{
??fmt.Println("Hello")
?}
}

or

package?main

import?(
?"fmt"
?"strings"
)

func?main()?{

?fmt.Print(strings.Repeat("Hello\n",?10))

}

fn?main()?{
????for?_?in?0..10?{
????????println!("Hello");
????}
}

or

fn?main()?{
????print!("{}",?"Hello\n".repeat(10));
}

3. Create a procedure

Like a function which doesn't return any value, thus has only side effects (e.g. Print to standard output)

創(chuàng)建一個方法，沒有返回值，打印一些內(nèi)容

package?main

import?"fmt"

func?finish(name?string)?{
?fmt.Println("My?job?here?is?done.?Good?bye?"?+?name)
}

func?main()?{
?finish("Tony")
}

fn?main(){
????finish("Buddy")
}

fn?finish(name?:?&str)?{
????println!("My?job?here?is?done.?Goodbye?{}",?name);
}

4. Create a function which returns the square of an integer

創(chuàng)建一個函數(shù),返回一個整數(shù)的平方

func?square(x?int)?int?{
??return?x*x
}

fn?square(x:?u32)?->?u32?{
????x?*?x
}

fn?main()?{
????let?sq?=?square(9);

????println!("{}",?sq);
}

5. Create a 2D Point data structure

Declare a container type for two floating-point numbers x and y

聲明一個容器類型,有x、y兩個浮點數(shù)

package?main

import?"fmt"

type?Point?struct?{
?x,?y?float64
}

func?main()?{
?p1?:=?Point{}
?p2?:=?Point{2.1,?2.2}
?p3?:=?Point{
??y:?3.1,
??x:?3.2,
?}
?p4?:=?&Point{
??x:?4.1,
??y:?4.2,
?}

?fmt.Println(p1)
?fmt.Println(p2)
?fmt.Println(p3)
?fmt.Println(p4)
}

輸出

{0?0}
{2.1?2.2}
{3.2?3.1}
&{4.1?4.2}

use?std::fmt;

struct?Point?{
????x:?f64,
????y:?f64,
}

impl?fmt::Display?for?Point?{
????fn?fmt(&self,?f:?&mut?fmt::Formatter<'_>)?->?fmt::Result?{
????????write!(f,?"({},?{})",?self.x,?self.y)
????}
}

fn?main()?{
????let?p?=?Point?{?x:?2.0,?y:?-3.5?};

????println!("{}",?p);
}

or

use?std::fmt;

struct?Point(f64,?f64);

impl?fmt::Display?for?Point?{
????fn?fmt(&self,?f:?&mut?fmt::Formatter<'_>)?->?fmt::Result?{
????????write!(f,?"({},?{})",?self.0,?self.1)
????}
}

fn?main()?{
????let?p?=?Point(2.0,?-3.5);

????println!("{}",?p);
}

6. Iterate over list values

Do something with each item x of an array-like collection items, regardless indexes.

遍歷列表的值

for?_,?x?:=?range?items?{
????doSomething(x)
}

package?main

import?(
?"fmt"
)

func?main()?{
?items?:=?[]int{11,?22,?33}

?for?_,?x?:=?range?items?{
??doSomething(x)
?}
}

func?doSomething(i?int)?{
?fmt.Println(i)
}

輸出

11
22
33

fn?main()?{
????let?items?=?vec![11,?22,?33];

????for?x?in?items?{
????????do_something(x);
????}
}

fn?do_something(n:?i64)?{
????println!("Number?{}",?n)
}

or

fn?main()?{
????let?items?=?vec![11,?22,?33];

????items.into_iter().for_each(|x|?do_something(x));
}

fn?do_something(n:?i64)?{
????println!("Number?{}",?n)
}

7. Iterate over list indexes and values

遍歷列表的索引和值

package?main

import?"fmt"

func?main()?{
?items?:=?[]string{
??"oranges",
??"apples",
??"bananas",
?}

?for?i,?x?:=?range?items?{
??fmt.Printf("Item?%d?=?%v?\n",?i,?x)
?}
}

輸出

Item?0?=?oranges?
Item?1?=?apples?
Item?2?=?bananas?

fn?main()?{
????let?items?=?["a",?"b",?"c"];
????for?(i,?x)?in?items.iter().enumerate()?{
????????println!("Item?{}?=?{}",?i,?x);
????}
}

or

fn?main()?{
????let?items?=?["a",?"b",?"c"];
????items.iter().enumerate().for_each(|(i,?x)|?{
????????println!("Item?{}?=?{}",?i,?x);
????});
}

8. Initialize a new map (associative array)

Create a new map object x, and provide some (key, value) pairs as initial content.

創(chuàng)建一個新的map,提供一些鍵值對 作為初始內(nèi)容

package?main

import?"fmt"

func?main()?{
?x?:=?map[string]int{"one":?1,?"two":?2}

?fmt.Println(x)
}

輸出

map[one:1?two:2]

use?std::collections::BTreeMap;

fn?main()?{
????let?mut?x?=?BTreeMap::new();
????x.insert("one",?1);
????x.insert("two",?2);
????
????println!("{:?}",?x);
}

輸出為：

("one",?1)
("two",?2)

or

use?std::collections::HashMap;

fn?main()?{
????let?x:?HashMap<&str,?i32>?=?[
????????("one",?1),
????????("two",?2),
????].iter().cloned().collect();
????
????println!("{:?}",?x);
}

輸出為：

("two",?2)
("one",?1)

分 BTreeMap 和 HashMap，且都需要use進(jìn)來； 前者無序，后者有序

9. Create a Binary Tree data structure

The structure must be recursive because left child and right child are binary trees too. A node has access to children nodes, but not to its parent.

創(chuàng)建一個二叉樹

type?BinTree?struct?{
?Value?valueType
?Left?*BinTree
?Right?*BinTree
}

package?main

import?"fmt"

type?BinTree?struct?{
?Value?int
?Left??*BinTree
?Right?*BinTree
}

func?inorder(root?*BinTree)?{
?if?root?==?nil?{
??return
?}

?inorder(root.Left)
?fmt.Printf("%d?",?root.Value)
?inorder(root.Right)
}

func?main()?{
?root?:=?&BinTree{1,?nil,?nil}
?root.Left?=?&BinTree{2,?nil,?nil}
?root.Right?=?&BinTree{3,?nil,?nil}
?root.Left.Left?=?&BinTree{4,?nil,?nil}
?root.Left.Right?=?&BinTree{5,?nil,?nil}
?root.Right.Right?=?&BinTree{6,?nil,?nil}
?root.Left.Left.Left?=?&BinTree{7,?nil,?nil}

?inorder(root)
}

輸出

7?4?2?5?1?3?6?

struct?BinTree<T>?{
????value:?T,
????left:?Option<Box<BinTree<T>>>,
????right:?Option<Box<BinTree<T>>>,
}

10. Shuffle a list

Generate a random permutation of the elements of list x

隨機(jī)排序一個list

package?main

import?(
?"fmt"
?"math/rand"
)

func?main()?{
?x?:=?[]string{"a",?"b",?"c",?"d",?"e",?"f",?"g",?"h"}

?for?i?:=?range?x?{
??j?:=?rand.Intn(i?+?1)
??x[i],?x[j]?=?x[j],?x[i]
?}

?fmt.Println(x)
}

輸出

[f e c g h a d b]

or

package?main

import?(
?"fmt"
?"math/rand"
)

func?main()?{
?x?:=?[]string{"a",?"b",?"c",?"d",?"e",?"f",?"g",?"h"}

?y?:=?make([]string,?len(x))
?perm?:=?rand.Perm(len(x))
?for?i,?v?:=?range?perm?{
??y[v]?=?x[i]
?}

?fmt.Println(y)
}

輸出

[f h c g b a d e]

or

package?main

import?(
?"fmt"
?"math/rand"
)

func?main()?{
?x?:=?[]string{"a",?"b",?"c",?"d",?"e",?"f",?"g",?"h"}

?rand.Shuffle(len(x),?func(i,?j?int)?{
??x[i],?x[j]?=?x[j],?x[i]
?})

?fmt.Println(x)
}

輸出

[f a h b c d g e]

or

package?main

import?(
?"fmt"
?"math/rand"
)

func?main()?{
?x?:=?[]string{"a",?"b",?"c",?"d",?"e",?"f",?"g",?"h"}

?for?i?:=?len(x)?-?1;?i?>?0;?i--?{
??j?:=?rand.Intn(i?+?1)
??x[i],?x[j]?=?x[j],?x[i]
?}

?fmt.Println(x)
}

輸出

[g d a h e f c b]

extern?crate?rand;
use?rand::{Rng,?StdRng};

let?mut?rng?=?StdRng::new().unwrap();
rng.shuffle(&mut?x);

or

use?rand::seq::SliceRandom;
use?rand::thread_rng;

fn?main()?{
????let?mut?x?=?[1,?2,?3,?4,?5];
????println!("Unshuffled:?{:?}",?x);

????let?mut?rng?=?thread_rng();
????x.shuffle(&mut?rng);

????println!("Shuffled:???{:?}",?x);
}

11. Pick a random element from a list

從列表中選擇一個隨機(jī)元素

package?main

import?(
?"fmt"
?"math/rand"
)

var?x?=?[]string{"bleen",?"fuligin",?"garrow",?"grue",?"hooloovoo"}

func?main()?{
?fmt.Println(x[rand.Intn(len(x))])
}

輸出

fuligin

or

package?main

import?(
?"fmt"
?"math/rand"
)

type?T?string

func?pickT(x?[]T)?T?{
?return?x[rand.Intn(len(x))]
}

func?main()?{
?var?list?=?[]T{"bleen",?"fuligin",?"garrow",?"grue",?"hooloovoo"}
?fmt.Println(pickT(list))
}

輸出

fuligin

use?rand::{self,?Rng};

fn?main()?{
????let?x?=?vec![11,?22,?33];

????let?choice?=?x[rand::thread_rng().gen_range(0..x.len())];

????println!("I?picked?{}!",?choice);
}

or

use?rand::seq::SliceRandom;
?
fn?main()?{
????let?x?=?vec![11,?22,?33];

????let?mut?rng?=?rand::thread_rng();
????let?choice?=?x.choose(&mut?rng).unwrap();
????
????println!("I?picked?{}!",?choice);
}

12. Check if list contains a value

Check if list contains a value x. list is an iterable finite container.

檢查列表中是否包含一個值

package?main

import?"fmt"

func?Contains(list?[]T,?x?T)?bool?{
?for?_,?item?:=?range?list?{
??if?item?==?x?{
???return?true
??}
?}
?return?false
}

type?T?string

func?main()?{
?list?:=?[]T{"a",?"b",?"c"}
?fmt.Println(Contains(list,?"b"))
?fmt.Println(Contains(list,?"z"))
}

輸出

true
false

fn?main()?{
????let?list?=?[10,?40,?30];

????{
????????let?num?=?30;

????????if?list.contains(&num)?{
????????????println!("{:?}?contains?{}",?list,?num);
????????}?else?{
????????????println!("{:?}?doesn't?contain?{}",?list,?num);
????????}
????}

????{
????????let?num?=?42;

????????if?list.contains(&num)?{
????????????println!("{:?}?contains?{}",?list,?num);
????????}?else?{
????????????println!("{:?}?doesn't?contain?{}",?list,?num);
????????}
????}
}

or

fn?main()?{
????let?list?=?[10,?40,?30];
????let?x?=?30;

????if?list.iter().any(|v|?v?==?&x)?{
????????println!("{:?}?contains?{}",?list,?x);
????}?else?{
????????println!("{:?}?doesn't?contain?{}",?list,?x);
????}
}

or

fn?main()?{
????let?list?=?[10,?40,?30];
????let?x?=?30;

????if?(&list).into_iter().any(|v|?v?==?&x)?{
????????println!("{:?}?contains?{}",?list,?x);
????}?else?{
????????println!("{:?}?doesn't?contain?{}",?list,?x);
????}
}

13. Iterate over map keys and values

Access each key k with its value x from an associative array mymap, and print them

遍歷關(guān)聯(lián)數(shù)組中的每一對 k-v， 并打印出它們

package?main

import?"fmt"

func?main()?{
?mymap?:=?map[string]int{
??"one":???1,
??"two":???2,
??"three":?3,
??"four":??4,
?}

?for?k,?x?:=?range?mymap?{
??fmt.Println("Key?=",?k,?",?Value?=",?x)
?}
}

輸出

Key?=?two?,?Value?=?2
Key?=?three?,?Value?=?3
Key?=?four?,?Value?=?4
Key?=?one?,?Value?=?1

use?std::collections::BTreeMap;

fn?main()?{
????let?mut?mymap?=?BTreeMap::new();
????mymap.insert("one",?1);
????mymap.insert("two",?2);
????mymap.insert("three",?3);
????mymap.insert("four",?4);

????for?(k,?x)?in?&mymap?{
????????println!("Key={key},?Value={val}",?key?=?k,?val?=?x);
????}
}

14. Pick uniformly a random floating point number in [a..b)

Pick a random number greater than or equals to a, strictly inferior to b. Precondition : a < b.

選出一個隨機(jī)的浮點數(shù)，大于或等于a，嚴(yán)格小于b，且a< b

package?main

import?(
?"fmt"
?"math/rand"
)

func?main()?{
?x?:=?pick(-2.0,?6.5)
?fmt.Println(x)
}

func?pick(a,?b?float64)?float64?{
?return?a?+?(rand.Float64()?*?(b?-?a))
}

輸出

3.1396124478267664

extern?crate?rand;
use?rand::{thread_rng,?Rng};

fn?main()?{
????let?(a,?b)?=?(1.0,?3.0);
????let?c?=?thread_rng().gen_range(a..b);
????println!("{}",?c);
}

15. Pick uniformly a random integer in [a..b]

Pick a random integer greater than or equals to a, inferior or equals to b. Precondition : a < b.

選出一個隨機(jī)的整數(shù)，大于或等于a，小于或等于b，且a< b

package?main

import?(
?"fmt"
?"math/rand"
)

func?main()?{
?x?:=?pick(3,?7)

?//?Note?that?in?the?Go?Playground,?time?and?random?don't?change?very?often.
?fmt.Println(x)
}

func?pick(a,?b?int)?int?{
?return?a?+?rand.Intn(b-a+1)
}

輸出

4

fn?pick(a:?i32,?b:?i32)?->?i32?{
????let?between?=?Range::new(a,?b);
????let?mut?rng?=?rand::thread_rng();
????between.ind_sample(&mut?rng)
}

or

use?rand::distributions::Distribution;
use?rand::distributions::Uniform;

fn?main()?{
????let?(a,?b)?=?(3,?5);

????let?x?=?Uniform::new_inclusive(a,?b).sample(&mut?rand::thread_rng());

????println!("{}",?x);
}

17. Create a Tree data structure

The structure must be recursive. A node may have zero or more children. A node has access to children nodes, but not to its parent.

創(chuàng)建樹數(shù)據(jù)結(jié)構(gòu), 該結(jié)構(gòu)必須是遞歸的。一個節(jié)點可以有零個或多個子節(jié)點,節(jié)點可以訪問子節(jié)點，但不能訪問其父節(jié)點

type?Tree?struct?{
?Key?keyType
?Deco?valueType
?Children?[]*Tree
}

package?main

import?"fmt"

type?Tree?struct?{
?Key??????key
?Deco?????value
?Children?[]*Tree
}

type?key?string
type?value?string

func?(t?*Tree)?String()?string?{
?str?:=?"("
?str?+=?string(t.Deco)
?if?len(t.Children)?==?0?{
??return?str?+?")"
?}
?str?+=?"?("
?for?_,?child?:=?range?t.Children?{
??str?+=?child.String()
?}
?str?+=?"))"
?return?str
}

func?(this?*Tree)?AddChild(x?key,?v?value)?*Tree?{
?child?:=?&Tree{Key:?x,?Deco:?v}
?this.Children?=?append(this.Children,?child)
?return?child
}

func?main()?{
?tree?:=?&Tree{Key:?"Granpa",?Deco:?"Abraham"}
?subtree?:=?tree.AddChild("Dad",?"Homer")
?subtree.AddChild("Kid?1",?"Bart")
?subtree.AddChild("Kid?2",?"Lisa")
?subtree.AddChild("Kid?3",?"Maggie")

?fmt.Println(tree)
}

輸出

(Abraham ((Homer ((Bart)(Lisa)(Maggie)))))

use?std::vec;

struct?Node<T>?{
????value:?T,
????children:?Vec<Node<T>>,
}

impl<T>?Node<T>?{
????pub?fn?dfs<F:?Fn(&T)>(&self,?f:?F)?{
???????self.dfs_helper(&f);
????}

????fn?dfs_helper<F:?Fn(&T)>(&self,?f:?&F)?{
????????(f)(&self.value);
????????for?child?in?&self.children?{
????????????child.dfs_helper(f);
????????}
????}
}


fn?main()?{
????let?t:?Node<i32>?=?Node?{
????????children:?vec![
????????????Node?{
????????????????children:?vec![
????????????????????Node?{
????????????????????????children:?vec![],
????????????????????????value:?14
????????????????????}
????????????????],
????????????????value:?28
????????????},
????????????Node?{
????????????????children:?vec![],
????????????????value:?80
????????????}
????????],
????????value:?50
????};

????t.dfs(|node|?{?println!("{}",?node);?});
}

輸出：

50
28
14
80

18. Depth-first traversing of a tree

Call a function f on every node of a tree, in depth-first prefix order

樹的深度優(yōu)先遍歷。按照深度優(yōu)先的前綴順序，在樹的每個節(jié)點上調(diào)用函數(shù)f

package?main

import?.?"fmt"

func?(t?*Tree)?Dfs(f?func(*Tree))?{
?if?t?==?nil?{
??return
?}
?f(t)
?for?_,?child?:=?range?t.Children?{
??child.Dfs(f)
?}
}

type?key?string
type?value?string

type?Tree?struct?{
?Key??????key
?Deco?????value
?Children?[]*Tree
}

func?(this?*Tree)?AddChild(x?key,?v?value)?{
?child?:=?&Tree{Key:?x,?Deco:?v}
?this.Children?=?append(this.Children,?child)
}

func?NodePrint(node?*Tree)?{
?Printf("%v?(%v)\n",?node.Deco,?node.Key)
}

func?main()?{
?tree?:=?&Tree{Key:?"Granpa",?Deco:?"Abraham"}
?tree.AddChild("Dad",?"Homer")
?tree.Children[0].AddChild("Kid?1",?"Bart")
?tree.Children[0].AddChild("Kid?2",?"Lisa")
?tree.Children[0].AddChild("Kid?3",?"Maggie")

?tree.Dfs(NodePrint)
}

輸出

Abraham?(Granpa)
Homer?(Dad)
Bart?(Kid?1)
Lisa?(Kid?2)
Maggie?(Kid?3)

use?std::vec;

struct?Tree<T>?{
????children:?Vec<Tree<T>>,
????value:?T
}

impl<T>?Tree<T>?{
????pub?fn?new(value:?T)?->?Self{
????????Tree{
????????????children:?vec![],
????????????value
????????}
????}

????pub?fn?dfs<F:?Fn(&T)>(&self,?f:?F)?{
???????self.dfs_helper(&f);
????}

????fn?dfs_helper<F:?Fn(&T)>(&self,?f:?&F)?{
????????(f)(&self.value);
????????for?child?in?&self.children?{
????????????child.dfs_helper(f);
????????}
????}
}


fn?main()?{
????let?t:?Tree<i32>?=?Tree?{
????????children:?vec![
????????????Tree?{
????????????????children:?vec![
????????????????????Tree?{
????????????????????????children:?vec![],
????????????????????????value:?14
????????????????????}
????????????????],
????????????????value:?28
????????????},
????????????Tree?{
????????????????children:?vec![],
????????????????value:?80
????????????}
????????],
????????value:?50
????};

????t.dfs(|node|?{?println!("{}",?node);?});
}

輸出：

50
28
14
80

19. Reverse a list

Reverse the order of the elements of list x. This may reverse "in-place" and destroy the original ordering.

反轉(zhuǎn)鏈表

package?main

import?"fmt"

func?main()?{

?s?:=?[]int{5,?2,?6,?3,?1,?4}

?for?i,?j?:=?0,?len(s)-1;?i?<?j;?i,?j?=?i+1,?j-1?{
??s[i],?s[j]?=?s[j],?s[i]
?}

?fmt.Println(s)
}

輸出

[4 1 3 6 2 5]

fn?main()?{
????let?x?=?vec!["Hello",?"World"];
????let?y:?Vec<_>?=?x.iter().rev().collect();
????println!("{:?}",?y);
}

輸出：

["World",?"Hello"]

or

fn?main()?{
????let?mut?x?=?vec![1,2,3];
????x.reverse();
????println!("{:?}",?x);
}

輸出:

[3,?2,?1]

20. Return two values

Implement a function search which looks for item x in a 2D matrix m. Return indices i, j of the matching cell. Think of the most idiomatic way in the language to return the two values at the same time.

實現(xiàn)在2D矩陣m中尋找元素x，返回匹配單元格的索引 i，j

package?main

import?"fmt"

func?search(m?[][]int,?x?int)?(bool,?int,?int)?{
?for?i?:=?range?m?{
??for?j,?v?:=?range?m[i]?{
???if?v?==?x?{
????return?true,?i,?j
???}
??}
?}
?return?false,?0,?0
}

func?main()?{
?matrix?:=?[][]int{
??{1,?2,?3},
??{4,?5,?6},
??{7,?8,?9},
?}
?for?x?:=?1;?x?<=?11;?x?+=?2?{
??found,?i,?j?:=?search(matrix,?x)
??if?found?{
???fmt.Printf("matrix[%v][%v]?==?%v?\n",?i,?j,?x)
??}?else?{
???fmt.Printf("Value?%v?not?found.?\n",?x)
??}
?}
}

輸出

matrix[0][0]?==?1?
matrix[0][2]?==?3?
matrix[1][1]?==?5?
matrix[2][0]?==?7?
matrix[2][2]?==?9?
Value?11?not?found.?

fn?search<T:?Eq>(m:?&Vec<Vec<T>>,?x:?&T)?->?Option<(usize,?usize)>?{
????for?(i,?row)?in?m.iter().enumerate()?{
????????for?(j,?column)?in?row.iter().enumerate()?{
????????????if?*column?==?*x?{
????????????????return?Some((i,?j));
????????????}
????????}
????}
????
????None
}

fn?main()?{
????let?a?=?vec![
????????vec![0,?11],
????????vec![22,?33],
????????vec![44,?55],
????];
????
????let?hit?=?search(&a,?&33);
????
????println!("{:?}",?hit);
}

輸出：

Some((1,?1))