Closed65

RustのPaiza問題集をやっていく

① 文字列を取得して出力

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_step1
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
    let a: String = read();
    println!("{}", a);
}

https://doc.rust-jp.rs/rust-by-example-ja/std/str.html
https://qiita.com/tubo28/items/e6076e9040da57368845

② うるう年の判定

https://paiza.jp/works/mondai/dateset/leap_year
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
    let a: u32 = read();
    if a % 400 == 0 {
        println!("Yes");
    } else if a % 100 == 0 {
        println!("No");
    } else if a % 4 == 0 {
        println!("Yes");
    } else {
        println!("No")
    }
}

https://doc.rust-jp.rs/rust-by-example-ja/flow_control/if_else.html
https://doc.rust-jp.rs/book-ja/ch03-02-data-types.html

③ 繰り返し処理

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_step2
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let a: u32 = read();

// 繰り返し処理
  for n in 0..a {
    println!("paiza");
  }
}

https://doc.rust-jp.rs/rust-by-example-ja/flow_control/for.html

④ 繰り返し取得&出力

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_step3
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let num: u32 = read();

  for n in 0..num {
    let x: u32 = read();
    println!("{}", x);
  }
}

⑤ 入力した内容を配列に保存する

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_step4
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){

  let num = read();

  // ベクター
  let mut input_vector = Vec::new();

  for n in 0..num {
    let x: i32 = read();
    input_vector.push(x);
  }
  
  // 並び替え
  input_vector.sort();

  //並び替え後、もっとも最後のデータ=最大値を出力
  println!("{:?}", input_vector[input_vector.len()-1]);
}
  • ベクタ型とベクタ型への追加
let mut vec = Vec::new();
vec.push(1);
vec.push(2);

https://moshg.github.io/rust-std-ja/std/vec/struct.Vec.html
println!("{:?}")とすると1行で出力される
https://qiita.com/task4233/items/b6f7c457e25bc5236075
ベクタ型のソート .sort();
https://uma0317.github.io/rust-cookbook-ja/algorithms/sorting.html
ベクタ型のサイズ .len()
https://doc.rust-jp.rs/rust-by-example-ja/std/vec.html

⑥ 半角スペースで区切って出力

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_step5
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let num = read();

  for n in 0..num {
    print!("paiza");

    // 繰り返し処理最後以外、半角スペースを挟む処理    
    if n < num - 1 {
        print!(" ");
    }
  }
}

⑦ 改行して出力

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_step6
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let times = read();
  
  for n in 0..times {
    let num: i32 = read();
    println!("{}", num);
  }
}

⑧ 文字列と数字を取得し出力。加えて数字は計算で変更する

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_std_in_out_boss
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let num: u32 = read();
  
  for n in 0..num {
      let name: String = read();
      let mut age: u32 = read();
      
      println!("{} {}", name, age+1)
  }
}

https://qiita.com/hiro4669/items/1eea8c6443e7b533ea03

⑨ 文字列操作

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_string_boss

数値への変換 .parse().unwrap()
文字列への変換 .to_string()
文字列の長さ .chars().count()

解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let num: u32 = read(); //数値の取得

  // 繰り返し処理
  for n in 0..num {
      let time: String = read(); // 時刻(文字列)の取得
      let plus_hour: u32 = read(); // 加算する時間(数値)の取得
      let plus_minute: u32 = read(); // 加算する分(数値)の取得
      
      let mut hour: u32 = time[0..2].parse().unwrap(); // 時刻(文字列)の「時間」の部分を数字に変換
      let mut minute: u32 = time[3..5].parse().unwrap();  // 時刻(文字列)の「分」の部分を数字に変換
      
      minute = minute + plus_minute; // 分を加算
      hour = hour + plus_hour; // 時間を加算
      
      let mut hour_s: String; // 数値を文字列に変換したものを代入する変数
      let mut minute_s: String; // 同上
      
      // 分が60以上の場合は分をマイナス60、時間をプラス1
      if minute >= 60 {
          minute = minute - 60;
          hour = hour + 1;
      }  
      
      // 時間が24以上の場合は時間をプラス24。else if にすると上記のifに条件が引っかかった時点で下記の処理がされなくなるので注意。
      if hour >= 24 {
          hour = hour - 24;
      }
      
      // 文字列に変換
      hour_s = hour.to_string();
      minute_s = minute.to_string();
      
      // 1文字の場合は頭に 「0」を付ける
      if hour_s.chars().count() == 1 {
          hour_s = "0".to_owned() + &hour_s
      } 
      
      if minute_s.chars().count() == 1 {
          minute_s = "0".to_owned() + &minute_s
      }
      
      println!("{}:{}", hour_s, minute_s)
  }
}

https://doc.rust-jp.rs/rust-by-example-ja/flow_control/if_else.html
https://qiita.com/smicle/items/29a4d5d1d14ad7f77f60
https://www.it-swarm-ja.com/ja/rust/rustの文字列の長さを取得する/834081743/

⑩ 3の倍数を探す

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_for_step1
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let num: u32 = read(); //数値の取得
  
  let mut counter: u32 = 0; // 3の倍数のカウンター
  
  for n in 0..num {
      let x: u32 = read();
      if x % 3 == 0 { // 3で割った余りが0のとき、counter を +1 
          counter = counter + 1;
      }
  }
  println!("{}", counter);
}

⑪ フラグ管理

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_for_step2
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let num: u32 = read();
  
  // 7がある個数をカウントする変数
  let mut counter: u32 = 0;
  
  for n in 0..num {
      let answer: u32 = read();
      
      // 7がある場合は、counter を +1 する
      if answer == 7 {
          counter += 1;
      }
  }
  
  // 1つ以上 7 がある場合は YES、そうでないなら NO
  if counter >= 1 {
      println!("YES")
  } else {
      println!("NO")
  }
}

⑫ インデックス取得

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_for_step3
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let num :u32 = read();

  let mut money_vec = Vec::new();
  
  // ベクターに保存
  for n in 0..num {
      let money :u32 = read();
      money_vec.push(money);
  }
  
  // 解答を取得
  let answer :u32 = read();
  
  // ベクターに保存した数値と解答を比較
  for n in 0..(num as usize) {
      if answer == money_vec[n] { // 一致した場合は n+1を返して break
        println!("{}", n+1);
        break
      }
  }
}

インデックスを指定して配列の一部を出力する際は、usize とする

https://qiita.com/osorezugoing/items/23940e2507ae6149f12d

for文で使う場合は下記の様にする。

for i in 0..(n as usize) {
    println!("{}", x[i]);
}

