fork download
copy 
  1. fn main() {
  2.     let xs: Vec<i64> = vec![3, 1, 4, 1, 5];
  3.     let rev_xs: Vec<i64> = xs.iter().map(|&x| x).rev().collect();
  4.     println!("rev_xs = {:?}", rev_xs);
  5.     let acc: Vec<_> = xs.iter()
  6.         .scan(0, |state, &x| { *state += x; Some(*state) })
  7.         .collect();
  8.     println!("acc = {:?}", acc);
  9.     let ys = vec![2, 7, 1, 8, 2];
  10.     let xys: Vec<_> = xs.iter().map(|&x| x).zip(ys.iter().map(|&x| x)).collect();
  11.     println!("xys = {:?}", xys);
  12.     let sqs: Vec<_> = xs.iter().map(|&x| x.pow(2)).collect();
  13.     println!("sqs = {:?}", sqs);
  14.     let odds: Vec<_> = xs.iter().filter(|&&x| x % 2 == 1).map(|&x| x).collect();
  15.     println!("odds = {:?}", odds);
  16.     let (fib5, _) = (0..4).fold(
  17.         (1, 0),
  18.         |(p, pp), _| (p + pp, p)
  19.     );
  20.     println!("fib5 = {}", fib5);
  21.     let x_max = *xs.iter().max().unwrap();
  22.     println!("x_max = {}", x_max);
  23.     let zs = vec![];
  24.     let z_min = *zs.iter().max().unwrap_or(&0);
  25.     println!("z_min = {}", z_min);
  26.     let x_argmin = *xs.iter().min_by_key(|&&x| x % 2).unwrap();
  27.     println!("x_argmin = {}", x_argmin);
  28.     let s: i64 = xs.iter().sum();
  29.     println!("s = {}", s);
  30.     let is_all_odd = xs.iter().all(|&x| x % 2 == 1);
  31.     println!("is_all_odd = {}", is_all_odd);
  32.     let does_exist_even = xs.iter().any(|&x| x % 2 == 0);
  33.     println!("does_exist_even = {}", does_exist_even);
  34.     let indexed_xs: Vec<_> = xs.iter().map(|&x| x).enumerate().collect();
  35.     println!("indexed_xs = {:?}", indexed_xs);
  36.     let sorted_xs: Vec<_> = {
  37.         let mut tmp_xs = xs.clone();
  38.         tmp_xs.sort();
  39.         tmp_xs
  40.     };
  41.     println!("sorted_xs = {:?}", sorted_xs);
  42.     let ps: Vec<_> = (0..10).collect();
  43.     println!("ps = {:?}", ps);
  44.     let qs: Vec<_> = (1..10).collect();
  45.     println!("qs = {:?}", qs);
  46.     let heads = xs[..3].to_vec();
  47.     println!("heads = {:?}", heads);
  48.     let tails = xs[3..].to_vec();
  49.     println!("tails = {:?}", tails);
  50. }
  51.  
Success #stdin #stdout 0s 4448KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
rev_xs = [5, 1, 4, 1, 3]
acc = [3, 4, 8, 9, 14]
xys = [(3, 2), (1, 7), (4, 1), (1, 8), (5, 2)]
sqs = [9, 1, 16, 1, 25]
odds = [3, 1, 1, 5]
fib5 = 5
x_max = 5
z_min = 0
x_argmin = 4
s = 14
is_all_odd = false
does_exist_even = true
indexed_xs = [(0, 3), (1, 1), (2, 4), (3, 1), (4, 5)]
sorted_xs = [1, 1, 3, 4, 5]
ps = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
qs = [1, 2, 3, 4, 5, 6, 7, 8, 9]
heads = [3, 1, 4]
tails = [1, 5]
https://ideone.com/JCRFWl
iterate
language:
Rust (rust 1.56)
created:
4 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!