Rust vs Go:常用语法对比(四)（1）

package main
import (
  "fmt"
  "time"
)
func main() {
  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.
}

extern crate time;
let d = time::now();

use std::time::SystemTime;
fn main() {
    let d = SystemTime::now();
    println!("{:?}", d);
}

package main
import (
  "fmt"
  "strings"
)
func main() {
  x := "été chaud"
  {
    y := "chaud"
    i := strings.Index(x, y)
    fmt.Println(i)
  }
  {
    y := "froid"
    i := strings.Index(x, y)
    fmt.Println(i)
  }
}

6
-1

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);
}

Some(6)
None

package main
import (
  "fmt"
  "strings"
)
func main() {
  x := "oink oink oink"
  y := "oink"
  z := "moo"
  x2 := strings.Replace(x, y, z, -1)
  fmt.Println(x2)
}

fn main() {
    let x = "lorem ipsum dolor lorem ipsum";
    let y = "lorem";
    let z = "LOREM";
    let x2 = x.replace(&y, &z);
    println!("{}", x2);
}

package main
import "fmt"
import "math/big"
func main() {
  x := new(big.Int)
  x.Exp(big.NewInt(3), big.NewInt(247), nil)
  fmt.Println(x)
}

extern crate num;
use num::bigint::ToBigInt;
fn main() {
    let a = 3.to_bigint().unwrap();
    let x = num::pow(a, 247);
    println!("{}", x)
}

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

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

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() {
  x := big.NewInt(3)
  n := 5
  z := exp(x, n)
  fmt.Println(z)
}

extern crate num;
use num::bigint::BigInt;
fn main() {
    let x = BigInt::parse_bytes(b"600000000000", 10).unwrap();
    let n = 42%

package main
import (
  "fmt"
  "math/big"
)
func main() {
  z := new(big.Int)
  z.Binomial(4, 2)
  fmt.Println(z)
  z.Binomial(133, 71)
  fmt.Println(z)
}

6
555687036928510235891585199545206017600

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));
}

package main
import (
  "fmt"
  "math/big"
)
func main() {
  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))
  }
}

x has bit 13 set to 0
x has bit 42 set to 1

package main
import (
  "fmt"
)
const n = 1024
func main() {
  x := make([]bool, n)
  x[42] = true
  for _, y := range []int{13, 42} {
    fmt.Println("x has bit", y, "set to", x[y])
  }
}

x has bit 13 set to false
x has bit 42 set to true

package main
import (
  "fmt"
)
func main() {
  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)
}

x has bit 13 set to false
x has bit 42 set to true

fn main() {
    let n = 20;
    let mut x = vec![false; n];
    x[3] = true;
    println!("{:?}", x);
}

package main
import (
  "fmt"
  "math/rand"
)
func main() {
  var s int64 = 42
  rand.Seed(s)
  fmt.Println(rand.Int())
}

package main
import (
  "fmt"
  "math/rand"
)
func main() {
  var s int64 = 42
  r := rand.New(rand.NewSource(s))
  fmt.Println(r.Int())
}

use rand::{Rng, SeedableRng, rngs::StdRng};
fn main() {
    let s = 32;
    let mut rng = StdRng::seed_from_u64(s);
    println!("{:?}", rng.gen::<f32>());
}

package main
import (
  "fmt"
  "math/rand"
  "time"
)
func main() {
  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))
}

package main
import (
  "fmt"
  "math/rand"
  "time"
)
func main() {
  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))
}

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>());
}