https://teratail.com/questions/311514

⑫ 多重ループ処理

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_for_boss
解答
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let persons :u32 = read(); // 参加者の人数
  let write_times :u32 = read(); // 数字を書く回数
  let answer :u32 = read(); // 回答となる数字
  
  for i in 0..persons { // 参加者ごとのループ処理
      
      let mut counter :u32 = 0; // 書いた数と正解の数が一致した数をカウントする変数
  
      for j in 0..write_times { // 書ける数だけのループ処理
      
          let write_num :u32 = read();
          if write_num == answer { // 書いた数と正解の数が一致した時の処理
              counter += 1; // 変数を +1
              
          }
      }
      println!("{}", counter)
  }
}

⑬ 1日1万歩

https://paiza.jp/works/mondai/drankfast/d1_step_distance
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let walk_km :f32 = read();
  let stride_cm :f32 = read();
  
  let mut step :f32;
  step = walk_km / stride_cm * 100000.0;
  
  if step >= 10000.0 {
      println!("yes");
  } else {
      println!("no");
  }
} 

https://qiita.com/deta-mamoru/items/9c2596a617fdf707ec4f

⑭ 正n角形の内角

https://paiza.jp/works/mondai/drankfast/d2_polygon
正解
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let num :f32 = read();
  println!("{}", (180.0 * (num - 2.0) / num).floor());
}
xxx.round() // 四捨五入
xxx.ceil() // 切り上げ 
xxx.floor() // 切り捨て

https://mseeeen.msen.jp/rust-rounding-to-specific-decimal-place/

⑮ うなりの周波数

https://paiza.jp/works/mondai/drankfast/d3_beat_frequency
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  
  let f1 :u32 = read();
  let f2 :u32 = read();

  if f1 >= f2 {
      println!("{}", f1-f2);
  } else {
      println!("{}", f2-f1);
  }
}

⑯ 文字列のスライスとループ処理

https://paiza.jp/works/mondai/drankfast/d4_maybe
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}


fn main(){
  // 適当な文字列を代入
  let mut sentence = String::from("blank");
  
  //最後の1文字が , (カンマ) の文字列が来るまでループ処理
  while &sentence[sentence.len()-1..sentence.len()] != "," {

        sentence = read();
        
        // 最後の1文字目が , (カンマ) でない場合は改行無し、末尾にスペースそのまま出力
        // 最後の1文字目が , (カンマ) の場合は最後の1文字を除く部分と !! を出力する        
        if &sentence[sentence.len()-1..sentence.len()] != "," {
            print!("{} ", sentence);
        } else {
            println!("{}{}", &sentence[0..sentence.len()-1], "!!")
        }
  }
}
// while を使ったループ処理
let mut n = 1;

while n < 100 {
   略
   n += 1;
}

https://doc.rust-jp.rs/rust-by-example-ja/flow_control/while.html
// 空のミュータブルな String を宣言
let mut string = String::new();

// ノンミュータブルで指定した文字列を含む String を宣言
let alice = String::from("I like dogs");

https://doc.rust-jp.rs/rust-by-example-ja/std/str.html
// 文字列スライス
let s = String::from("hello world");

let hello = &s[0..5];
let world = &s[6..11];

https://doc.rust-jp.rs/book-ja/ch04-03-slices.html

⑰ 単語の数の指定がなく、文の終わりを認識できるキーワードもない場合の while ループ処理

https://paiza.jp/works/mondai/drankfast/d5_underline
注 問題上、^ をアンダーラインとして扱う
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){

  // 文字の長さが0になってwhile ループ処理にいきなり引っかからないよう適当なワードを入れる
  let mut sentence = String::from("blank");
  
  let mut length = 0; # ^(アンダーライン)を出力する回数の変数
  let mut count = 0; # ループ処理を繰り返した回数をカウントする変数
  
  // 文字の長さがゼロになったらループを終了 = 単語が取得できなくなったら終了
  while sentence.len() != 0 {

    sentence  = read();
    
    if count < 1 {

        print!("{}", sentence);
        length += sentence.len();

    // カウントが1以上で単語の長さがゼロでない時は アタマに半角スペースを入れて単語を出力
    // カウントが1以上になるのは文が終わった後か、2番目以降の単語を取得する時
    // 「カウントが1以上」だけでなく、「単語の長さがゼロでない時」も条件に入れることで文が終わったときは以下の処理を行わないようにする
    } else if sentence.len() != 0 && count >= 1 {

        length += sentence.len()+1; // 単語間のスペースも1文字分 ^(アンダーライン)を出力するので+1
        print!(" {}", sentence)

    }
    count = count + 1;
  }
  
  println!();
  
  // length の数だけ ^(アンダーライン)を出力
  for i in 0..length {
      print!("{}", '^');
  }
}

⑱ 式の計算

https://paiza.jp/works/mondai/drankfast/d6_calculator
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}


fn main(){

  let num_1 :u32 = read();
  let plus :String = read();
  let num_2 :u32 = read();
  
  println!("{}", num_1 + num_2);
}

⑲ 鉛筆の濃さ

https://paiza.jp/works/mondai/drankfast/d7_pencil
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  
  let pencil = &["6B", "5B", "4B", "3B", "2B", "B", "HB", "F", "H", "2H", "3H", "4H", "5H", "6H", "7H", "8H", "9H"]; // slice の指定

  let num :usize = read(); slice の index は usize で指定
  
  println!("{}", pencil[num-1])
}

スライス型の宣言

let x = &[1, 2, 3]; // アンミュータブル
又は
let x = &mut [1, 2, 3]; // ミュータブル

https://moshg.github.io/rust-std-ja/std/primitive.slice.html

⑳ 小数点以下の表示をフォーマット指定する

https://paiza.jp/works/mondai/drankfast/d8_shoes_size
解説
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let cm_size :f32 = read(); // cm 単位のサイズ
  
  let us_size = format!("{:.*}", 1, cm_size-18.0); // US サイズ。 小数点1位まで表示させる
  let uk_size = format!("{:.*}", 1, cm_size-18.5); // UK サイズ。 小数点1位まで表示させる
  
  println!("{} {}", us_size, uk_size);
}
let formatted_number = format!("{:.*}", 2, 1.234567);

(出力) 1.23

https://aonys.hatenablog.com/entry/2017/02/17/001358

㉑ 30人31脚

https://paiza.jp/works/mondai/drankfast/d9_30people31legs
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let persons :u32 = read();
  println!("{}", persons + 1);
}

㉒ for文

