Rust vs Go: A Comparison of Common Grammar (4)

61. Get current date

Get the current time

package main

import (
	"fmt"
	"time"
)

func main(a) {
	d := time.Now()
	fmt.Println("Now is", d)
	// The Playground has a special sandbox, so you may get a Time value fixed in the past.
}

Copy the code

Now IS 2009-11-10 23:00:00 +0000 UTC M =+0.000000001

extern crate time;
let d = time::now();
Copy the code

use std::time::SystemTime;

fn main() {
    let d = SystemTime::now();
    println!("{:? }", d);
}
Copy the code

SystemTime { tv_sec: 1526318418, tv_nsec: 699329521 }

62. Find substring position

String lookup

Find substring positions

package main

import (
	"fmt"
	"strings"
)

func main(a) {
	x := "été chaud"

	{
		y := "chaud"
		i := strings.Index(x, y)
		fmt.Println(i)
	}

	{
		y := "froid"
		i := strings.Index(x, y)
		fmt.Println(i)
	}
}
Copy the code

i is the byte index of y in x, not the character (rune) index. i will be -1 if y is not found in x.

6
- 1
Copy the code

fn main() {
    let x = "été chaud";
    
    let y = "chaud";
    let i = x.find(y);
    println!("{:? }", i);
    
    let y = "froid";
    let i = x.find(y);
    println!("{:? }", i);
}
Copy the code

Some(6)
None
Copy the code

63. Replace fragment of a string

Replace string fragments

package main

import (
	"fmt"
	"strings"
)

func main(a) {
	x := "oink oink oink"
	y := "oink"
	z := "moo"
	x2 := strings.Replace(x, y, z, - 1)
	fmt.Println(x2)
}
Copy the code

moo moo moo

fn main() {
    let x = "lorem ipsum dolor lorem ipsum";
    let y = "lorem";
    let z = "LOREM";

    let x2 = x.replace(&y, &z);
    
    println!("{}", x2);
}
Copy the code

LOREM ipsum dolor LOREM ipsum

64. Big integer : value 3 power 247

Large integer

package main

import "fmt"
import "math/big"

func main(a) {
	x := new(big.Int)
	x.Exp(big.NewInt(3), big.NewInt(247), nil)
	fmt.Println(x)
}

Copy the code

7062361041362837614435796717454722507454089864783271756927542774477268334591598635421519542453366332460075473278915787

extern crate num;
use num::bigint::ToBigInt;

fn main() {
    let a = 3.to_bigint().unwrap();
    let x = num::pow(a, 247);
    println!("{}", x)
}
Copy the code

7062361041362837614435796717454722507454089864783271756927542774477268334591598635421519542453366332460075473278915787

65. Format decimal number

Formatted decimal number

package main

import "fmt"

func main(a) {
	x := 0.15625
	s := fmt.Sprintf("%.1f%%".100.0*x)
	fmt.Println(s)
}

Copy the code

15.6%

