syuntoku14の進捗

進捗を書きなぐります

進捗: 2018-10-05

 

進捗: 2018-10-05

08:00~ 起床
09:00~12:00 お絵かきの授業
13:00~17:00 睡眠
18:00~24:00 Rustの練習とか

なんで私はアメリカに来てまでお絵かきをしているのか。でもお絵かきの授業全然課題でないから好き。教授が言っていることは英語力が足りないので大体わからない。

今日のお絵かき:

Blinder Contour Drawingを学んだ。その後インクを使ったお絵かきをした。紙は見ないで、描く対象だけ見て輪郭を描くことで目の動きと手の動きの同期を練習するみたいなアレ。よくわからん。弟は現役の美大生だが私は美術全然知らないので何も分からん。

f:id:syuntoku14:20181005164447p:plain

f:id:syuntoku14:20181005164519p:plain

ルームメイトのResumeを見て、賞がたくさんあってすごいなと言う気持ち。自分のResumeを見てみたが何もなかった。つれえ〜。

AIクラブが強化学習のコンペのメンバーを募集してて、強化学習やっときゃよかったと言う気持ちにもなっている。とりあえず顔を出して強化学習を教えてもらおうかな。

暇な時間をRustで競プロにあててる。暇な時間あんまりないけど。Rustがそもそも難しい。私は何故Rustをやっているのか。

Rustが好きすぎて生徒から文句を言われている教授を見つけた。授業取りたかったが、Rustが難しいので学部から文句を言われて今年からPythonになったみたい。悲しい。

* 入力関係:https://qiita.com/penguinshunya/items/cd96803b74635aebefd6

* タプルのソート:

fn main() {
    let mut tuple_list = vec![(1, 5), (9, 2), (4, 8)];
    tuple_list.sort_by_key(|k| k.1);

    print!("{:?}", tuple_list);
}

* VectorのSum:

let sum: i64 = array.iter().fold(0, |sum, a| sum + a.count);

今日解いたやつ:

* Rummy:

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

fn is_same_number(a: i32, b: i32, c: i32) -> bool {
    a == b && a == c
}

fn is_sequense_number(a: i32, b: i32, c: i32) -> bool {
    a + 1 == b && b + 1 == c
}

fn is_good_set(a: i32, b: i32, c: i32) -> bool {
    is_same_number(a, b, c) || is_sequense_number(a, b, c)
}

fn remove_good_set(vec: &mut Vec<i32>) {
    let vecsize: usize = vec.len();
    let mut flag: bool = false;
    //println!("{}", vecsize);
    for i in 0..vecsize {
        for j in i + 1..vecsize {
            for k in j + 1..vecsize {
                //println!("{}, {}, {}", i, j, k);
                if is_good_set(vec[i], vec[j], vec[k]) {
                    vec.remove(k);
                    vec.remove(j);
                    vec.remove(i);
                    flag = true;
                }
                if flag {
                    break;
                }
            }
            if flag {
                break;
            }
        }
        if flag {
            break;
        }
    }
}

fn main() {
    let n: i32 = read();
    for i in 0..n {
        let mut vec_num: Vec<i32> = read_vec();
        let vec_mark: Vec<String> = read_vec();

        // modify the vector for simplification
        for i in 0..9 as usize {
            if vec_mark[i] == "G" {
                vec_num[i] = vec_num[i] + 10;
            } else if vec_mark[i] == "B" {
                vec_num[i] = vec_num[i] + 20;
            }
        }

        vec_num.sort();
        let mut ans: i32 = 0;
        for i in 0..3 {
            remove_good_set(&mut vec_num);
        }
        if vec_num.len() == 0 {
            ans = 1;
        }

        println!("{}", ans);
        //println!("----");
    }
}

* Princess's Marriage

use std::io;

fn read() -> Vec<i32> {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim()
        .split_whitespace()
        .map(|e| e.parse().unwrap())
        .collect()
}

fn main() {
    loop {
        let NM = read();
        let N = NM[0] as usize;
        let mut M = NM[1];

        if N == 0 && M == 0 {
            break;
        }

        let mut DP_tuple = Vec::new();
        for i in 0..N {
            let DP = read();
            DP_tuple.push((DP[0], DP[1]));
        }
        DP_tuple.sort_by_key(|k| k.1);
        DP_tuple.reverse();

        for i in 0..DP_tuple.len() as usize {
            let DP = DP_tuple[i];
            let remain = M - DP.0;
            if remain >= 0 {
                DP_tuple[i].0 = 0;
                M = remain;
            } else {
                DP_tuple[i].0 = -remain;
                break;
            }
        }
        //println!("{:?}", DP_tuple);

        let ans = DP_tuple
            .iter()
            .fold(0, |acc, tuple| acc + tuple.0 * tuple.1);
        println!("{}", ans);
    }
}

* Space CoconutCrab

use std::io;

fn main() {
    loop {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).unwrap();
        let mut iter = s.split_whitespace();
        let e: i64 = iter.next().unwrap().parse().unwrap();

        if e == 0 {
            break;
        }

        let mut min_ = 1e8 as i64;
        let mut flag: bool = false;
        for z in 0..101 as i64 {
            for y in 0..1001 as i64 {
                let x = e - z.pow(3) - y.pow(2);
                //println!{"{}, {}, {}", x, y, z};
                if x < 0 {
                    break;
                }
                if min_ > x + y + z {
                    min_ = x + y + z;
                }
            }
        }
        println!("{}", min_);
    }
}

日課

  • [ ] Control Systems の予習と復習
  • [ ] Probabilistic Analysis の予習と復習
  • [ ] 英会話の練習
  • [ ] 確率ロボティクス
  • [ ] Algorithms at Coursera
  • [ ] 大学生からの確率統計