https://paiza.jp/works/mondai/drankfast/d10_stripe_pattern
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let times :u32 = read();

  for i in 0..times {
    println!("##########");
    println!("..........");
  }
  
}
// いずれも 1, 2, ..., 100 の範囲内で繰り返す
for n in 1..101 {
}

for n in 1..=100 {
}

https://doc.rust-jp.rs/rust-by-example-ja/flow_control/for.html

㉓ 文字列を構成する文字を1つ1つ for文で拾う

https://paiza.jp/works/mondai/drankfast/d11_vertical_writing
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let mut word :String = read();
  
  for i in 0..(word.len() as usize) {
      println!("{}", &word[i..i+1]);
  }
}

㉓ 山の英語表記

https://paiza.jp/works/mondai/drankfast/d12_mountain
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let name :String = read();
  println!("Mt. {}", name);
}

㉔ 満員電車の乗車率

https://paiza.jp/works/mondai/drankfast/d13_crowded_train
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let n_passengers :u32 = read();
  
  println!("{}%", n_passengers * 100 / 140);
}

㉔ 0から9までのカウンタ

https://paiza.jp/works/mondai/drankfast/d14_counting
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let start_num :u32 = read();
  
  for n in 0..10 {
      if n + start_num >= 10 {
          println!("{}", n + start_num-10);
      } else {
          println!("{}", n + start_num);
      }
  }
}

㉕ 四則演算の結果がプラスか、マイナスかで出力の挙動を変える

https://paiza.jp/works/mondai/drankfast/d15_temperature
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let (t1, t2) :(u32, u32) = (read(), read());

  if t1 > t2 {
    println!("-{}", t1-t2);   
  } else if t1 < t2 {
    println!("+{}", t2-t1);  
  } else {
    println!("{}", 0);
  }
}

複数の変数を同時に宣言

let (y,z): (&str,&str) = ("foxtrot","golf")

https://qiita.com/EqualL2/items/a232ab0855f145bd5997

㉖ アルファベットの穴の数

https://paiza.jp/works/mondai/drankfast/d16_alphabet_hole
解答 if文で強引に処理
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let alpabet :String = read();
  
  if alpabet == "A" || alpabet == "D" || alpabet == "O" || alpabet == "P" || alpabet == "Q" || alpabet == "R" {
      println!("{}", 1);
  } else if alpabet == "B" {
      println!("{}", 2);
  } else {
      println!("{}", 0);
  }
}
解答 matchを使う
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let alpabet :String = read();
  
  match &*alpabet {

        "B" => println!("{}", 2),

        "A" | "D" | "O" | "P" | "Q" | "R" => println!("{}", 1),

        _ => println!("{}", 0),
    }
}

論理OR

expr || expr

https://doc.rust-jp.rs/book-ja/appendix-02-operators.html

match

let number = 13;

match number {
    1 => println!("One!"),
    2 | 3 | 5 | 7 | 11 => println!("This is a prime"),
    13..=19 => println!("A teen"),
    _ => println!("Ain't special"),
}


# 文字列のパターン
let s = "foo".to_string();

match &*s {
    "foo" => println!("matched"),
    _ => println!("not matched"),
}

https://doc.rust-jp.rs/rust-by-example-ja/flow_control/match.html
https://totem3.hatenablog.jp/entry/2016/10/25/212303

㉗ 騒音レベル

https://paiza.jp/works/mondai/drankfast/d17_noise
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let decibel :u32 = read();

  match decibel {
    0..=29 => println!("quiet"),
    30..=49 => println!("normal"),
    50..=69 => println!("noisy"),
    _ => println!("very noisy"),
  }
}

備忘 下記だとエラーが出る
match decibel {
    0..=29 => println!("quiet"),
    30..=49 => println!("normal"),
    50..=70 => println!("noisy"),
    _ => println!("very noisy"),
}

error[E0658]: exclusive range pattern syntax is experimental
--> Main.rs:21:5
|
21 | 0..30 => println!("quiet"),
| ^^^^^
|
= note: see issue #37854 https://github.com/rust-lang/rust/issues/37854 for more information

https://doc.rust-jp.rs/rust-by-example-ja/flow_control/match.html

㉘ TGIF (Thank God It's Friday) 仕事や学校の長い一週間を終えて週末を迎えられることに感謝する言葉

https://paiza.jp/works/mondai/drankfast/d18_tgif
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let dayOfWeek :String = read();
  
  match &*dayOfWeek {
     "Friday" => println!("TGIF"),
     
     _ => println!("Still {}", dayOfWeek),
  }
}

㉙ 可聴領域

https://paiza.jp/works/mondai/drankfast/d19_hearing_range
パターン1解答
### if文を使う
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let num :u32 = read();
  
  if num < 20 || num > 20000 {
      println!("no");
  } else if num >= 20 && num <= 15000 {
      println!("yes");
  } else if num > 15000 && num <= 20000 {
      println!("not sure");
  }
}
パターン2解答
### match文を使う
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let num :u32 = read();
  
  match num {
     20..=15000 => println!("yes"),
     15001..=20000 => println!("not sure"),
     _ => println!("no"),
  }
}

㉚ 駄菓子の大人買い

https://paiza.jp/works/mondai/drankfast/d20_dagasi
解答
use std::io::*;
use std::str::FromStr;

// 入力を取得する関数
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main(){
  let money :f32 = read();
  
  println!("{}", (money/10.0).floor());
}

おおむねチケットなしでRustで解ける問題を解き終わったため終了。

㉛ 単純なソート

https://paiza.jp/works/mondai/sort_naive/sort_naive__insertion
解答
fn main(){

  // 入力受付
  let mut num_str = String::new();
  std::io::stdin().read_line(&mut num_str).unwrap();
  num_str.trim_end().to_owned();

  let num :i32 = num_str.trim().parse::<i32>().unwrap();
  
  // 入力受付 ベクタ
  let mut num_vec = String::new();
  std::io::stdin().read_line(&mut num_vec).unwrap();
  num_vec.trim_end().to_owned();
  num_vec = num_vec.replace("\r\n", ""); // 改行コードを削除

  // 文字列を分割して文字列のベクターに変換
  let vec_str: Vec<&str> = num_vec.split(' ').collect();
  let mut vec: Vec<i32> = Vec::new();

  // 文字列のベクターを数字のベクターに変換
  for v in vec_str {
    let n :i32 = v.trim().parse::<i32>().unwrap();
    vec.push(n);
  }
  
  // ベクタ内を探索
  for i in 1..vec.len() {

    // i番目の数値を仮の変数に保存
    let save_num :i32 = vec[i];
    
    // j番目より手前の数値をチェック
    for j in 0..i {
        if save_num < vec[j] { // チェックした数字より大きい数字かどうか判定
          vec.insert(j, save_num); // 大きい場合は、その大きい数字の左に挿入
          vec.remove(i+1); // 元の数字は削除する
          break; // 一度でも自分より大きな数字に当たったらそこで処理終了
        }
    }
    
    // ベクタの中身を出力
    for (i, v) in vec.iter().enumerate() {
      // 最初の数字以外は、半角スペース+数字を出力。最後に改行する
      if i == 0 {
        print!("{}", v); 
      } else {
        print!(" {}", v);
      }
    }
    println!("");
  }
}