fn main() {
    let x = 0.15625 f64;
    let s = format!({" : 1} %".100.0 * x);
    
    println!("{}", s);
}

Copy the code

15.6%

66. Big integer exponentiation

Large integer power operation

package main

import "fmt"
import "math/big"

func exp(x *big.Int, n int) *big.Int {
	nb := big.NewInt(int64(n))
	var z big.Int
	z.Exp(x, nb, nil)
	return &z
}

func main(a) {
	x := big.NewInt(3)
	n := 5
	z := exp(x, n)
	fmt.Println(z)
}

Copy the code

243

extern crate num;

use num::bigint::BigInt;

fn main() {
    let x = BigInt::parse_bytes(b"600000000000".10).unwrap();
    let n = 42%
Copy the code

67. Binomial coefficient “n choose k”

Calculate binom(n, k) = n! / (k! * (n-k)!) . Use an integer type able to handle huge numbers.

Binomial coefficient “N choose K”

package main

import (
	"fmt"
	"math/big"
)

func main(a) {
	z := new(big.Int)
	
	z.Binomial(4.2)
	fmt.Println(z)
	
	z.Binomial(133.71)
	fmt.Println(z)
}

Copy the code

6
555687036928510235891585199545206017600
Copy the code

extern crate num;

use num::bigint::BigInt;
use num::bigint::ToBigInt;
use num::traits::One;

fn binom(n: u64, k: u64) -> BigInt {
    let mut res = BigInt::one();
    for i in 0..k {
        res = (res * (n - i).to_bigint().unwrap()) /
              (i + 1).to_bigint().unwrap();
    }
    res
}

fn main() {
    let n = 133;
    let k = 71;

    println!("{}", binom(n, k));
}

Copy the code

555687036928510235891585199545206017600

68. Create a bitset

Creating a collection of bits

package main

import (
	"fmt"
	"math/big"
)

func main(a) {
	var x *big.Int = new(big.Int)

	x.SetBit(x, 42.1)

	for _, y := range []int{13.42} {
		fmt.Println("x has bit", y, "set to", x.Bit(y))
	}
}
Copy the code

x has bit 13 set to 0
x has bit 42 set to 1
Copy the code

package main

import (
	"fmt"
)

const n = 1024

func main(a) {
	x := make([]bool, n)

	x[42] = true

	for _, y := range []int{13.42} {
		fmt.Println("x has bit", y, "set to", x[y])
	}
}
Copy the code

x has bit 13 set to false
x has bit 42 set to true
Copy the code

package main

import (
	"fmt"
)

func main(a) {
	const n = 1024

	x := NewBitset(n)

	x.SetBit(13)
	x.SetBit(42)
	x.ClearBit(13)

	for _, y := range []int{13.42} {
		fmt.Println("x has bit", y, "set to", x.GetBit(y))
	}
}

type Bitset []uint64

func NewBitset(n int) Bitset {
	return make(Bitset, (n+63) /64)}func (b Bitset) GetBit(index int) bool {
	pos := index / 64
	j := index % 64
	return (b[pos] & (uint64(1) << j)) ! =0
}

func (b Bitset) SetBit(index int) {
	pos := index / 64
	j := index % 64
	b[pos] |= (uint64(1) << j)
}

func (b Bitset) ClearBit(index int) {
	pos := index / 64
	j := index % 64
	b[pos] ^= (uint64(1) << j)
}

Copy the code

x has bit 13 set to false
x has bit 42 set to true
Copy the code

fn main() {
    let n = 20;

    let mut x = vec![false; n];

    x[3] = true;
    println!("{:? }", x);
}

Copy the code

[false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]

69. Seed random generator

Use seed s to initialize a random generator.

If s is constant, the generator output will be the same each time the program runs. If s is based on the current value of the system clock, the generator output will be different each time.

Random seed generator

package main

import (
	"fmt"
	"math/rand"
)

func main(a) {
	var s int64 = 42
	rand.Seed(s)
	fmt.Println(rand.Int())
}

Copy the code

3440579354231278675

package main

import (
	"fmt"
	"math/rand"
)

func main(a) {
	var s int64 = 42
	r := rand.New(rand.NewSource(s))
	fmt.Println(r.Int())
}
Copy the code

3440579354231278675

use rand::{Rng, SeedableRng, rngs::StdRng};

fn main() {
    let s = 32;
    let mut rng = StdRng::seed_from_u64(s);
    
    println!("{:? }", rng.gen::<f32> ()); }Copy the code

0.35038823

70. Use clock as random generator seed

Get the current datetime and provide it as a seed to a random generator. The generator sequence will be different at each run.

Use the clock as the seed for the random generator

package main

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

func main(a) {
	rand.Seed(time.Now().UnixNano())
	// Well, the playground date is actually fixed in the past, and the
	// output is cached.
	// But if you run this on your workstation, the output will vary.
	fmt.Println(rand.Intn(999))}Copy the code

524

package main

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

func main(a) {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	// Well, the playground date is actually fixed in the past, and the
	// output is cached.
	// But if you run this on your workstation, the output will vary.
	fmt.Println(r.Intn(999))}Copy the code

524

use rand::{Rng, SeedableRng, rngs::StdRng};
use std::time::SystemTime;

fn main() {
    let d = SystemTime::now()
        .duration_since(SystemTime::UNIX_EPOCH)
        .expect("Duration since UNIX_EPOCH failed");
    let mut rng = StdRng::seed_from_u64(d.as_secs());
    
    println!("{:? }", rng.gen::<f32> ()); }Copy the code

0.7326781

71. Echo program implementation

Basic implementation of the Echo program: Print all arguments except the program name, separated by space, followed by newline.

The idiom demonstrates how to skip the first argument if necessary, concatenate arguments as strings, append newline and print it to stdout.

Echo program

package main
import "fmt"
import "os"
import "strings"
func main(a) {
    fmt.Println(strings.Join(os.Args[1:].""))}Copy the code

use std::env;

fn main() {
    println!("{}", env::args().skip(1).collect::<Vec<_>>().join(""));
}
Copy the code

use itertools::Itertools;
println!("{}", std::env::args().skip(1).format(""));
Copy the code

74. Compute GCD

Compute the greatest common divisor x of big integers a and b. Use an integer type able to handle huge numbers.

Compute the greatest common divisor x of the large integers A and b. Use integer types that can handle large numbers.

package main

import "fmt"
import "math/big"

func main(a) {
	a, b, x := new(big.Int), new(big.Int), new(big.Int)
	a.SetString("6000000000000".10)
	b.SetString("9000000000000".10)
	x.GCD(nil.nil, a, b)
	fmt.Println(x)
}

Copy the code

3000000000000

extern crate num;

use num::Integer;
use num::bigint::BigInt;

fn main() {
    let a = BigInt::parse_bytes(b"6000000000000".10).unwrap();
    let b = BigInt::parse_bytes(b"9000000000000".10).unwrap();
    
    let x = a.gcd(&b);
 
    println!("{}", x);
}
Copy the code

3000000000000

75. Compute LCM

Compute the least common multiple x of the large integers A and b. Use integer types that can handle large numbers.

Compute the least common multiple x of big integers a and b. Use an integer type able to handle huge numbers.

package main

import "fmt"
import "math/big"

func main(a) {
	a, b, gcd, x := new(big.Int), new(big.Int), new(big.Int), new(big.Int)
	a.SetString("6000000000000".10)
	b.SetString("9000000000000".10)
	gcd.GCD(nil.nil, a, b)
	x.Div(a, gcd).Mul(x, b)
	fmt.Println(x)
}
Copy the code

18000000000000

extern crate num;

use num::bigint::BigInt;
use num::Integer;

fn main() {
    let a = BigInt::parse_bytes(b"6000000000000".10).unwrap();
    let b = BigInt::parse_bytes(b"9000000000000".10).unwrap();
    let x = a.lcm(&b);
    println!("x = {}", x);
}
Copy the code

x = 18000000000000

76. Binary digits from an integer

Create the string s of integer x written in base 2.

E.g. 13 -> “1101”

Converts a decimal integer to a binary number

package main

import "fmt"
import "strconv"

func main(a) {
	x := int64(13)
	s := strconv.FormatInt(x, 2)

	fmt.Println(s)
}

Copy the code

1101

package main

import (
	"fmt"
	"math/big"
)

func main(a) {
	x := big.NewInt(13)
	s := fmt.Sprintf("%b", x)

	fmt.Println(s)
}
Copy the code

1101

fn main() {
    let x = 13;
    let s = format!("{:b}", x);
    
    println!("{}", s);
}
Copy the code

1101

77. SComplex number

Declare a complex x and initialize it with value (3i – 2). Then multiply it by i.

The plural

package main

import (
	"fmt"
	"reflect"
)

func main(a) {
	x := 3i - 2
	x *= 1i

	fmt.Println(x)
	fmt.Print(reflect.TypeOf(x))
}

Copy the code

(- 3-2i)
complex128
Copy the code

extern crate num;
use num::Complex;

fn main() {
    let mut x = Complex::new(-2.3);
    x *= Complex::i();
    println!("{}", x);
}
Copy the code

-3-2i

78. “do while” loop

Execute a block once, then execute it again as long as boolean condition c is true.

Loop execution

package main

import (
	"fmt"
	"math/rand"
)

func main(a) {
	for {
		x := rollDice()
		fmt.Println("Got", x)
		if x == 3 {
			break}}}func rollDice(a) int {
	return 1 + rand.Intn(6)}Copy the code

Go has no do while loop, use the for loop, instead.

Got 6
Got 4
Got 6
Got 6
Got 2
Got 1
Got 2
Got 3
Copy the code

package main

import (
	"fmt"
	"math/rand"
)

func main(a) {
	for done := false; ! done; { x := rollDice() fmt.Println("Got", x)
		done = x == 3}}func rollDice(a) int {
	return 1 + rand.Intn(6)}Copy the code

Got 6
Got 4
Got 6
Got 6
Got 2
Got 1
Got 2
Got 3
Copy the code

loop {
    doStuff();
    if! c {break; }}Copy the code

Rust has no do-while loop with syntax sugar. Use loop and break.

79. Convert integer to floating point number

Declare floating point number y and initialize it with the value of integer x .

Integer to floating point

Declare the floating point number y and initialize it with the value of the integer x.

package main

import (
	"fmt"
	"reflect"
)

func main(a) {
	x := 5
	y := float64(x)

	fmt.Println(y)
	fmt.Printf("%.2f\n", y)
	fmt.Println(reflect.TypeOf(y))
}
Copy the code

5
5.00
float64
Copy the code

fn main() {
    let i = 5;
    let f = i as f64;
    
    println!("int {:? }, float {:? }", i, f);
}
Copy the code

int 5, float 5.0
Copy the code

80. Truncate floating point number to integer

Declare integer y and initialize it with the value of floating point number x . Ignore non-integer digits of x .

Make sure to truncate towards zero: a negative x must yield the closest greater integer (not lesser).

Floating point to integer

package main

import "fmt"

func main(a) {
	a := 6.4
	b := 6.4
	c := 6.6
	fmt.Println(int(a))
	fmt.Println(int(b))
	fmt.Println(int(c))
}
Copy the code

- 6
6
6
Copy the code

fn main() {
    let x = 41.59999999 f64;
    let y = x as i32;
    println!("{}", y);
}
Copy the code

41

Rust vs Go: A Comparison of Common Grammar (4)

61. Get current date

62. Find substring position

63. Replace fragment of a string

64. Big integer : value 3 power 247

65. Format decimal number

66. Big integer exponentiation

67. Binomial coefficient “n choose k”

68. Create a bitset

69. Seed random generator

70. Use clock as random generator seed

71. Echo program implementation

74. Compute GCD

75. Compute LCM

76. Binary digits from an integer

77. SComplex number

78. “do while” loop

79. Convert integer to floating point number

80. Truncate floating point number to integer

Related Posts

10 things to avoid in Docker containers

Tomcat has a bug after more than 10 years of use!

Jdk8 -CopyOnWriteArrayList and CopyOnWriteArraySet