N 찍기

입출력을 빠르게 해야 TLE를 받지 않을 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
use std::io::{self, Read, Write};

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let mut it = input.split_whitespace();

    let mut out = io::BufWriter::new(io::stdout());

    let n: i32 = it.next().unwrap().parse().unwrap();
    for i in 1..=n {
        writeln!(out, "{i}").unwrap();
    }
}

팩토리얼

여러 방식의 코드 첨부합니다.
순서대로 반복문, 함수, 재귀함수입니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
use std::io::{self, Read};

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let mut it = input.split_whitespace();

    let n: i32 = it.next().unwrap().parse().unwrap();

    let mut factorial: i32 = 1;
    for i in 1..=n {
        factorial *= i;
    }
    println!("{factorial}");
}

or

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
use std::io::{self, Read};

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let mut it = input.split_whitespace();

    let n: i32 = it.next().unwrap().parse().unwrap();

    let factorial: i32 = (1..=n).product();
    println!("{factorial}");
}

or

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
use std::io::{self, Read};

fn factorial(n: u32) -> u32 {
    match n {
        0 => 1,
        _ => n * factorial(n - 1),
    }
}

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let mut it = input.split_whitespace();

    let n: u32 = it.next().unwrap().parse().unwrap();

    println!("{}", factorial(n));
}

A+B - 3

t번 반복합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
use std::io::{self, Read};

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let mut it = input.split_whitespace();

    let t: usize = it.next().unwrap().parse().unwrap();
    for _ in 0..t {
        let a: u8 = it.next().unwrap().parse().unwrap();
        let b: u8 = it.next().unwrap().parse().unwrap();

        println!("{}", a + b);
    }
}

A+B - 5

두 값이 모두 0일 때까지 loop로 반복합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
use std::io::{self, Read};

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let mut it = input.split_whitespace();

    loop {
        let a: u8 = it.next().unwrap().parse().unwrap();
        let b: u8 = it.next().unwrap().parse().unwrap();
        if a == 0 && b == 0 {
            break;
        }
        println!("{}", a + b);
    }
}

구구단

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
use std::io::{self, Read};

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let mut it = input.split_whitespace();

    let n: u8 = it.next().unwrap().parse().unwrap();
    for i in 1..=9 {
        println!("{} * {} = {}", n, i, n * i);
    }
}

별 찍기 - 1

repeat로 문자를 반복한 것을 볼 수 있습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
use std::io::{self, Read};

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let mut it = input.split_whitespace();

    let n: usize = it.next().unwrap().parse().unwrap();
    for i in 1..=n {
        println!("{}", "*".repeat(i));
    }
}

A+B - 4

읽을 게 없을 때까지 반복해야 합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
use std::io::{self, Read};

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let mut it = input.split_whitespace();

    while let (Some(a), Some(b)) = (it.next(), it.next()) {
        let a: u8 = a.parse().unwrap();
        let b: u8 = b.parse().unwrap();
        println!("{}", a + b);
    }
}