https://qiita.com/Tamamu/items/6fd8f344cd9b4a20b7c2

㉜ 選択ソート

https://paiza.jp/works/mondai/sort_naive/sort_naive__selection
6/10正解、検証中
fn main(){
    
  // 入力受付
  let mut num_str = String::new();
  std::io::stdin().read_line(&mut num_str).unwrap();
  num_str.trim_end().to_owned();

  let mut num :usize = num_str.trim().parse::<usize>().unwrap();
  
  // 入力受付 ベクタ
  let mut num_vec = String::new();
  std::io::stdin().read_line(&mut num_vec).unwrap();
  num_vec.trim_end().to_owned();
  num_vec = num_vec.replace("\r\n", ""); // 改行コードを削除

  // 文字列を分割して文字列のベクターに変換
  let vec_str: Vec<&str> = num_vec.split(' ').collect();
  let mut vec: Vec<i32> = Vec::new();

  // 文字列のベクターを数字のベクターに変換
  for v in vec_str {
    let n :i32 = v.trim().parse::<i32>().unwrap();
    vec.push(n);
  }
  
  let mut min_num :isize;
  let mut min_num_index :usize = 0;
  
  for i in 0..num-1 { // num に置き換える
   
    min_num = vec[i] as isize; // 未整備値の最初の数字を暫定で最初値に入れる
   
    // 最小値を取得
    for j in i..vec.len() {
      if min_num >= vec[j] as isize {
          min_num = vec[j] as isize;
          min_num_index = j;
      }
    }
    
    vec.insert(min_num_index, vec[i]); // 探索した値を最小値のindexに挿入
    
    vec.remove(i); // 探索した値を初期ベクタから削除
    
    vec.remove(min_num_index); // 最小値を初期ベクタから削除
    vec.insert(i, min_num as i32); // 最小値を左から順番にベクタに追加
    
    // ベクタの中身を出力
    for (j, v) in vec.iter().enumerate() {
      // 最初の数字以外は、半角スペース+数字を出力。最後に改行する
      if j == 0 {
        print!("{}", v); 
      } else {
        print!(" {}", v);
      }
    }
    println!("");
  }
}

https://doc.rust-jp.rs/book-ja/ch08-01-vectors.html
https://uma0317.github.io/rust-cookbook-ja/algorithms/sorting.html
https://qiita.com/Tamamu/items/6fd8f344cd9b4a20b7c2

㉝ 指定された値の個数

https://paiza.jp/works/mondai/sequence_search_problems/sequence_search_problems_search_value_step0
解答
fn main(){

  // 入力受付 1 ベクタのサイズ 結局使ってない
  let mut num_str = String::new();
  std::io::stdin().read_line(&mut num_str).unwrap();
  num_str.trim_end().to_owned();

  let mut num :i32 = num_str.trim().parse::<i32>().unwrap();  
  
  // 入力受付 2 ベクタ
  let mut num_vec = String::new();
  std::io::stdin().read_line(&mut num_vec).unwrap();
  num_vec.trim_end().to_owned();
  num_vec = num_vec.replace("\r\n", ""); // 改行コードを削除

  // 文字列を分割して文字列のベクターに変換
  let vec_str: Vec<&str> = num_vec.split(' ').collect();
  let mut vec: Vec<i32> = Vec::new();

  // 文字列のベクターを数字のベクターに変換
  for v in vec_str {
    let n :i32 = v.trim().parse::<i32>().unwrap();
    vec.push(n);
  }

  // 入力受付 3 input
  let mut input_str = String::new();
  std::io::stdin().read_line(&mut input_str).unwrap();
  input_str.trim_end().to_owned();

  let mut input :i32 = input_str.trim().parse::<i32>().unwrap();  
  
  // 指定の数字をカウントする変数
  let mut counter :usize = 0;
  
  for v in vec.iter() {
      if v == &input {
          counter += 1;
      }
  }
  
  println!("{}", counter);
  
}

㉞二部探索

https://paiza.jp/works/mondai/binary_search/binary_search__basic_step0
正解率 7/10
// 自分の得意な言語で
// Let's チャレンジ!!
fn main(){

  // 入力受付 1 なくてもOK
  let mut num_str = String::new();
  std::io::stdin().read_line(&mut num_str).unwrap();
  num_str.trim_end().to_owned();
  let mut num :i32 = num_str.trim().parse::<i32>().unwrap();  
  
  // 入力受付 2 ベクタ
  let mut num_vec = String::new();
  std::io::stdin().read_line(&mut num_vec).unwrap();
  num_vec.trim_end().to_owned();
  num_vec = num_vec.replace("\r\n", ""); // 改行コードを削除

  // 文字列を分割して文字列のベクターに変換
  let vec_str: Vec<&str> = num_vec.split(' ').collect();
  let mut vec: Vec<isize> = Vec::new();

  // 文字列のベクターを数字のベクターに変換
  for v in vec_str {
    let n :isize = v.trim().parse::<isize>().unwrap();
    vec.push(n);
  }

  // 入力受付 3
  let mut given_nums_str = String::new();
  std::io::stdin().read_line(&mut given_nums_str).unwrap();
  given_nums_str.trim_end().to_owned();
  let mut given_nums :isize = given_nums_str.trim().parse::<isize>().unwrap();
  
  for i in 0..given_nums {
    let mut given_num_str = String::new();
    std::io::stdin().read_line(&mut given_num_str).unwrap();
    given_num_str.trim_end().to_owned();
    let mut given_num :isize = given_num_str.trim().parse::<isize>().unwrap();
    
    let mut left :usize = 0;
    let mut right :usize = (vec.len()-1);
    let mut no_hit_flag = true;
    
    if left == right && vec[0] == given_num {
        println!("Yes");
        no_hit_flag = false;
    } else if vec[left] > given_num {
        println!("No");
        no_hit_flag = false;
    } else if vec [right] < given_num {
        println!("No");
        no_hit_flag = false;
    } else {
        while right - left > 1 {
          if vec[(left+right)/2] > given_num {
            right = (left+right)/2;
            //println!("right {}", right);
          } else if vec[(left+right)/2] < given_num {
            left = (left+right)/2;
            //println!("left {}", left);
          } else {
            println!("Yes");
            no_hit_flag = false;
            break;
          }
        }
    }
    if no_hit_flag {
        println!("No");
    }
  }
}

