3. Rust vs Go

41. Reverse a string

Reverse string

package main

import "fmt"

func Reverse(s string) string {
	runes := []rune(s)
	for i, j := 0.len(runes)- 1; i < j; i, j = i+1, j- 1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func main(a) {
	input := "The quick Brown fox jumped over The lazy dog"
	fmt.Println(Reverse(input))
	// Original string unaltered
	fmt.Println(input)
}

Copy the code

The output

Dog Yzal Eht Revo Depmuj Fox Nworb Kciuq Eht The quick Brown fox jumped over The lazy dogCopy the code

---

let t = s.chars().rev().collect::<String> ();Copy the code

or

fn main() {
    let s = "Lorem ipsum dolor sit amor ❤";
    let t: String = s.chars().rev().collect();
    println!("{}", t);
}
Copy the code

The output

Roma tis rolod muspi merol

42. Continue outer loop

Print each item v of list a which in not contained in list b.

For this, write an outer loop to iterate on a and an inner loop to iterate on b.

Print each item V in list A that is not included in list B. To do this, write an external loop to iterate over A and an internal loop to iterate over B.

package main

import "fmt"

func printSubtraction(a []int, b []int) {
mainloop:
	for _, v := range a {
		for _, w := range b {
			if v == w {
				continue mainloop
			}
		}
		fmt.Println(v)
	}
}

func main(a) {
	a := []int{1.2.3.4}
	b := []int{2.4.6.8}
	printSubtraction(a, b)
}

Copy the code

mainloop is a label used to refer to the outer loop.

The output

1
3
Copy the code

---

fn main() {
    let a = ['a'.'b'.'c'.'d'.'e'];
    let b = [     'b'.'d'     ];
    
    'outer: for va in &a {
        for vb in &b {
            if va == vb {
                continue 'outer; }}println!("{}", va); }}Copy the code

‘outer is a label used to refer to the outer loop. Labels in Rust start with a ‘.

The output

a
c
e
Copy the code

43. Break outer loop

Look for a negative value v in 2D integer matrix m. Print it and stop searching.

Look for a negative value v in the 2D integer matrix M, print it out, and stop searching.

package main

import "fmt"
import "os"

var m = [][]int{{1.2.3},
	{11.0.30},
	{5.- 20.55},
	{0.0.- 60}},func main(a) {
mainloop:
	for i, line := range m {
		fmt.Fprintln(os.Stderr, "Searching in line", i)
		for _, v := range line {
			if v < 0 {
				fmt.Println("Found ", v)
				break mainloop
			}
		}
	}

	fmt.Println("Done.")}Copy the code

mainloop is a label used to refer to the outer loop.

The output

Searching in line 0
Searching in line 1
Searching in line 2
Found  - 20
Done.
Copy the code

---

fn main() {
    let m = vec![
        vec![1.2.3].vec![11.0.30].vec![5, -20.55].vec![0.0, -60]];'outer: for v in m {
        'inner: for i in v {
            if i < 0 {
                println!("Found {}", i);
                break 'outer; }}}}Copy the code

Loop label syntax is similar to lifetimes.

The output

Found -20

44. Insert element in list

Insert element x at position i in list s. Further elements must be shifted to the right.

Insert element x at position I of list S. Other elements must be moved to the right.

package main

import "fmt"

func main(a) {

	s := make([]int.2)
	
	s[0] = 0
	s[1] = 2
	
	fmt.Println(s)	
	// insert one at index one
	s = append(s, 0)
	copy(s[2:], s[1:])
	s[1] = 1
	
	fmt.Println(s)
}
Copy the code

The output

[0 2]
[0 1 2]
Copy the code

---

fn main() {
    let mut vec = vec![1.2.3];
    vec.insert(1.4);
    assert_eq!(vec, [1.4.2.3]);
    vec.insert(4.5);
    assert_eq!(vec, [1.4.2.3.5]);
    
}
Copy the code

45. Pause execution for 5 seconds

Sleep for 5 seconds in the current thread before proceeding to the next instruction.

package main

import (
	"fmt"
	"time"
)

func main(a) {
	time.Sleep(5 * time.Second)
	fmt.Println("Done.")}Copy the code

---

use std::{thread, time};
thread::sleep(time::Duration::from_secs(5));
Copy the code

46. Extract beginning of string (prefix)

Create string t consisting of the 5 first characters of string s.

Make sure that multibyte characters are properly handled.

Create a string t consisting of the first five characters of string S. Ensure proper handling of multi-byte characters.

package main

import "fmt"

func main(a) {
	s := "П р и kind guide е т"
	t := string([]rune(s)[:5])
	
	fmt.Println(t)
}

Copy the code

The output

П р и kind guide еCopy the code

---

fn main() {
    let s = "été 😁 torride";
    
    let t = s.char_indices().nth(5).map_or(s, |(i, _)| &s[..i]);

    println!("{}", t);
}
Copy the code

The output

Ete 😁

47. Extract string suffix

Create string t consisting in the 5 last characters of string s.

Make sure that multibyte characters are properly handled.

Create a string t consisting of the last five characters of string S. Ensure proper handling of multi-byte characters

package main

import "fmt"

func main(a) {
	s := "hello, world! 문 자. ""
	t := string([]rune(s)[len([]rune(s))- 5:])
	fmt.Println(t)
}

Copy the code

The output

d! 문 자

---

fn main() {
    let s = "tükörfúrógép";
    let last5ch = s.chars().count() - 5;
    let s2: String = s.chars().skip(last5ch).collect();
    println!("{}", s2);
}
Copy the code

The output

rógép

48. Multi-line string literal

Assign to variable s a string literal consisting in several lines of text, including newlines.

Assigns the variable s a string of several lines of text, including newlines.

package main

import (
	"fmt"
)

func main(a) {
	s := `Huey
Dewey
Louie`

	fmt.Println(s)
}

Copy the code

The output

Huey
Dewey
Louie
Copy the code

---

fn main() {
    let s = "line 1
line 2
line 3";
    
    print!("{}", &s);
}
Copy the code

The output

line 1
line 2
line 3
Copy the code

or

fn main() {
    let s = r#"Huey
Dewey
Louie"#;
    
    print!("{}", &s);
}
Copy the code

The output

Huey
Dewey
Louie
Copy the code

49. Split a space-separated string

Split strings separated by Spaces

Build list chunks consisting in substrings of input string s, separated by one or more space characters.

Builds a list block of substrings of the input string, separated by one or more space characters.

package main

import (
	"fmt"
	"strings"
)

func main(a) {
	s := "Un dos tres"
	chunks := strings.Split(s, "")
	fmt.Println(len(chunks))
	fmt.Println(chunks)

	s = " Un dos tres "
	chunks = strings.Split(s, "")
	fmt.Println(len(chunks))
	fmt.Println(chunks)

	s = "Un dos"
	chunks = strings.Split(s, "")
	fmt.Println(len(chunks))
	fmt.Println(chunks)
}

Copy the code

The output

3
[Un dos tres]
5
[ Un dos tres ]
3
[Un  dos]
Copy the code

or

package main

import (
	"fmt"
	"strings"
)

func main(a) {
	s := "hello world"
	chunks := strings.Fields(s)

	fmt.Println(chunks)
}

Copy the code

The output is

[hello world]
Copy the code

and

package main

import (
	"fmt"
	"strings"
)

func main(a) {
	s := "Un dos tres"
	chunks := strings.Fields(s)
	fmt.Println(len(chunks))
	fmt.Println(chunks)

	s = " Un dos tres "
	chunks = strings.Fields(s)
	fmt.Println(len(chunks))
	fmt.Println(chunks)

	s = "Un dos"
	chunks = strings.Fields(s)
	fmt.Println(len(chunks))
	fmt.Println(chunks)
}
Copy the code

The output

3
[Un dos tres]
3
[Un dos tres]
2
[Un dos]
Copy the code

Strings.Fields can only do that

---

fn main() {
    let s = "What a mess";

    let chunks: Vec<_> = s.split_whitespace().collect();

    println!("{:? }", chunks);
}
Copy the code

The output

["What"."a"."mess"]
Copy the code

or

fn main() {
    let s = "What a mess";

    let chunks: Vec<_> = s.split_ascii_whitespace().collect();

    println!("{:? }", chunks);
}

Copy the code

The output

["What"."a"."mess"]
Copy the code

or

fn main() {
    let s = "What a mess";

    let chunks: Vec<_> = s.split(' ').collect();

    println!("{:? }", chunks);
}

Copy the code

The output

["What"."a".""."mess"]
Copy the code

50. Make an infinite loop

Write an infinite loop

for {
	// Do something
}
Copy the code

package main

import "fmt"

func main(a) {
	k := 0
	for {
		fmt.Println("Hello, playground")
		k++
		if k == 5 {
			break}}}Copy the code

The output

Hello, playground
Hello, playground
Hello, playground
Hello, playground
Hello, playground
Copy the code

---

loop {
	// Do something
}
Copy the code

51. Check if map contains key

Determine whether map m contains an entry for key k

Check whether the map has a key

package main

import (
	"fmt"
)

func main(a) {
	m := map[string]int{
		"uno":  1."dos":  2."tres": 3,
	}

	k := "cinco"
	_, ok := m[k]
	fmt.Printf("m contains key %q: %v\n", k, ok)

	k = "tres"
	_, ok = m[k]
	fmt.Printf("m contains key %q: %v\n", k, ok)
}

Copy the code

The output

m contains key "cinco": false
m contains key "tres": true
Copy the code

---

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert(1."a");
    m.insert(2."b");

    let k = 2;

    let hit = m.contains_key(&k);

    println!("{:? }", hit);
}
Copy the code

52. Check if map contains value

Check if there is a value in the map

package main

import (
	"fmt"
)

func containsValue(m map[K]T, v T) bool {
	for _, x := range m {
		if x == v {
			return true}}return false
}

// Arbitrary types for K, T.
type K string
type T int

func main(a) {
	m := map[K]T{
		"uno":  1."dos":  2."tres": 3,}var v T = 5
	ok := containsValue(m, v)
	fmt.Printf("m contains value %d: %v\n", v, ok)

	v = 3
	ok = containsValue(m, v)
	fmt.Printf("m contains value %d: %v\n", v, ok)
}
Copy the code

The output

m contains value 5: false
m contains value 3: true
Copy the code

---

use std::collections::BTreeMap;

fn main() {
    let mut m = BTreeMap::new();
    m.insert(11."one");
    m.insert(22."twenty-two");

    {
        let v = "eight";
        let does_contain = m.values().any(|&val| *val == *v);
        println!("{:? }", does_contain);
    }

    {
        let v = "twenty-two";
        let does_contain = m.values().any(|&val| *val == *v);
        println!("{:? }", does_contain); }}Copy the code

53. Join a list of strings

String concatenation

package main

import (
	"fmt"
	"strings"
)

func main(a) {

	x := []string{"xxx"."bbb"."aaa"}
	y := strings.Join(x, "&")

	fmt.Println(y)

}

Copy the code

The output

xxx&bbb&aaa

About strings. Joins

---

fn main() {
    let x = vec!["Lorem"."ipsum"."dolor"."sit"."amet"];
    let y = x.join(",");
    println!("{}", y);
}
Copy the code

The output

Lorem, ipsum, dolor, sit, amet
Copy the code

54. Compute sum of integers

Sum of integers

package main

import "fmt"

func main(a) {
	x := []int{1.2.3}
	s := 0
	for _, v := range x {
		s += v
	}
	fmt.Println(s)
}
Copy the code

The output

6

---

fn main() {
    let x: Vec<usize> = (0..=10 _000).collect(); eprintln! ("Sum of 0-10,000 = {}", x.iter().sum::<usize>())
}
Copy the code

The output

Sum of 0-10,000 = 50005000

55. Convert integer to string

Converts integers to strings

package main

import (
	"fmt"
	"strconv"
)

func main(a) {
	var i int = 1234
	s := strconv.Itoa(i)
	fmt.Println(s)
}
Copy the code

The output

1234

or

package main

import (
	"fmt"
	"strconv"
)

func main(a) {
	var i int64 = 1234
	s := strconv.FormatInt(i, 10)
	fmt.Println(s)
}
Copy the code

The output

1234

or

package main

import "fmt"
import "math/big"

func main(a) {
	var i int = 1234
	s := fmt.Sprintf("%d", i)
	fmt.Println(s)

	var j int = 5678
	s = fmt.Sprintf("%d", j)
	fmt.Println(s)

	var k *big.Int = big.NewInt(90123456)
	s = fmt.Sprintf("%d", k)
	fmt.Println(s)
}

Copy the code

The output

1234
5678
90123456
Copy the code

---

fn main() {
    let i = 123;
    let s = i.to_string();

    println!("{}", s);
}
Copy the code

The output

123

or

fn main() {
    let i = 123;
    let s = format!("{}", i);

    println!("{}", s);
}

Copy the code

The output

123

56. Launch 1000 parallel tasks and wait for completion

Fork-join : launch the concurrent execution of procedure f with parameter i from 1 to 1000.

Tasks are independent and f(i) doesn’t return any value. Tasks need not run all at the same time, so you may use a pool. Wait for the completion of the 1000 tasks and then print “Finished”.

Create 1000 parallel tasks and wait for them to complete

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

func f(i int) {
	d := rand.Int() % 10000
	time.Sleep(time.Duration(d))
	fmt.Printf("Hello %v\n", i)
}

func main(a) {
	var wg sync.WaitGroup
	wg.Add(1000)
	for i := 1; i <= 1000; i++ {
		go func(i int) {
			f(i)
			wg.Done()
		}(i)
	}
	wg.Wait()
	fmt.Println("Finished")}Copy the code

The output

Hello 741
Hello 651
Hello 49. (a total of1000A) Hello XXXCopy the code

---

use std::thread;

fn f(i: i32) {
    i + 1;
}

fn main() {
    let threads: VecThe < _ > = (0.10).map(|i| thread::spawn(move || f(i))).collect();

    for t inthreads { t.join(); }}Copy the code

57. Filter list

Create list y containing items from list x satisfying predicate p. Respect original ordering. Don’t modify x in-place.

Filter the values in the list

package main

import "fmt"

type T int

func main(a) {
	x := []T{1.2.3.4.5.6.7.8.9.10}
	p := func(t T) bool { return t%2= =0 }

	y := make([]T, 0.len(x))
	for _, v := range x {
		if p(v) {
			y = append(y, v)
		}
	}

	fmt.Println(y)
}

Copy the code

or

package main

import "fmt"

type T int

func main(a) {
	x := []T{1.2.3.4.5.6.7.8.9.10}
	p := func(t T) bool { return t%2= =0 }

	n := 0
	for _, v := range x {
		if p(v) {
			n++
		}
	}
	y := make([]T, 0, n)
	for _, v := range x {
		if p(v) {
			y = append(y, v)
		}
	}

	fmt.Println(y)
}
Copy the code

The output

[2 4 6 8 10]
Copy the code

---

fn main() {
    let x = vec![1.2.3.4.5.6];

    let y: Vec<_> = x.iter()
        .filter(|&x| x % 2= =0)
        .collect();

    println!("{:? }", y);
}
Copy the code

The output

[2.4.6]
Copy the code

58. Extract file content to a string

Extract the file contents of the string

package main

import "fmt"
import "io/ioutil"

func main(a) {
	f := "data.txt"
	b, err := ioutil.ReadFile(f)
	iferr ! =nil {
		panic(err)
	}
	lines := string(b)

	fmt.Println(lines)
}

// Create file in fake FS of the Playground. init is executed before main.
func init(a) {
	err := ioutil.WriteFile("data.txt"And []byte(`Un
Dos
Tres`), 0644)
	iferr ! =nil {
		panic(err)
	}
}

Copy the code

The output

Un
Dos
Tres
Copy the code

---

use std::fs::File;
use std::io::prelude::*;

fn main() - >Result< () () > {let f = "Cargo.toml";

    let mut file = File::open(f).expect("Can't open file.");
    let mut lines = String::new();
    file.read_to_string(&mut lines)
        .expect("Can't read file contents.");

    println!("{}", lines);

    Ok(())}Copy the code

or

use std::fs;

fn main() {
    let f = "Cargo.toml";

    let lines = fs::read_to_string(f).expect("Can't read file.");

    println!("{}", lines);
}
Copy the code

59. Write to standard error stream

Print the message “x is negative” to standard error (stderr), with integer x value substitution (e.g. “-2 is negative”).

Writes to standard error stream

package main

import (
	"fmt"
	"os"
)

func main(a) {
	x := 2 -
	fmt.Fprintln(os.Stderr, x, "is negative")}Copy the code

The output

2 - is negative
Copy the code

---

fn main() {
    let x = -3; eprintln! ("{} is negative", x);
}

Copy the code

The output

-3 is negative
Copy the code

60. Read command line argument

Read command line arguments

import "os"
x := os.Args[1]
Copy the code

---

use std::env;

fn main() {
    let first_arg = env::args().skip(1).next();

    let fallback = "".to_owned();
    let x = first_arg.unwrap_or(fallback);
    
    println!("{:? }", x);
}
Copy the code

The output

""