㉟2項間漸化式 1

https://paiza.jp/works/mondai/dp_primer/dp_primer_recursive_formula_step0
解答
fn main(){
  // 入力受付 ベクタ
  let mut num_vec = String::new();
  std::io::stdin().read_line(&mut num_vec).unwrap();
  num_vec.trim_end().to_owned();
  num_vec = num_vec.replace("\r\n", ""); // 改行コードを削除

  // 文字列を分割して文字列のベクターに変換
  let vec_str: Vec<&str> = num_vec.split(' ').collect();
  let mut vec: Vec<i32> = Vec::new();

  // 文字列のベクターを数字のベクターに変換
  for v in vec_str {
    let n :i32 = v.trim().parse::<i32>().unwrap();
    vec.push(n);
  }
  
  let start :i32 = vec[0];
  
  let mut answer :i32 = start;
  
  for i in 1..vec[2] {
      answer = answer + vec[1];
  }
  
  println!("{}", answer);
}

㊲素数判定

https://paiza.jp/works/mondai/prime_number_primer/prime_number_primer__is_prime_easy
解答
fn main(){

  // 入力受付 1 なくてもOK
  let mut num_str = String::new();
  std::io::stdin().read_line(&mut num_str).unwrap();
  num_str.trim_end().to_owned();
  let mut num :usize = num_str.trim().parse::<usize>().unwrap();  
  
  let mut prime_flag :bool = true;
  
  if num == 1 {
      prime_flag = false;
  } else if num >= 3 {
      for i in 2..num {
         if num % i == 0 {
            prime_flag = false;
         }
      }
  }
  
  if prime_flag {
      println!("YES");
  } else {
      println!("NO");
  }
}

㊳計算量の多い素数判定

https://paiza.jp/works/mondai/prime_number_primer/prime_number_primer__is_prime_normal
自分の解答(解答にはなったが遅い)
fn main(){

  // 入力受付
  let mut num_str = String::new();
  std::io::stdin().read_line(&mut num_str).unwrap();
  num_str.trim_end().to_owned();
  let mut num :usize = num_str.trim().parse::<usize>().unwrap();  
  
  let mut prime_flag :bool = true;
  
  // 2 から √n まで割って余りがなければよいので、1000000で閾値をもうけ、それ以上の場合は1000(√1000000)で割った数で余りがなければよいと計算させてみた。

  if num == 1 {
      prime_flag = false;
  } else if num >= 3 {
      if num % 2 == 0 {
          prime_flag = false;
      } else if num <= 1000000 {
          for i in (3..num/3).step_by(2) {
              if num % i == 0 {
                  prime_flag = false;
                  break
              }
           }
      } else {
          for i in (3..num/1000).step_by(2) {
              if num % i == 0 {
                  prime_flag = false;
                  break
              }
          }
      }
  }
  
  if prime_flag {
      println!("YES");
  } else {
      println!("NO");
  }
}
解答見て修正したVer.
fn main(){

  // 入力受付
  let mut num_str = String::new();
  std::io::stdin().read_line(&mut num_str).unwrap();
  num_str.trim_end().to_owned();
  let mut num :usize = num_str.trim().parse::<usize>().unwrap();  

  let mut prime_flag :bool = true;
  
  if num == 1 {
      prime_flag = false;
  } else if num >= 3 {
      for i in 2..num {
          if i * i > num {
              break
          } else if num % i == 0 {
              prime_flag = false;
              break
          }
      }
  }
  
  if prime_flag {
      println!("YES");
  } else {
      println!("NO");
  }
}

https://scrapbox.io/nwtgck/Rustのrangeでステップ数(=by)を指定したいとき
https://algo-logic.info/is-prime/

㊴エラトステネスの篩(ふるい)

https://paiza.jp/works/mondai/prime_number_primer/prime_number_primer__eratosthenes
解答
fn main(){

  // 入力受付
  let mut num_str = String::new();
  std::io::stdin().read_line(&mut num_str).unwrap();
  num_str.trim_end().to_owned();
  let mut num :usize = num_str.trim().parse::<usize>().unwrap(); 

  let mut is_prime: Vec<bool> = Vec::new();
  
  for i in 0..=num {
    is_prime.push(true);
  }
  
  is_prime[0] = false;
  is_prime[1] = false;
  
  // num までの数字をチェックする
  for i in 2..=num as usize {
  
      // エラトステネスの篩の処理ですでに is_prime[num] が false になってたら以降の処理は行わない
      if is_prime[num] == false {
          break
          
      // エラトステネスの篩の処理ですでに is_prime[num] が false になっているものはパスする
      } else if is_prime[i] == false {
          continue
      }
      
      // 素数かどうか判定する
      for j in 2..i as usize {
      
          // 
          if j * j > i {
              break
          }
      
          // 素数判定場合
          if i % j == 0 {
            // フラグを素数じゃなかった場合に変更
            is_prime[i] = false;
            // 1回でも素数じゃない判定に引っかかったら終わり
            break
          }
      }
      
      // 素数だった場合
      if is_prime[i] == true {
          for j in 2..num  as usize {
              if i * j > num {
                  break
              }
              is_prime[i * j] == false;
          }
      }
  }
    
  if is_prime[is_prime.len()-1] == true {
      println!("YES");
  } else {
      println!("NO");
  }
  
}

㊵フェルマーテスト

https://paiza.jp/works/mondai/prime_number_primer/prime_number_primer__fermat_test
解答
fn main(){

  // 入力受付
  let mut N_str = String::new();
  std::io::stdin().read_line(&mut N_str).unwrap();
  N_str.trim_end().to_owned();
  let mut N :usize = N_str.trim().parse::<usize>().unwrap(); 

  let mut fermat :usize = 1;
  
  for i in 0..(N-1) {
     fermat = fermat * 2;
     fermat = fermat % N;
  }
  
  if fermat == 1 {
      println!("YES");
  } else {
      println!("NO");
  }
}

https://ja.wikipedia.org/wiki/フェルマーの小定理

㊶素数大学

https://paiza.jp/works/mondai/prime_number_primer/prime_number_primer__is_prime_multi
解答
fn main(){

  // 入力受付
  let mut times_str = String::new();
  std::io::stdin().read_line(&mut times_str).unwrap();
  times_str.trim_end().to_owned();
  let mut times :i32 = times_str.trim().parse::<i32>().unwrap(); 

  let mut vec: Vec<i32> = Vec::new();
  
  for time in 0..times {
    
    // 入力受付してベクタに格納
    let mut num_str = String::new();
    std::io::stdin().read_line(&mut num_str).unwrap();
    num_str.trim_end().to_owned();
    let mut num :i32 = num_str.trim().parse::<i32>().unwrap(); 
  
    vec.push(num);
  }

  for v in vec.iter() {
      
      let mut prime_flag :bool = true;
  
      if v <= &2 {
         prime_flag = false;
      } else if v >= &3 {
      
         for i in 2..*v {
            if i * i > *v {
                break
            } else if *v % i == 0 {
               prime_flag = false;
               break
            }
         }
      }
  
      // 素数判定
      if prime_flag {
         println!("pass");
      } else {
         println!("failure");
      }     
  }
}

㊷ゴールドバッハ予想

https://paiza.jp/works/mondai/prime_number_primer/prime_number_primer__goldbach_conjecture
解答
fn main(){

  // 入力受付
  let mut num_str = String::new();
  std::io::stdin().read_line(&mut num_str).unwrap();
  num_str.trim_end().to_owned();
  let mut num :usize = num_str.trim().parse::<usize>().unwrap();
  
  // なるべく積を大きくするため、num/2からスタートして1つずつ減らし、素数を探す
  for i in (2..=num/2).rev() {
  
    let mut prime_flag :bool = true;
    
    // i が素数か判定
    for j in 2..i {
        if j * j > i {
            break
        } else if i % j == 0 {
            prime_flag = false;
            break
        }        
    }
    if prime_flag {
        // i は素数だった
        // num - i が素数かどうか判定
        let mut prime_flag_other :bool = true;
        
        for k in 2..(num - i) {
            if k * k > (num - i) {
               break
            } else if (num - i) % k == 0 {
                prime_flag_other = false;
                break
            }
        }
        // num - i も素数だった場合、i と num - i を出力
        if prime_flag_other {
            println!("{}", i);
            println!("{}", num - i);
            break
        }
    }
  }
}

https://magidropack.hatenablog.com/entry/2018/12/25/175545

㊸中国剰余定理

https://paiza.jp/works/mondai/prime_number_primer/prime_number_primer__chinese_remainder_theorem
解答
fn main(){

  // 入力受付 2 ベクタ
  let mut num_vec = String::new();
  std::io::stdin().read_line(&mut num_vec).unwrap();
  num_vec.trim_end().to_owned();
  num_vec = num_vec.replace("\r\n", ""); // 改行コードを削除

  // 文字列を分割して文字列のベクターに変換
  let vec_str: Vec<&str> = num_vec.split(' ').collect();
  let mut vec: Vec<usize> = Vec::new();

  // 文字列のベクターを数字のベクターに変換
  for v in vec_str {
    let n :usize = v.trim().parse::<usize>().unwrap();
    vec.push(n);
  }
  
  //vec = vec![67383, 99991, 47375, 84729];

  for i in (vec[2]..(vec[0] * vec[1])).step_by(vec[0]) {
     if i % vec[0] == vec[2] {
         if i % vec[1] == vec[3] {
             println!("{}", i);
             break
         }
     }
  }
}

https://scrapbox.io/nwtgck/Rustのrangeでステップ数(=by)を指定したいとき
// Rustのrangeでステップ数を指定
for i in (0..100).step_by(5) {
}

㊹paiza問題

https://paiza.jp/works/mondai/prime_number_primer/prime_number_primer__paiza_conjecture
タイムオーバー
fn main(){

    for i in 2..=10000 { // 本来は10000
        let mut prime_flag_pair :bool = false; 
        
        for j in 2..=i*i/2 {
            
            let mut prime_flag_A :bool = true;
            let mut prime_flag_B :bool = true;
            
            // j が素数か判定
            for k in 2..j {
                if k * k > j {
                    break
                } else if j % k == 0 {
                    prime_flag_A = false;
                    break;
                }
            }
            
            // j が素数のときだけ i*i-j の判定をする
            if prime_flag_A {
                // i*i-j が素数か判定
                for k in 2..i*i-j {
                    if k * k > i*i-j {
                        break
                    } else if (i*i-j) % k == 0 {
                        prime_flag_B = false;
                        break;
                    }
                }                
            }
            
            // 満たす組み合わせがあった場合
            if prime_flag_A == true && prime_flag_B == true {
                prime_flag_pair = true;
                break;
            }
        }
        if prime_flag_pair == false {
            println!("{}", i*i);
        }
    }
}

㊺整数と文字列

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_string_step1
解答
fn main(){

  // 入力受付
  let mut times_str = String::new();
  std::io::stdin().read_line(&mut times_str).unwrap();
  times_str.trim_end().to_owned();
  let mut times :usize = times_str.trim().parse::<usize>().unwrap();  

  // 入力受付 ベクタ
  let mut vec: Vec<usize> = Vec::new();

  // ベクタに入力受付した数値を保存
  for t in 0..times {
  
    let mut num_str = String::new();
    std::io::stdin().read_line(&mut num_str).unwrap();
    num_str.trim_end().to_owned();
    let mut num :usize = num_str.trim().parse::<usize>().unwrap();
  
    vec.push(num);
  }

  // ベクタの内訳(数値)を文字列に変換し、その長さを出力
  for v in vec.iter() {
      println!("{}", v.to_string().len());
  }
}

https://qiita.com/smicle/items/29a4d5d1d14ad7f77f60

㊻部分文字列

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_string_step2
解答
fn main(){

  // 入力受付
  let mut character = String::new();
  std::io::stdin().read_line(&mut character);
  let character = character.trim();

  // 入力受付
  let mut sentence = String::new();
  std::io::stdin().read_line(&mut sentence);
  let sentence = sentence.trim();
  
  let mut included_flag = false;

  for s in sentence.chars(){
      if s.to_string() == character {
          included_flag = true;
          break;
      }
  }
  
  if included_flag {
      println!("YES");
  } else {
      println!("NO");
  }
}

https://magidropack.hatenablog.com/entry/2018/12/18/194442
https://zenn.dev/megane_otoko/articles/059_rust_for_string

㊼数字の文字列操作

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_string_step3
解答
fn main(){

  // 入力受付
  let mut numbers = String::new();
  std::io::stdin().read_line(&mut numbers);
  let numbers = numbers.trim();

  let mut tenth_place :i32 = 0; // 十の位
  let mut first_place :i32 = 0; // 一の位

  for (i, n) in numbers.chars().enumerate() {
  
      // 数値に変換
      let number: i32 = n.to_string().parse().unwrap();
      
      // 0番目、3番目の数値を十の位に加算
      // 1番目、2番目の数値を一の位に加算
      if i == 0 || i == 3 {
          tenth_place += number;
      } else if i == 1 || i == 2 {
          first_place += number;
      }
  }
  println!("{}{}", tenth_place, first_place);
}

https://qiita.com/smicle/items/29a4d5d1d14ad7f77f60
https://webbibouroku.com/Blog/Article/rust-iter-index

㊾数字の文字列操作

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_string_step5
解答
fn main(){

  // 入力受付
  let mut timesOfDay = String::new();
  std::io::stdin().read_line(&mut timesOfDay);
  let timesOfDay = timesOfDay.trim();
  
  let vec: Vec<&str> = timesOfDay.split(':').collect();

  for v in vec.iter() {
      
      // 数値に変換
      let v_num: i32 = v.to_string().parse().unwrap();
      
      println!("{}", v_num);
  }
}

https://qiita.com/hobo0xcc/items/04846eeccb5e2004731a

㊿数字の文字列操作

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_string_step6
解答(コードが汚い)
fn main(){

  // 入力受付
  let mut timesOfDay = String::new();
  std::io::stdin().read_line(&mut timesOfDay);
  let timesOfDay = timesOfDay.trim();
  
  let vec: Vec<&str> = timesOfDay.split(':').collect();

  let hours: i32 = vec[0].to_string().parse().unwrap();
  let minutes: i32 = vec[1].to_string().parse().unwrap();

  if minutes >= 40 {
     if hours >= 9 {
        print!("{}:{}", hours + 1, minutes -30);
     } else {
        print!("0{}:{}", hours + 1, minutes -30);
     }
  } else if minutes >= 30 {
     if hours >= 9 {
        print!("{}:0{}", hours + 1, minutes -30);
     } else {
        print!("0{}:0{}", hours + 1, minutes -30);
     }
  } else {
     if hours >= 10 {
        print!("{}:{}", hours, minutes + 30);
     } else {
        print!("0{}:{}", hours, minutes + 30);
     }
  }
}

51 文字列の中に特定の文字が含まれるか判定

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_for_step4
解答
fn main(){

  // 入力受付 A
  let mut num_A_str = String::new();
  std::io::stdin().read_line(&mut num_A_str).unwrap();
  num_A_str.trim_end().to_owned();
  let mut num_A :usize = num_A_str.trim().parse::<usize>().unwrap();
  
  // ベクタ
  let mut vec_A: Vec<String> = Vec::new();

  // 文字列のベクターを数字のベクターに変換
  for i in 0..num_A {
  
    let mut word = String::new();
    std::io::stdin().read_line(&mut word).unwrap();
    word = word.replace("\n", ""); // 改行コードを削除
    
    vec_A.push(word);
  }
  
  
  // 入力受付 B
  let mut num_B_str = String::new();
  std::io::stdin().read_line(&mut num_B_str).unwrap();
  num_B_str.trim_end().to_owned();
  let mut num_B :usize = num_B_str.trim().parse::<usize>().unwrap();
  
  // ベクタ
  let mut vec_B: Vec<String> = Vec::new();

  // 文字列のベクターを数字のベクターに変換
  for i in 0..num_B {
  
    let mut word = String::new();
    std::io::stdin().read_line(&mut word).unwrap();
    word = word.replace("\n", ""); // 改行コードを削除
    
    vec_B.push(word);
  }
  
  for v_a in vec_A.iter() {
      for v_b in vec_B.iter() {

          // String を char の ベクタに変換
          let v_a_char: Vec<char> = v_a.chars().collect();
          
          if v_b.contains(v_a_char[0]) {
              println!("YES");
          } else {
              println!("NO");
          }
      }
  } 
}

https://qiita.com/kujirahand/items/fcb4f75dbdbfaf36aa75
https://keens.github.io/blog/2019/10/06/rustde_mojigatokuteinomojishuugounifukumareruka_wohanteisurunohadoregahayaika/

51 昇順ソート

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_sort_step1
解答
fn main(){

  // 入力受付
  let mut times_str = String::new();
  std::io::stdin().read_line(&mut times_str).unwrap();
  times_str.trim_end().to_owned();
  let mut times :usize = times_str.trim().parse::<usize>().unwrap();
  
  // ベクタ
  let mut vec: Vec<usize> = Vec::new();

  // 文字列のベクターを数字のベクターに変換
  for i in 0..times {
  
    let mut num_str = String::new();
    std::io::stdin().read_line(&mut num_str).unwrap();
    num_str.trim_end().to_owned();
    let mut num :usize = num_str.trim().parse::<usize>().unwrap();

    //word = word.replace("\n", ""); // 改行コードを削除
    
    vec.push(num);
  }

  vec.sort();

  for v in vec.iter() {
     println!("{}", v);
  }
}

https://uma0317.github.io/rust-cookbook-ja/algorithms/sorting.html

52 降順ソート

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_sort_step2
解答
fn main(){

  // 入力受付
  let mut times_str = String::new();
  std::io::stdin().read_line(&mut times_str).unwrap();
  times_str.trim_end().to_owned();
  let mut times :usize = times_str.trim().parse::<usize>().unwrap();
  
  // ベクタ
  let mut vec: Vec<usize> = Vec::new();

  // 文字列のベクターを数字のベクターに変換
  for i in 0..times {
  
    let mut num_str = String::new();
    std::io::stdin().read_line(&mut num_str).unwrap();
    num_str.trim_end().to_owned();
    let mut num :usize = num_str.trim().parse::<usize>().unwrap();

    //word = word.replace("\n", ""); // 改行コードを削除
    
    vec.push(num);
  }

  vec.sort();
  vec.reverse();

  for v in vec.iter() {
     println!("{}", v);
  }
}

https://zenn.dev/toga/books/rust-atcoder/viewer/21-slice#reverse-関数

53 辞書式ソート

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_sort_step3
解答
fn main(){

  // 入力受付
  let mut times_str = String::new();
  std::io::stdin().read_line(&mut times_str).unwrap();
  times_str.trim_end().to_owned();
  let mut times :usize = times_str.trim().parse::<usize>().unwrap();

  let mut vecs = Vec::new();
  
  for i in 0..times {

      let mut vec_child = Vec::new();
      
      // 入力受付 リンゴとバナナのペア
      let mut pair_str = String::new();
      std::io::stdin().read_line(&mut pair_str).unwrap();
      pair_str = pair_str.trim_end().to_owned();
      
      let mut vec_str: Vec<&str> = pair_str.split(' ').collect();
      
      for v in vec_str.iter() {
          let num: i32 = v.parse().unwrap();
          vec_child.push(num);
      }
      
      vecs.push(vec_child);
  }
  
  // ソート ✖ 2
  for i in 0..vecs.len() {
      for j in 0..vecs.len(){
          // リンゴで降順にソート
          if vecs[i][0] > vecs[j][0]{
              vecs.swap(i, j);
              
              // リンゴの数字が同じときはバナナの数字で降順にソート
          } else if vecs[i][0] == vecs[j][0] {
              if vecs[i][1] > vecs[j][1] {
                  vecs.swap(i, j);    
              }
          }
      }
  }
      
  // ベクタの中身を出力
  for vec in vecs.iter() {
      for (i, v) in vec.iter().enumerate() {
          if i == 0 {
              print!("{}", v);
          } else {
              println!(" {}", v);
          }
      }
  }
}

http://blog.livedoor.jp/itukano/archives/52127174.html

54 ソート

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_sort_boss
解答
fn main(){

  // 入力受付
  let mut num_str = String::new();
  std::io::stdin().read_line(&mut num_str);
  let mut num :usize = num_str.trim().parse::<usize>().unwrap();

  let mut vecs = Vec::new();

  for i in 0..num {
  
      // 入力受付
      let mut vec_str = String::new();
      std::io::stdin().read_line(&mut vec_str);
      let vec_str = vec_str.trim();
  
      let vec_str: Vec<&str> = vec_str.split(' ').collect();
  
      let mut vec: Vec<i32> = Vec::new();
      
      for v in vec_str.iter(){
      
         let num: i32 = v.parse().unwrap();
         vec.push(num);
      }
      vecs.push(vec);
  }
  
  // ソート
  for i in 0..vecs.len() {
      for j in 0..vecs.len(){
          // 銀の量で降順にソート
          if vecs[i][1] > vecs[j][1]{
              vecs.swap(i, j);
              
          // 銀の数字が同じときは金の数字で降順にソート
          } else if vecs[i][1] == vecs[j][1] {
              if vecs[i][0] > vecs[j][0] {
                  vecs.swap(i, j);    
              }
          }
      }
  }
  
  for vec in vecs.iter(){
      for (i, v) in vec.iter().enumerate(){
          if i == 0 {
            print!("{} ", v);
          } else {
            println!("{}", v);
          }
      }
  }
}

55 辞書型データの四則演算

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_dictionary_step2
解答(改善の余地多し)
use std::collections::HashMap;
fn main(){
  // 入力受付
  let mut num_person_str = String::new();
  std::io::stdin().read_line(&mut num_person_str);
  let num_person :usize = num_person_str.trim().parse::<usize>().unwrap();
  // ハッシュマップの宣言
  let mut dict = HashMap::new();
  for _i in 0..num_person {
    // 入力受付
    let mut name = String::new();
    std::io::stdin().read_line(&mut name);
    name = name.replace("\n", "");
    dict.insert(
        name.to_string(),
        0,
    );
  }
  // 入力受付
  let mut times_str = String::new();
  std::io::stdin().read_line(&mut times_str);
  let times :usize = times_str.trim().parse::<usize>().unwrap();
  for _i in 0..times {
    // 入力受付
    let mut data = String::new();
    std::io::stdin().read_line(&mut data);
    data = data.replace("\n", "");
    let vec: Vec<&str> = data.split(' ').collect();

    let count = dict.entry(vec[0].to_string()).or_insert(0);
    
    let v_num: i32 = vec[1].parse().unwrap();
    *count += v_num;
    
  }
  
  // 入力受付
  let mut answer_name = String::new();
  std::io::stdin().read_line(&mut answer_name);
  answer_name = answer_name.replace("\n", "");
  
  println!("{}", dict[&answer_name]);
}

https://euniclus.com/article/rust_string_function/
https://webbibouroku.com/Blog/Article/rust-iter-index
https://qiita.com/hobo0xcc/items/04846eeccb5e2004731a
https://qiita.com/smicle/items/29a4d5d1d14ad7f77f60
https://doc.rust-lang.org/std/collections/struct.HashMap.html

HashMapの四則演算

use std::collections::HashMap;

func main() {
   let text = "hello world wonderful world";
   let mut map = HashMap::new();

   for word in text.split_whitespace() {
       // ここで加算するkeyを変数に格納してポインタを使うのがコツ?
       let count = map.entry(word).or_insert(0);
       *count += 1;
   }

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

出力 {"world": 2, "hello": 1, "wonderful": 1}

https://doc.rust-jp.rs/book-ja/ch08-03-hash-maps.html

56 辞書データの順序

https://paiza.jp/works/mondai/c_rank_level_up_problems/c_rank_dictionary_step3
解答
use std::collections::HashMap;

fn main(){
  // 入力受付
  let mut num_person_str = String::new();
  std::io::stdin().read_line(&mut num_person_str);
  let num_person :usize = num_person_str.trim().parse::<usize>().unwrap();

  // ハッシュマップの宣言
  let mut dict = HashMap::new();
  for _i in 0..num_person {

    // 入力受付
    let mut name = String::new();
    std::io::stdin().read_line(&mut name);
    name = name.replace("\n", "");
    dict.insert(
        name.to_string(),
        0,
    );
  }

  // 入力受付
  let mut times_str = String::new();
  std::io::stdin().read_line(&mut times_str);
  let times :usize = times_str.trim().parse::<usize>().unwrap();
  for _i in 0..times {

    // 入力受付
    let mut data = String::new();
    std::io::stdin().read_line(&mut data);
    data = data.replace("\n", "");

    let vec: Vec<&str> = data.split(' ').collect();

    let count = dict.entry(vec[0].to_string()).or_insert(0);
    let v_num: i32 = vec[1].parse().unwrap();
    *count += v_num;
  }

  let mut dict_vec: Vec<_> = dict.into_iter().collect();
  dict_vec.sort();

  for v in dict_vec.iter() {
      println!("{:?}", v.1);
  }
}

https://www.suzu6.net/posts/288-rust-hash-map/#値の大きい順にソートする
このスクラップは13日前にクローズされました
作成者以外のコメントは許可されていません