코딩테스트 기초
코딩테스트 기초 테스트의 출처는 https://school.programmers.co.kr 입니다.
1 Day1 출력
1.1 문자열 출력하기
문자열 str 이 주어질 때, str 을 출력하는 코드를 작성해 보세요.
1.1.1 파이썬
str: str = input()
print(str)1.1.2 러스트
use std::io;
fn main() {
let mut s = String::new();
io::stdin().read_line(&mut s).unwrap();
println!("{}", s.trim());
}1.2 a 와 b 출력하기
정수 a 와 b 가 주어집니다. 각 수를 입력받아 출력하는 코드를 작성해 보세요.
1.2.1 파이썬
a, b = map(int, input().strip().split(" "))
print(f"a = {a}")
print(f"b = {b}")1.2.2 러스트
use std::io;
fn main() {
let mut input = String::new();
io::stdin().read_line(&mut input).expect("Failed to read line");
let numbers: Vec<i32> = input
.trim()
.split_whitespace()
.map(|s| s.parse().expect("Parse error"))
.collect();
let a = numbers[0];
let b = numbers[1];
println!("a = {}", a);
println!("b = {}", b);
}1.3 문자열 반복해서 출력하기
문자열 str 과 정수 n 이 주어집니다. str 이 n 번 반복된 문자열을 만들어 출력하는 코드를 작성해 보세요.
1.3.1 파이썬
str, n = input().strip().split("")
n = int(n)
print(str*n)1.3.2 러스트
use std::io;
fn main() {
let mut input = String::new();
io::stdin().read_line(&mut input).expect("Failed to read line");
let parts: Vec<&str> = input.trim().split_whitespace().collect();
if parts.len() != 2 {
println!("Invalid input format");
return;
}
let str_part = parts[0];
let n: usize = parts[1].parse().expect("Failed to parse number");
println!("{}", str_part.repeat(n));
}1.4 대소문자 바꿔서 출력하기
영어 알파벳으로 이루어진 문자열 str 이 주어집니다. 각 알파벳을 대문자는 소문자로 소문자는 대문자로 변환해서 출력하는 코드를 작성해 보세요.
1.4.1 파이썬
str = input()
print(str.swapcase())1.4.2 러스트
use std::io::{self, BufRead};
fn main() {
let mut input = String::new();
io::stdin().lock().read_line(&mut input).unwrap();
let swapped = input.chars().map(|c| {
if c.is_uppercase() {
c.to_lowercase().next().unwrap()
} else if c.is_lowercase() {
c.to_uppercase().next().unwrap()
} else {
c
}
}).collect::<String>();
print!("{}", swapped);
}1.5 특수문자 출력하기
!@#$%^&*(\'"<>?:; 과 같이 출력하도록 코드를 작성해 주세요.
1.5.1 파이썬
print("!@#$%^&*(\\'\"<>?:;")1.5.2 러스트
fn main() {
println!("!@#$%^&*(\\'\"<>?:;");
}2 Day2 출력, 연산
2.1 덧셈식 출력하기
두 정수 a, b 가 주어질 때 계산식을 출력하는 코드를 작성해 보세요.
2.1.1 파이썬
a, b = map(int, input().strip().split(" "))
print(f"{a} + {b} = {a + b}")2.1.2 러스트
use std::io;
fn main() {
let mut input = String::new();
io::stdin().read_line(&mut input).expect("Failed to read line");
let numbers: Vec<i32> = input
.trim()
.split_whitespace()
.map(|s| s.parse().expect("Parse error"))
.collect();
if numbers.len() != 2 {
println!("Invalid input: expected two numbers");
return;
}
let a = numbers[0];
let b = numbers[1];
println!("{} + {} = {}", a, b, a + b);
}2.2 문자열 붙여서 출력하기
두 개의 문자열 str1, str2 가 공백으로 구분되어 입력으로 주어집니다. str1 과 str2 을 이어서 출력하는 코드를 작성해 보세요.
2.2.1 파이썬
str1, str2 = input().strip().split()
print(f"{str1}{str2}")2.2.2 러스트
use std::io;
fn main() {
let mut input = String::new();
io::stdin().read_line(&mut input).expect("Failed to read line");
let parts: Vec<&str> = input.trim().split_whitespace().collect();
if parts.len() != 2 {
println!("Invalid input: expected two strings");
return;
}
let str1 = parts[0];
let str2 = parts[1];
println!("{}{}", str1, str2);
}2.3 문자열 돌리기
문자열 str 이 주어집니다. 문자열을 시계방향으로 90 도 돌려서 출력하는 코드를 작성해 보세요.
2.3.1 파이썬
str: str = input()
for i in str:
print(i)2.3.2 러스트
use std::io::{self, BufRead};
fn main() {
let stdin = io::stdin();
let input = stdin.lock().lines().next().unwrap().unwrap();
for c in input.chars() {
println!("{}", c);
}
}2.4 홀짝 구분하기
자연수 n 이 입력으로 주어졌을 때 만약 n 이 짝수이면 “n is even”을, 홀수이면 “n is odd”를 출력하는 코드를 작성해 보세요.
2.4.1 파이썬
a: int = int(input())
if a % 2 == 0:
print(f"{a} is even")
else:
print(f"{a} is odd")2.4.2 러스트
use std::io;
fn main() {
let mut input = String::new();
io::stdin().read_line(&mut input).expect("Failed to read line");
let a: i32 = input.trim().parse().expect("Please enter a valid integer");
if a % 2 == 0 {
println!("{} is even", a);
} else {
println!("{} is odd", a);
}
}2.5 문자열 겹쳐쓰기
문자열 my_string, overwrite_string 과 정수 s 가 주어집니다. 문자열 my_string 의 인덱스 s 부터 overwrite_string 의 길이만큼을 문자열 overwrite_string 으로 바꾼 문자열을 return 하는 solution 함수를 작성해 주세요.
2.5.1 파이썬
def solution(my_string: str, overwrite_string: str, s: int) -> str:
prefix = my_string[:s]
middle = overwrite_string
suffix = my_string[s + len(overwrite_string):]
return prefix + middle + suffix2.5.2 러스트
fn solution(my_string: &str, overwrite_string: &str, s: usize) -> String {
let prefix = &my_string[..s];
let middle = overwrite_string;
let suffix = &my_string[s + overwrite_string.len()..];
format!("{}{}{}", prefix, middle, suffix)
}
fn main() {
// Example usage
let result = solution("Hello World", "Rust", 6);
println!("{}", result);
}3 Day3 연산
3.1 문자열 섞기
길이가 같은 두 문자열 str1 과 str2 가 주어집니다. 두 문자열의 각 문자가 앞에서부터 서로 번갈아가면서 한 번씩 등장하는 문자열을 만들어 return 하는 solution 함수를 완성해 주세요
3.1.1 파이썬
def solution(str1: str, str2: str) -> str:
answer: str = ''
for i in range(len(str1)):
answer += str1[i] + str2[i]
return answer3.1.2 러스트
fn solution(str1: &str, str2: &str) -> String {
let mut answer = String::new();
for (c1, c2) in str1.chars().zip(str2.chars()) {
answer.push(c1);
answer.push(c2);
}
answer
}
fn main() {
// Example usage
let result = solution("abc", "def");
println!("{}", result);
}3.2 문자 리스트를 문자열로 변환하기
문자들이 담겨있는 배열 arr 가 주어집니다. arr 의 원소들을 순서대로 이어 붙인 문자열을 return 하는 solution 함수를 작성해 주세요.
3.2.1 파이썬
from typing import List
def solution(arr: List[str]) -> str:
return ''.join(arr)3.2.2 러스트
fn solution(arr: &[String]) -> String {
arr.join("")
}
fn main() {
// Example usage
let arr = vec![
String::from("Hello"),
String::from(" "),
String::from("World"),
];
let result = solution(&arr);
println!("{}", result);
}3.3 문자열 곱하기
문자열 my_string 과 정수 k 가 주어질 때, my_string 을 k 번 반복한 문자열을 return 하는 solution 함수를 작성해 주세요.
3.3.1 파이썬
def solution(my_string: str, k: int) -> str:
return my_string*k3.3.2 러스트
fn solution(my_string: &str, k: usize) -> String {
my_string.repeat(k)
}
fn main() {
// Example usage
let result = solution("Hello", 3);
println!("{}", result);
}3.4 더 크게 합치기
연산 \(⊕\) 는 두 정수에 대한 연산으로 두 정수를 붙여서 쓴 값을 반환합니다. 예를 들면 다음과 같습니다. \(12 ⊕ 3 = 123\), \(3 ⊕ 12 = 312\) . 양의 정수 a 와 b 가 주어졌을 때, \(a⊕b\) 와 \(b⊕a\) 중 더 큰 값을 return 하는 solution 함수를 완성해 주세요. 단, \(a⊕b\) 와 \(b⊕a\) 가 같다면 \(a⊕b\) 를 return 합니다.
3.4.1 파이썬
def solution(a: int, b: int) -> int:
ab = int(str(a) + str(b))
ba = int(str(b) + str(a))
return max(ab, ba)3.4.2 러스트
fn solution(a: i32, b: i32) -> i32 {
let ab = format!("{}{}", a, b).parse::<i32>().unwrap();
let ba = format!("{}{}", b, a).parse::<i32>().unwrap();
ab.max(ba)
}
fn main() {
// Example usage
let result = solution(12, 34);
println!("{}", result);
}3.5 두 수의 연산값 비교하기
연산 \(⊕\) 는 두 정수에 대한 연산으로 두 정수를 붙여서 쓴 값을 반환합니다. 예를 들면 다음과 같습니다. \(12⊕3=123\), \(3⊕12=312\) 양의 정수 a 와 b 가 주어졌을 때, \(a⊕b\) 와 \(2*a*b\) 중 더 큰 값을 return 하는 solution 함수를 완성해 주세요. 단, \(a⊕b\) 와 \(2*a*b\) 가 같으면 \(a⊕b\) 를 return 합니다.
3.5.1 파이썬
def solution(a: int, b: int) -> int:
concat_op = int(str(a) + str(b))
multiply_op = 2 * a * b
return max(concat_op, multiply_op)3.5.2 러스트
fn solution(a: i32, b: i32) -> i32 {
let concat_op = format!("{}{}", a, b).parse::<i32>().unwrap();
let multiply_op = 2 * a * b;
concat_op.max(multiply_op)
}
fn main() {
// Example usage
let result = solution(2, 91);
println!("{}", result);
}4 Day 4 연산, 조건문
4.1 n 의 배수
정수 num 과 n 이 매개 변수로 주어질 때, num 이 n 의 배수이면 1 을 return n 의 배수가 아니라면 0 을 return 하도록 solution 함수를 완성해주세요.
4.1.1 파이썬
def solution(num: int, n: int) -> int:
if num % n == 0:
return 1
else:
return 04.1.2 러스트
fn solution(num: i32, n: i32) -> i32 {
if num % n == 0 {
1
} else {
0
}
}
fn main() {
let num = 10;
let n = 2;
let result = solution(num, n);
println!("Result for num={} and n={}: {}", num, n, result);
}4.2 공배수
정수 number 와 n, m 이 주어집니다. number 가 n 의 배수이면서 m 의 배수이면 1 을 아니라면 0 을 return 하도록 solution 함수를 완성해주세요.
4.2.1 파이썬
def solution(number: int, n: int, m:int) -> int:
if number % n == 0 and number % m == 0:
return 1
else:
return 04.2.2 러스트
fn solution(number: i32, n: i32, m: i32) -> i32 {
if number % n == 0 && number % m == 0 {
1
} else {
0
}
}
fn main() {
let result1 = solution(12, 3, 4);
println!("Result 1: {}", result1);
}4.3 홀짝에 따른 다른 값 반환하기
양의 정수 n 이 매개변수로 주어질 때, n 이 홀수라면 n 이하의 홀수인 모든 양의 정수의 합을 return 하고 n 이 짝수라면 n 이하의 짝수인 모든 양의 정수의 제곱의 합을 return 하는 solution 함수를 작성해 주세요.
4.3.1 파이썬
def solution(n:int) -> int:
if n % 2 == 1: # n이 홀수인 경우
return sum(range(1, n+1, 2))
else: # n이 짝수인 경우
return sum(i**2 for i in range(2, n+1, 2))4.3.2 러스트
fn solution(n: i32) -> i32 {
if n % 2 == 1 {
// If `n` is odd, sum all odd numbers from 1 to `n`
(1..=n).step_by(2).sum()
} else {
// If `n` is even, sum the squares of all even numbers from 2 to `n`
(2..=n).step_by(2).map(|i| i * i).sum()
}
}
fn main() {
let result1 = solution(7); // Example with an odd number
println!("Result 1: {}", result1);
}4.4 조건 문자열
문자열에 따라 다음과 같이 두 수의 크기를 비교하려고 합니다.
- 두 수가
n과m이라면- “>”, “=” :
n>=m - “<”, “=” :
n<=m - “>”, “!” :
n>m - “<”, “!” :
n<m
- “>”, “=” :
두 문자열 ineq 와 eq 가 주어집니다. ineq 는 “<”와 “>”중 하나고, eq 는 “=”와 “!”중 하나입니다. 그리고 두 정수 n 과 m 이 주어질 때, n 과 m 이 ineq 와 eq 의 조건에 맞으면 1 을 아니면 0 을 return 하도록 solution 함수를 완성해주세요.
4.4.1 파이썬
def solution(ineq:str, eq:str, n:int, m:int) -> int:
if ineq == ">" and eq == "=":
return 1 if n >= m else 0
elif ineq == "<" and eq == "=":
return 1 if n <= m else 0
elif ineq == ">" and eq == "!":
return 1 if n > m else 0
elif ineq == "<" and eq == "!":
return 1 if n < m else 04.4.2 러스트
fn solution(ineq: char, eq: char, n: i32, m: i32) -> i32 {
match (ineq, eq) {
('>', '=') => if n >= m { 1 } else { 0 },
('<', '=') => if n <= m { 1 } else { 0 },
('>', '!') => if n > m { 1 } else { 0 },
('<', '!') => if n < m { 1 } else { 0 },
_ => panic!("Invalid input combination"),
}
}
fn main() {
println!("Result 1: {}", solution('>', '=', 20, 15));
println!("Result 2: {}", solution('<', '=', 10, 20));4.5 flag 에 따라 다른 값 반환하기
두 정수 a, b 와 boolean 변수 flag 가 매개변수로 주어질 때, flag 가 true 면 a + b 를 false 면 a - b 를 return 하는 solution 함수를 작성해 주세요.
4.5.1 파이썬
def solution(a: int, b:int, flag:bool) -> int:
return a + b if flag else a - b4.5.2 러스트
fn solution(a: i32, b: i32, flag: bool) -> i32 {
if flag {
a + b
} else {
a - b
}
}
fn main() {
println!("Result 1: {}", solution(5, 3, true));
println!("Result 2: {}", solution(10, 7, false));
}5 Day 5 조건문
5.1 코드 처리하기
문자열 code 가 주어집니다. code 를 앞에서부터 읽으면서 만약 문자가 “1”이면 mode 를 바꿉니다. mode 에 따라 code 를 읽어가면서 문자열 ret 을 만들어냅니다. mode 는 0 과 1 이 있으며, idx 를 0 부터 code의 길이 - 1 까지 1 씩 키워나가면서 code[idx] 의 값에 따라 다음과 같이 행동합니다.
mode가 0 일 때code[idx]가 “1”이 아니면idx가 짝수일 때만ret의 맨 뒤에code[idx]를 추가합니다.code[idx]가 “1”이면mode를 0 에서 1 로 바꿉니다.
mode가 1 일 때code[idx]가 “1”이 아니면idx가 홀수일 때만ret의 맨 뒤에code[idx]를 추가합니다.code[idx]가 “1”이면mode를 1 에서 0 으로 바꿉니다.
문자열 code 를 통해 만들어진 문자열 ret 를 return 하는 solution 함수를 완성해 주세요.
단, 시작할 때 mode 는 0 이며, return 하려는 ret 가 만약 빈 문자열이라면 대신 “EMPTY”를 return 합니다.
5.1.1 파이썬
def solution(code: str) -> str:
ret = ''
mode = 0 # 시작할 때 mode는 0입니다.
for idx, char in enumerate(code):
if char == '1':
mode = 1 - mode # mode를 전환합니다.
else:
if (mode == 0 and idx % 2 == 0) or (mode == 1 and idx % 2 == 1):
ret += char
if ret == '':
return 'EMPTY'
return ret5.1.2 러스트
fn solution(code: &str) -> String {
let mut ret = String::new();
let mut mode = 0; // Start with mode 0
for (idx, char) in code.chars().enumerate() {
if char == '1' {
mode = 1 - mode; // Toggle the mode
} else {
if (mode == 0 && idx % 2 == 0) || (mode == 1 && idx % 2 == 1) {
ret.push(char);
}
}
}
if ret.is_empty() {
"EMPTY".to_string()
} else {
ret
}
}
fn main() {
println!("Result 1: {}", solution("012345"));
println!("Result 2: {}", solution("1101010"));
}5.2 등차수열의 특정한 항만 더하기
두 정수 a, d 와 길이가 n 인 boolean 배열 included 가 주어집니다. 첫째항이 a, 공차가 d 인 등차수열에서 included[i] 가 i + 1 항을 의미할 때, 이 등차수열의 1 항부터 n 항까지 included 가 true 인 항들만 더한 값을 return 하는 solution 함수를 작성해 주세요.
5.2.1 파이썬
from typing import List
def solution(a:int, d:int, included: List[bool]) -> int:
answer = 0
for i in range(len(included)):
if included[i]:
# (i+1)번째 항 계산
term = a + i * d
answer += term
return answer5.2.2 러스트
fn solution(a: i32, d: i32, included: Vec<bool>) -> i32 {
let mut answer = 0;
for (i, &is_included) in included.iter().enumerate() {
if is_included {
// Calculate the (i+1)th term
let term = a + (i as i32) * d;
answer += term;
}
}
answer
}
fn main() {
let result1 = solution(3, 4, vec![true, false, false, true, true]);
println!("Result 1: {}", result1);
}6 Day 6 조건문, 반복문
6.1 마지막 두 원소
정수 리스트 num_list가 주어질 때, 마지막 원소가 그전 원소보다 크면 마지막 원소에서 그전 원소를 뺀 값을 마지막 원소가 그전 원소보다 크지 않다면 마지막 원소를 두 배한 값을 추가하여 return하도록 solution 함수를 완성해주세요.
6.1.1 파이썬
from typing import List
def solution(num_list: List[int]) -> List[int]:
# 마지막 원소와 그 전 원소 추출
last = num_list[-1]
second_last = num_list[-2]
# 결과 리스트를 복사하여 추가할 값 결정
result = num_list.copy()
if last > second_last:
# 마지막 원소가 그 전 원소보다 크면 차를 추가
result.append(last - second_last)
else:
# 그렇지 않으면 마지막 원소의 두 배를 추가
result.append(last * 2)
return result6.1.2 러스트
6.2 수 조작하기 1
정수 n과 문자열 control이 주어집니다. control은 “w”, “a”, “s”, “d”의 4개의 문자로 이루어져 있으며, control의 앞에서부터 순서대로 문자에 따라 n의 값을 바꿉니다.
- “w” :
n이 1 커집니다. - “s” :
n이 1 작아집니다. - “d” :
n이 10 커집니다. - “a” :
n이 10 작아집니다.
위 규칙에 따라 n을 바꿨을 때 가장 마지막에 나오는 n의 값을 return 하는 solution 함수를 완성해 주세요.
6.2.1 파이썬
def solution(n: int, control:str) -> int:
# control 문자열을 순회하면서 n의 값을 조작합니다.
for char in control:
if char == 'w':
n += 1
elif char == 's':
n -= 1
elif char == 'd':
n += 10
elif char == 'a':
n -= 10
return n6.2.2 러스트
fn solution(mut n: i32, control: &str) -> i32 {
for char in control.chars() {
match char {
'w' => n += 1,
's' => n -= 1,
'd' => n += 10,
'a' => n -= 10,
_ => (), // Ignore any other characters
}
}
n
}
fn main() {
let initial_n = 0;
let control_string = "wsdawsdassw";
let result = solution(initial_n, control_string);
println!("Result: {}", result);
}6.3 수 조작하기 2
정수 배열 numLog가 주어집니다. 처음에 numLog[0]에서 부터 시작해 “w”, “a”, “s”, “d”로 이루어진 문자열을 입력으로 받아 순서대로 다음과 같은 조작을 했다고 합시다.
- “w” : 수에 1을 더한다.
- “s” : 수에 1을 뺀다.
- “d” : 수에 10을 더한다.
- “a” : 수에 10을 뺀다.
그리고 매번 조작을 할 때마다 결괏값을 기록한 정수 배열이 numLog입니다. 즉, numLog[i]는 numLog[0]로부터 총 i번의 조작을 가한 결과가 저장되어 있습니다.
주어진 정수 배열 numLog에 대해 조작을 위해 입력받은 문자열을 return 하는 solution 함수를 완성해 주세요.
6.3.1 파이썬
from typing import List
def solution(numLog:List[int]) -> str:
# 조작 문자열을 저장할 변수
answer = ''
# numLog 배열의 길이
n = len(numLog)
# 각 인접 원소 간의 차이를 확인하고 조작 문자열 생성
for i in range(1, n):
diff = numLog[i] - numLog[i - 1]
if diff == 1:
answer += 'w'
elif diff == -1:
answer += 's'
elif diff == 10:
answer += 'd'
elif diff == -10:
answer += 'a'
return answer6.3.2 러스트
fn solution(num_log: &[i32]) -> String {
let mut answer = String::new();
for i in 1..num_log.len() {
let diff = num_log[i] - num_log[i - 1];
match diff {
1 => answer.push('w'),
-1 => answer.push('s'),
10 => answer.push('d'),
-10 => answer.push('a'),
_ => (), // Ignore any other differences
}
}
answer
}
fn main() {
let num_log = vec![0, 1, 0, 10, 0, 1, 0, 10, 0, -1, -2, -1];
let result = solution(&num_log);
println!("Input: {:?}", num_log);
println!("Output: {}", result);
}6.4 수열 구간 쿼리 3
정수 배열 arr와 2차원 정수 배열 queries이 주어집니다. queries의 원소는 각각 하나의 query를 나타내며, [i, j] 꼴입니다.
각 query마다 순서대로 arr[i]의 값과 arr[j]의 값을 서로 바꿉니다.
위 규칙에 따라 queries를 처리한 이후의 arr를 return 하는 solution 함수를 완성해 주세요.
6.4.1 파이썬
from typing import List
def solution(arr:List[int], queries:List[int]) -> List[int]:
# 각 쿼리 처리
for i, j in queries:
# 인덱스 i와 j의 값을 서로 교환
arr[i], arr[j] = arr[j], arr[i]
return arr6.4.2 러스트
fn solution(mut arr: Vec<i32>, queries: &[(usize, usize)]) -> Vec<i32> {
for &(i, j) in queries {
arr.swap(i, j);
}
arr
}
fn main() {
let arr = vec![0, 1, 2, 3, 4];
let queries = vec![(0, 3), (1, 2), (1, 4)];
let result = solution(arr.clone(), &queries);
println!("Result: {:?}", result);
}6.5 수열 구간 쿼리2
정수 배열 arr와 2차원 정수 배열 queries이 주어집니다. queries의 원소는 각각 하나의 query를 나타내며, [s, e, k] 꼴입니다.
각 query마다 순서대로 s ≤ i ≤ e인 모든 i에 대해 k보다 크면서 가장 작은 arr[i]를 찾습니다.
각 쿼리의 순서에 맞게 답을 저장한 배열을 반환하는 solution 함수를 완성해 주세요.
단, 특정 쿼리의 답이 존재하지 않으면 -1을 저장합니다. ### 파이썬
from typing import List
def solution(arr:List[int], queries:List[int]) -> List[int]:
answer = []
for s, e, k in queries:
# 범위 내의 값을 추출
subset = arr[s:e+1]
# k보다 큰 값을 필터링
filtered = [num for num in subset if num > k]
if filtered:
# 필터링된 값 중 가장 작은 값 선택
answer.append(min(filtered))
else:
# k보다 큰 값이 없는 경우 -1
answer.append(-1)
return answer6.5.1 러스트
fn solution(arr: &[i32], queries: &[(usize, usize, i32)]) -> Vec<i32> {
let mut answer = Vec::new();
for &(s, e, k) in queries {
let subset = &arr[s..=e];
let min_value = subset.iter()
.filter(|&&num| num > k)
.min()
.copied()
.unwrap_or(-1);
answer.push(min_value);
}
answer
}
fn main() {
let arr = vec![0, 1, 2, 4, 3];
let queries = vec![(0, 4, 2), (0, 3, 2), (0, 2, 1)];
let result = solution(&arr, &queries);
println!("Result: {:?}", result);
}7 Day 7 반복문
7.1 수열 구간 쿼리 4
정수 배열 arr와 2차원 정수 배열 queries이 주어집니다. queries의 원소는 각각 하나의 query를 나타내며, [s, e, k] 꼴입니다.
각 query마다 순서대로 s ≤ i ≤ e인 모든 i에 대해 i가 k의 배수이면 arr[i]에 1을 더합니다.
위 규칙에 따라 queries를 처리한 이후의 arr를 return 하는 solution 함수를 완성해 주세요.
7.1.1 파이썬
from typing import List
def solution(arr:List[int], queries:List[int]) -> List[int]:
for s, e, k in queries:
for i in range(s, e + 1):
if i % k == 0:
arr[i] += 1
return arr7.1.2 러스트
fn solution(mut arr: Vec<i32>, queries: &[(usize, usize, usize)]) -> Vec<i32> {
for &(s, e, k) in queries {
for i in s..=e {
if i % k == 0 {
arr[i] += 1;
}
}
}
arr
}
fn main() {
let arr = vec![0, 1, 2, 3, 4];
let queries = vec![(0, 4, 1), (0, 3, 2), (0, 3, 3)];
let result = solution(arr.clone(), &queries);
println!("Result: {:?}", result);
}8 Day 8 조건문, 문자열
8.1 간단한 논리 연산
boolean 변수 x1, x2, x3, x4가 매개변수로 주어질 때, 다음의 \((x1∨x2)∧(x3∨x4)\) 식의 true/false를 return 하는 solution 함수를 작성해 주세요.
8.1.1 파이썬
def solution(x1:bool, x2:bool, x3:bool, x4:bool) -> bool:
return (x1 or x2) and (x3 or x4)8.1.2 러스트
fn solution(x1: bool, x2: bool, x3: bool, x4: bool) -> bool {
(x1 || x2) && (x3 || x4)
}
fn main() {
let result = solution(true, false, true, false);
println!("The result is: {}", result);
}8.2 주사위 게임
1부터 6까지 숫자가 적힌 주사위가 네 개 있습니다. 네 주사위를 굴렸을 때 나온 숫자에 따라 다음과 같은 점수를 얻습니다.
- 네 주사위에서 나온 숫자가 모두 p로 같다면 1111 × p점을 얻습니다.
- 세 주사위에서 나온 숫자가 p로 같고 나머지 다른 주사위에서 나온 숫자가 q(p ≠ q)라면 (10 × p + q)2 점을 얻습니다.
- 주사위가 두 개씩 같은 값이 나오고, 나온 숫자를 각각 p, q(p ≠ q)라고 한다면 (p + q) × |p - q|점을 얻습니다.
- 어느 두 주사위에서 나온 숫자가 p로 같고 나머지 두 주사위에서 나온 숫자가 각각 p와 다른 q, r(q ≠ r)이라면 q × r점을 얻습니다.
- 네 주사위에 적힌 숫자가 모두 다르다면 나온 숫자 중 가장 작은 숫자 만큼의 점수를 얻습니다.
네 주사위를 굴렸을 때 나온 숫자가 정수 매개변수 a, b, c, d로 주어질 때, 얻는 점수를 return 하는 solution 함수를 작성해 주세요.
8.2.1 파이썬
from collections import Counter
from typing import List
def solution(a: int, b: int, c: int, d: int) -> int:
counts: Counter[int] = Counter([a, b, c, d])
# 조건 1: 네 주사위의 숫자가 모두 같은 경우
if len(counts) == 1:
return 1111 * a
# 조건 2: 세 주사위의 숫자가 같고 나머지 한 주사위의 숫자가 다른 경우
if len(counts) == 2:
p, q = counts.most_common()
if p[1] == 3: # (숫자, 빈도)
return (10 * p[0] + q[0]) ** 2
else: # 두 쌍의 주사위가 같은 경우
return (p[0] + q[0]) * abs(p[0] - q[0])
# 조건 3: 두 주사위가 같은 숫자를 가질 경우, 나머지 두 주사위가 각각 다른 숫자일 경우
if len(counts) == 3:
for key in counts:
if counts[key] == 2:
remaining: List[int] = [k for k in counts if counts[k] == 1]
return remaining[0] * remaining[1]
# 조건 4: 모든 주사위의 숫자가 다를 경우
if len(counts) == 4:
return min(a, b, c, d)8.2.2 러스트
use std::collections::HashMap;
fn solution(a: i32, b: i32, c: i32, d: i32) -> i32 {
let mut counts = HashMap::new();
for &num in &[a, b, c, d] {
*counts.entry(num).or_insert(0) += 1;
}
// Condition 1: All four dice have the same number
if counts.len() == 1 {
return 1111 * a;
}
// Condition 2: Three dice have the same number, and one is different
if counts.len() == 2 {
let mut pairs: Vec<(&i32, &i32)> = counts.iter().collect();
pairs.sort_by(|a, b| b.cmp(a)); // Sort by frequency in descending order
let (p_num, p_count) = pairs[0];
let (q_num, _) = pairs[1];
if *p_count == 3 {
return (10 * p_num + q_num) * (10 * p_num + q_num);
} else {
return (p_num + q_num) * (p_num - q_num).abs();
}
}
// Condition 3: Two dice have the same number, and the other two are different
if counts.len() == 3 {
for (&key, &value) in &counts {
if value == 2 {
let mut remaining: Vec<i32> = counts
.iter()
.filter(|(_, &v)| v == 1)
.map(|(&k, _)| k)
.collect();
return remaining[0] * remaining[1];
}
}
}
// Condition 4: All four dice have different numbers
if counts.len() == 4 {
return *[a, b, c, d].iter().min().unwrap();
}
0 // Default return value (shouldn't reach here)
}
fn main() {
let result = solution(2, 2, 3, 4);
println!("The result is: {}", result);
}8.3 글자 이어 붙여 문자열 만들기
문자열 my_string과 정수 배열 index_list가 매개변수로 주어집니다. my_string의 index_list의 원소들에 해당하는 인덱스의 글자들을 순서대로 이어 붙인 문자열을 return 하는 solution 함수를 작성해 주세요.
8.3.1 파이썬
from typing import List
def solution(my_string: str, index_list:List[int]) -> str:
answer = ''.join(my_string[i] for i in index_list)
return answer8.3.2 러스트
fn solution(my_string: &str, index_list: &[usize]) -> String {
index_list.iter()
.filter_map(|&i| my_string.chars().nth(i))
.collect()
}
fn main() {
let my_string = "abcdef";
let index_list = vec![0, 2, 4];
let result = solution(my_string, &index_list);
println!("Result: {}", result);
}8.4 9로 나눈 나머지
음이 아닌 정수를 9로 나눈 나머지는 그 정수의 각 자리 숫자의 합을 9로 나눈 나머지와 같은 것이 알려져 있습니다.
이 사실을 이용하여 음이 아닌 정수가 문자열 number로 주어질 때, 이 정수를 9로 나눈 나머지를 return 하는 solution 함수를 작성해주세요.
8.4.1 파이썬
def solution(number:str) -> int:
digit_sum = sum(int(digit) for digit in number) # 각 자리 숫자의 합을 구합니다.
return digit_sum % 9 # 그 합을 9로 나눈 나머지를 반환합니다.8.4.2 러스트
fn solution(number: &str) -> i32 {
let digit_sum: i32 = number
.chars()
.filter_map(|c| c.to_digit(10))
.map(|d| d as i32)
.sum();
digit_sum % 9
}
fn main() {
let result = solution("123");
println!("Result: {}", result);
}8.5 문자열 여러 번 뒤집기
문자열 my_string과 이차원 정수 배열 queries가 매개변수로 주어집니다. queries의 원소는 [s, e] 형태로, my_string의 인덱스 s부터 인덱스 e까지를 뒤집으라는 의미입니다. my_string에 queries의 명령을 순서대로 처리한 후의 문자열을 return 하는 solution 함수를 작성해 주세요.
8.5.1 파이썬
from typing import List
def solution(my_string:str, queries:List[int]) -> str:
# 문자열을 리스트로 변환하여 수정 가능하게 만듭니다.
s = list(my_string)
# 각 쿼리 처리
for s_idx, e_idx in queries:
# s_idx부터 e_idx까지 부분 문자열을 뒤집습니다.
s[s_idx:e_idx + 1] = s[s_idx:e_idx + 1][::-1]
# 리스트를 문자열로 변환하여 반환합니다.
return ''.join(s)8.5.2 러스트
fn solution(my_string: &str, queries: &Vec<(usize, usize)>) -> String {
let mut s: Vec<char> = my_string.chars().collect();
for &(s_idx, e_idx) in queries {
s[s_idx..=e_idx].reverse();
}
s.into_iter().collect()
}
fn main() {
let my_string = "rermgorpsam";
let queries = vec![(2, 3), (0, 7), (5, 9), (6, 10)];
let result = solution(my_string, &queries);
println!("Result: {}", result);
}9 Day 9 문자열
9.1 배열 만들기 5
문자열 배열 intStrs와 정수 k, s, l가 주어집니다. intStrs의 원소는 숫자로 이루어져 있습니다.
배열 intStrs의 각 원소마다 s번 인덱스에서 시작하는 길이 l짜리 부분 문자열을 잘라내 정수로 변환합니다. 이때 변환한 정수값이 k보다 큰 값들을 담은 배열을 return 하는 solution 함수를 완성해 주세요.
9.1.1 파이썬
from typing import List
def solution(intStrs: List[str], k: int, s: int, l: int) -> List[int]:
answer: List[int] = []
for string in intStrs:
# s번 인덱스부터 l 길이만큼 부분 문자열을 잘라내고 정수로 변환
num: int = int(string[s:s+l])
# 변환한 정수가 k보다 크면 answer 리스트에 추가
if num > k:
answer.append(num)
return answer9.1.2 러스트
fn solution(int_strs: Vec<String>, k: i32, s: usize, l: usize) -> Vec<i32> {
let mut answer: Vec<i32> = Vec::new();
for string in int_strs {
// s번 인덱스부터 l 길이만큼 부분 문자열을 잘라내고 정수로 변환
if let Ok(num) = string[s..s+l].parse::<i32>() {
// 변환한 정수가 k보다 크면 answer 벡터에 추가
if num > k {
answer.push(num);
}
}
}
answer
}
fn main() {
let int_strs = vec![
String::from("12345"),
String::from("67890"),
String::from("54321")
];
let k = 340;
let s = 1;
let l = 3;
let result = solution(int_strs, k, s, l);
println!("Result: {:?}", result);
}9.2 부분 문자열 이어 붙여 문자열 만들기
길이가 같은 문자열 배열 my_strings와 이차원 정수 배열 parts가 매개변수로 주어집니다. parts[i]는 [s, e] 형태로, my_string[i]의 인덱스 s부터 인덱스 e까지의 부분 문자열을 의미합니다. 각 my_strings의 원소의 parts에 해당하는 부분 문자열을 순서대로 이어 붙인 문자열을 return 하는 solution 함수를 작성해 주세요.
9.2.1 파이썬
from typing import List, Tuple
def solution(my_strings: List[str], parts: List[Tuple[int, int]]) -> str:
answer: str = ''
for i in range(len(my_strings)):
s, e = parts[i]
answer += my_strings[i][s:e+1]
return answer9.2.2 러스트
fn solution(my_strings: Vec<String>, parts: Vec<(usize, usize)>) -> String {
let mut answer = String::new();
for i in 0..my_strings.len() {
let (s, e) = parts[i];
answer.push_str(&my_strings[i][s..=e]);
}
answer
}
fn main() {
let my_strings = vec![
String::from("progressive"),
String::from("hamburger"),
String::from("hammer"),
String::from("ahocorasick")
];
let parts = vec![(0, 4), (1, 2), (3, 5), (7, 7)];
let result = solution(my_strings, parts);
println!("Result: {}", result);
}9.3 문자열 뒤의 n글자
문자열 my_string과 정수 n이 매개변수로 주어질 때, my_string의 뒤의 n글자로 이루어진 문자열을 return 하는 solution 함수를 작성해 주세요.
9.3.1 파이썬
def solution(my_string: str, n: int) -> str:
return my_string[-n:]9.3.2 러스트
fn solution(my_string: String, n: usize) -> String {
my_string.chars().rev().take(n).rev().collect()
}
fn main() {
let my_string = String::from("HelloWorld");
let n = 5;
let result = solution(my_string, n);
println!("Result: {}", result);
}9.4 접미사 배열
어떤 문자열에 대해서 접미사는 특정 인덱스부터 시작하는 문자열을 의미합니다. 예를 들어, “banana”의 모든 접미사는 “banana”, “anana”, “nana”, “ana”, “na”, “a”입니다.
문자열 my_string이 매개변수로 주어질 때, my_string의 모든 접미사를 사전순으로 정렬한 문자열 배열을 return 하는 solution 함수를 작성해 주세요.
9.4.1 파이썬
from typing import List
def solution(my_string: str) -> List[str]:
# 모든 접미사 생성
suffixes: List[str] = [my_string[i:] for i in range(len(my_string))]
# 접미사들을 사전순으로 정렬
answer: List[str] = sorted(suffixes)
return answer9.4.2 러스트
fn solution(my_string: String) -> Vec<String> {
let mut suffixes: Vec<String> = Vec::new();
// 모든 접미사 생성
for i in 0..my_string.len() {
suffixes.push(my_string[i..].to_string());
}
// 접미사들을 사전순으로 정렬
suffixes.sort();
suffixes
}
fn main() {
let my_string = String::from("banana");
let result = solution(my_string);
println!("Result: {:?}", result);
}9.5 접미사인지 확인하기
어떤 문자열에 대해서 접미사는 특정 인덱스부터 시작하는 문자열을 의미합니다. 예를 들어, “banana”의 모든 접미사는 “banana”, “anana”, “nana”, “ana”, “na”, “a”입니다.
문자열 my_string과 is_suffix가 주어질 때, is_suffix가 my_string의 접미사라면 1을, 아니면 0을 return 하는 solution 함수를 작성해 주세요.
9.5.1 파이썬
def solution(my_string: str, is_suffix: str) -> int:
# my_string이 is_suffix로 끝나는지 확인
if my_string.endswith(is_suffix):
return 1
else:
return 09.5.2 러스트
fn solution(my_string: &str, is_suffix: &str) -> i32 {
// my_string이 is_suffix로 끝나는지 확인
if my_string.ends_with(is_suffix) {
1
} else {
0
}
}
fn main() {
let my_string = "banana";
let is_suffix = "ana";
let result = solution(my_string, is_suffix);
println!("Result: {}", result);
}10 Day 10 문자열
10.1 문자열의 앞 n글자
문자열 my_string과 정수 n이 매개변수로 주어질 때, my_string의 앞의 n글자로 이루어진 문자열을 return 하는 solution 함수를 작성해 주세요.
10.1.1 파이썬
def solution(my_string: str, n: int) -> str:
return my_string[:n]10.1.2 러스트
fn solution(my_string: &str, n: usize) -> String {
my_string.chars().take(n).collect()
}
fn main() {
let my_string = "HelloWorld";
let n = 5;
let result = solution(my_string, n);
println!("Result: {}", result);
}10.2 접두사인지 확인하기
어떤 문자열에 대해서 접두사는 특정 인덱스까지의 문자열을 의미합니다. 예를 들어, “banana”의 모든 접두사는 “b”, “ba”, “ban”, “bana”, “banan”, “banana”입니다. 문자열 my_string과 is_prefix가 주어질 때, is_prefix가 my_string의 접두사라면 1을, 아니면 0을 return 하는 solution 함수를 작성해 주세요.
10.2.1 파이썬
def solution(my_string: str, is_prefix:str) -> int:
return int(my_string.startswith(is_prefix))10.2.2 러스트
fn solution(my_string: &str, is_prefix: &str) -> i32 {
my_string.starts_with(is_prefix) as i32
}
fn main() {
let test_string = "Hello, world!";
let test_prefix = "Hello";
let result = solution(test_string, test_prefix);
println!("Is '{}' a prefix of '{}'? {}", test_prefix, test_string, result);
}10.3 문자열 뒤집기
문자열 my_string과 정수 s, e가 매개변수로 주어질 때, my_string에서 인덱스 s부터 인덱스 e까지를 뒤집은 문자열을 return 하는 solution 함수를 작성해 주세요.
10.3.1 파이썬
def solution(my_string: str, s:int, e:int) -> str:
# 문자열을 리스트로 변환
chars = list(my_string)
# s부터 e까지의 부분을 뒤집기
chars[s:e+1] = chars[s:e+1][::-1]
# 리스트를 다시 문자열로 변환하여 반환
return ''.join(chars)10.3.2 러스트
fn solution(my_string: &str, s: usize, e: usize) -> String {
let mut chars: Vec<char> = my_string.chars().collect();
let slice = &mut chars[s..=e];
slice.reverse();
chars.into_iter().collect()
}
fn main() {
let result = solution("abcde", 1, 3);
println!("Result: {}", result);
}10.4 세로 읽기
문자열 my_string과 두 정수 m, c가 주어집니다. my_string을 한 줄에 m 글자씩 가로로 적었을 때 왼쪽부터 세로로 c번째 열에 적힌 글자들을 문자열로 return 하는 solution 함수를 작성해 주세요.
10.4.1 파이썬
def solution(my_string: str, m: int, c: int) -> str:
# 결과를 저장할 문자열 초기화
result = ''
# c번째 열의 문자를 세로로 읽기
for i in range(0, len(my_string), m):
result += my_string[i + c - 1]
return result10.4.2 러스트
fn solution(my_string: &str, m: usize, c: usize) -> String {
my_string
.chars()
.skip(c - 1)
.step_by(m)
.collect()
}
fn main() {
let result = solution("ihrhbakrfpndopljhygc", 4, 2);
println!("Result: {}", result);
}10.5 qr code
두 정수 q, r과 문자열 code가 주어질 때, code의 각 인덱스를 q로 나누었을 때 나머지가 r인 위치의 문자를 앞에서부터 순서대로 이어 붙인 문자열을 return 하는 solution 함수를 작성해 주세요.
10.5.1 파이썬
def solution(q: int, r: int, code: str) -> str:
return ''.join(code[i] for i in range(len(code)) if i % q == r)10.5.2 러스트
fn solution(q: usize, r: usize, code: &str) -> String {
code.chars()
.enumerate()
.filter(|&(i, _)| i % q == r)
.map(|(_, c)| c)
.collect()
}
fn main() {
let result = solution(3, 1, "qjnwezgrpirldywt");
println!("Result: {}", result);
}11 Day 11 리스트 (배열)
11.1 문자 개수 세기
알파벳 대소문자로만 이루어진 문자열 my_string이 주어질 때, my_string에서 ’A’의 개수, my_string에서 ’B’의 개수,…, my_string에서 ’Z’의 개수, my_string에서 ’a’의 개수, my_string에서 ’b’의 개수,…, my_string에서 ’z’의 개수를 순서대로 담은 길이 52의 정수 배열을 return 하는 solution 함수를 작성해 주세요.
11.1.1 파이썬
from typing import List
def solution(my_string:str) -> List[int]:
answer = [0] * 52 # 52개의 0으로 초기화된 리스트 생성
for char in my_string:
if char.isupper():
# 대문자인 경우
index = ord(char) - ord('A')
elif char.islower():
# 소문자인 경우
index = ord(char) - ord('a') + 26
else:
# 알파벳이 아닌 경우 (이 문제에서는 발생하지 않지만, 안전성을 위해 추가)
continue
answer[index] += 1
return answer11.1.2 러스트
fn solution(my_string: &str) -> Vec<i32> {
let mut answer = vec![0; 52]; // Initialize a vector with 52 zeros
for char in my_string.chars() {
let index = if char.is_ascii_uppercase() {
// For uppercase letters
(char as u8 - b'A') as usize
} else if char.is_ascii_lowercase() {
// For lowercase letters
(char as u8 - b'a') as usize + 26
} else {
// For non-alphabetic characters (not expected in this problem, but added for safety)
continue;
};
answer[index] += 1;
}
answer
}
fn main() {
let test_string = "Rust is awesome!";
let result = solution(test_string);
println!("Result for '{}': {:?}", test_string, result);
}11.2 배열 만들기 1
정수 n과 k가 주어졌을 때, 1 이상 n이하의 정수 중에서 k의 배수를 오름차순으로 저장한 배열을 return 하는 solution 함수를 완성해 주세요.
11.2.1 파이썬
from tpying import List
def solution(n: int, k: int) -> List[int]:
return [i for i in range(k, n+1, k)]11.2.2 러스트
fn solution(n: i32, k: i32) -> Vec<i32> {
(k..=n).step_by(k as usize).collect()
}
fn main() {
let n = 10;
let k = 3;
let result = solution(n, k);
println!("Result for n={} and k={}: {:?}", n, k, result);
}11.3 글자 지우기
문자열 my_string과 정수 배열 indices가 주어질 때, my_string에서 indices의 원소에 해당하는 인덱스의 글자를 지우고 이어 붙인 문자열을 return 하는 solution 함수를 작성해 주세요.
11.3.1 파이썬
from typing import List
def solution(my_string: str, indices: List[int]) -> str:
# 문자열을 리스트로 변환
chars = list(my_string)
# indices의 원소에 해당하는 인덱스의 문자를 빈 문자로 대체
for index in indices:
chars[index] = ''
# 리스트를 다시 문자열로 결합
return ''.join(chars)11.3.2 러스트
from typing import List
def solution(my_string: str, indices: List[int]) -> str:
# 문자열을 리스트로 변환
chars = list(my_string)
# indices의 원소에 해당하는 인덱스의 문자를 빈 문자로 대체
for index in indices:
chars[index] = ''
# 리스트를 다시 문자열로 결합
return ''.join(chars)11.4 카운트 다운
정수 start_num와 end_num가 주어질 때, start_num에서 end_num까지 1씩 감소하는 수들을 차례로 담은 리스트를 return하도록 solution 함수를 완성해주세요.
11.4.1 파이썬
from typing import List
def solution(start_num: int, end_num: int) -> List[int]:
return list(range(start_num, end_num - 1, -1))11.4.2 러스트
fn solution(start_num: i32, end_num: i32) -> Vec<i32> {
(end_num..=start_num).rev().collect()
}
fn main() {
let start_num = 10;
let end_num = 5;
let result = solution(start_num, end_num);
println!("Result from {} to {}: {:?}", start_num, end_num, result);
}11.5 가까운 1 찾기
정수 배열 arr가 주어집니다. 이때 arr의 원소는 1 또는 0입니다. 정수 idx가 주어졌을 때, idx보다 크면서 배열의 값이 1인 가장 작은 인덱스를 찾아서 반환하는 solution 함수를 완성해 주세요.만약 그러한 인덱스가 없다면 -1을 반환합니다.
11.5.1 파이썬
from typing import List
def solution(arr: List[int], idx:int) -> int:
for i in range(idx, len(arr)):
if arr[i] == 1:
return i
return -111.5.2 러스트
fn solution(arr: &[i32], idx: usize) -> i32 {
for (i, &value) in arr.iter().enumerate().skip(idx) {
if value == 1 {
return i as i32;
}
}
-1
}
fn main() {
let arr = vec![0, 0, 0, 1, 0, 1];
let idx = 2;
let result = solution(&arr, idx);
println!("Result: {}", result);
}12 Day 12 리스트 (배열)
12.1 리스트 자르기
정수 n과 정수 3개가 담긴 리스트 slicer 그리고 정수 여러 개가 담긴 리스트 num_list가 주어집니다. slicer에 담긴 정수를 차례대로 a, b, c라고 할 때, n에 따라 다음과 같이 num_list를 슬라이싱 하려고 합니다.
- n = 1 : num_list의 0번 인덱스부터 b번 인덱스까지
- n = 2 : num_list의 a번 인덱스부터 마지막 인덱스까지
- n = 3 : num_list의 a번 인덱스부터 b번 인덱스까지
- n = 4 : num_list의 a번 인덱스부터 b번 인덱스까지 c 간격으로
올바르게 슬라이싱한 리스트를 return하도록 solution 함수를 완성해주세요.
12.1.1 파이썬
from typing import List
def solution(n: int, slicer: List[int], num_list: List[int]) -> List[int]:
a, b, c = slicer
if n == 1:
return num_list[:b+1]
elif n == 2:
return num_list[a:]
elif n == 3:
return num_list[a:b+1]
elif n == 4:
return num_list[a:b+1:c]12.1.2 러스트
fn solution(n: i32, slicer: &[i32], num_list: &[i32]) -> Vec<i32> {
let (a, b, c) = (slicer[0] as usize, slicer[1] as usize, slicer[2] as usize);
match n {
1 => num_list[..=b].to_vec(),
2 => num_list[a..].to_vec(),
3 => num_list[a..=b].to_vec(),
4 => num_list[a..=b].iter().step_by(c).cloned().collect(),
_ => Vec::new(), // Handle unexpected n values
}
}
fn main() {
let slicer = vec![1, 5, 2];
let num_list = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];
println!("n = 1: {:?}", solution(1, &slicer, &num_list));
}12.2 첫 번째로 나오는 음수
정수 리스트 num_list가 주어질 때, 첫 번째로 나오는 음수의 인덱스를 return하도록 solution 함수를 완성해주세요. 음수가 없다면 -1을 return합니다.
12.2.1 파이썬
from typing import List
def solution(num_list: List[int]) -> int:
for i, num in enumerate(num_list):
if num < 0:
return i
return -112.2.2 러스트
fn solution(num_list: &[i32]) -> i32 {
for (i, &num) in num_list.iter().enumerate() {
if num < 0 {
return i as i32;
}
}
-1
}
fn main() {
let num_list = vec![1, 2, 3, -4, 5, 6];
println!("Result: {}", solution(&num_list));
}12.3 배열 만들기 3
정수 배열 arr와 2개의 구간이 담긴 배열 intervals가 주어집니다.
intervals는 항상 [[a1, b1], [a2, b2]]의 꼴로 주어지며 각 구간은 닫힌 구간입니다. 닫힌 구간은 양 끝값과 그 사이의 값을 모두 포함하는 구간을 의미합니다.
이때 배열 arr의 첫 번째 구간에 해당하는 배열과 두 번째 구간에 해당하는 배열을 앞뒤로 붙여 새로운 배열을 만들어 return 하는 solution 함수를 완성해 주세요.
12.3.1 파이썬
from typing import List
def solution(arr: List[int], intervals: List[int]) -> List[int]:
result = []
for interval in intervals:
start, end = interval
result.extend(arr[start:end+1])
return result12.3.2 러스트
fn solution(arr: &[i32], intervals: &[[i32; 2]]) -> Vec<i32> {
let mut result = Vec::new();
for interval in intervals {
let start = interval[0] as usize;
let end = interval[1] as usize;
result.extend_from_slice(&arr[start..=end]);
}
result
}
fn main() {
let arr = vec![1, 2, 3, 4, 5];
let intervals = vec![[1, 3], [0, 4]];
let result = solution(&arr, &intervals);
println!("Result: {:?}", result);
}12.4 2의 영역
정수 배열 arr가 주어집니다. 배열 안의 2가 모두 포함된 가장 작은 연속된 부분 배열을 return 하는 solution 함수를 완성해 주세요.
단, arr에 2가 없는 경우 [-1]을 return 합니다.
12.4.1 파이썬
from typing import List
def solution(arr: List[int]) -> List[int]:
# 2의 위치를 모두 찾습니다
indices = [i for i, x in enumerate(arr) if x == 2]
# 2가 없는 경우 [-1]을 반환합니다
if not indices:
return [-1]
# 첫 번째 2와 마지막 2의 인덱스를 찾습니다
start = indices[0]
end = indices[-1]
# 해당 범위의 부분 배열을 반환합니다
return arr[start:end+1]12.4.2 러스트
fn solution(arr: &[i32]) -> Vec<i32> {
// 2의 위치를 모두 찾습니다
let indices: Vec<usize> = arr.iter()
.enumerate()
.filter(|&(_, &x)| x == 2)
.map(|(i, _)| i)
.collect();
// 2가 없는 경우 [-1]을 반환합니다
if indices.is_empty() {
return vec![-1];
}
// 첫 번째 2와 마지막 2의 인덱스를 찾습니다
let start = indices[0];
let end = indices[indices.len() - 1];
// 해당 범위의 부분 배열을 반환합니다
arr[start..=end].to_vec()
}
fn main() {
let arr = vec![1, 2, 1, 4, 5, 2, 9];
let result = solution(&arr);
println!("Result: {:?}", result);
}12.5 배열 조각하기
정수 배열 arr와 query가 주어집니다.
query를 순회하면서 다음 작업을 반복합니다.
- 짝수 인덱스에서는 arr에서
query[i]번 인덱스를 제외하고 배열의query[i]번 인덱스 뒷부분을 잘라서 버립니다. - 홀수 인덱스에서는 arr에서
query[i]번 인덱스는 제외하고 배열의query[i]번 인덱스 앞부분을 잘라서 버립니다.
위 작업을 마친 후 남은 arr의 부분 배열을 return 하는 solution 함수를 완성해 주세요.
12.5.1 파이썬
from typing import List
def solution(arr: List[int], query: List[int]) -> List[int]:
start, end = 0, len(arr)
for i, q in enumerate(query):
if i % 2 == 0: # 짝수 인덱스
end = start + q + 1
else: # 홀수 인덱스
start += q
return arr[start:end]12.5.2 러스트
fn solution(arr: &[i32], query: &[i32]) -> Vec<i32> {
let mut start = 0;
let mut end = arr.len();
for (i, &q) in query.iter().enumerate() {
if i % 2 == 0 { // 짝수 인덱스
end = start + q as usize + 1;
} else { // 홀수 인덱스
start += q as usize;
}
}
arr[start..end].to_vec()
}
fn main() {
let arr = vec![0, 1, 2, 3, 4, 5];
let query = vec![4, 1, 2];
let result = solution(&arr, &query);
println!("Result: {:?}", result);
}13 Day 13 리스트 (배열)
13.1 n 번째 원소부터
정수 리스트 num_list와 정수 n이 주어질 때, n 번째 원소부터 마지막 원소까지의 모든 원소를 담은 리스트를 return하도록 solution 함수를 완성해주세요.
13.1.1 파이썬
from typing import List
def solution(num_list: List[int], n:int) -> List[int]:
return num_list[n-1:]13.1.2 러스트
fn solution(num_list: &[i32], n: usize) -> Vec<i32> {
num_list[n-1..].to_vec()
}
fn main() {
let num_list = vec![2, 1, 6, 3, 7, 5];
let n = 3;
let result = solution(&num_list, n);
println!("Result: {:?}", result);
}13.2 순서 바꾸기
정수 리스트 num_list와 정수 n이 주어질 때, num_list를 n 번째 원소 이후의 원소들과 n 번째까지의 원소들로 나눠 n 번째 원소 이후의 원소들을 n 번째까지의 원소들 앞에 붙인 리스트를 return하도록 solution 함수를 완성해주세요.
13.2.1 파이썬
from typing import List
def solution(num_list: List[int], n: int) -> List[int]:
return num_list[n:] + num_list[:n]13.2.2 러스트
fn solution(num_list: Vec<i32>, n: usize) -> Vec<i32> {
let mut result = num_list[n..].to_vec();
result.extend_from_slice(&num_list[..n]);
result
}
fn main() {
let num_list = vec![1, 2, 3, 4, 5];
let n = 2;
let result = solution(num_list, n);
println!("Result: {:?}", result);
}13.3 왼쪽 오른쪽
문자열 리스트 str_list에는 “u”, “d”, “l”, “r” 네 개의 문자열이 여러 개 저장되어 있습니다. str_list에서 “l”과 “r” 중 먼저 나오는 문자열이 “l”이라면 해당 문자열을 기준으로 왼쪽에 있는 문자열들을 순서대로 담은 리스트를, 먼저 나오는 문자열이 “r”이라면 해당 문자열을 기준으로 오른쪽에 있는 문자열들을 순서대로 담은 리스트를 return하도록 solution 함수를 완성해주세요. “l”이나 “r”이 없다면 빈 리스트를 return합니다.
13.3.1 파이썬
from typing import List
def solution(str_list: List[str]) -> List[str]:
for i, char in enumerate(str_list):
if char == 'l':
return str_list[:i]
elif char == 'r':
return str_list[i+1:]
return []13.3.2 러스트
fn solution(str_list: Vec<String>) -> Vec<String> {
for (i, char) in str_list.iter().enumerate() {
if char == "l" {
return str_list[..i].to_vec();
} else if char == "r" {
return str_list[i+1..].to_vec();
}
}
Vec::new()
}
fn main() {
let str_list = vec![
"u".to_string(),
"u".to_string(),
"l".to_string(),
"r".to_string()
];
let result = solution(str_list);
println!("Result: {:?}", result);
}13.4 n번째 원소까지
정수 리스트 num_list와 정수 n이 주어질 때, num_list의 첫 번째 원소부터 n 번째 원소까지의 모든 원소를 담은 리스트를 return하도록 solution 함수를 완성해주세요.
13.4.1 파이썬
from typing import List
def solution(num_list: List[int], n: int) -> List[int]:
return num_list[:n]13.4.2 러스트
fn solution(num_list: Vec<i32>, n: usize) -> Vec<i32> {
num_list[..n].to_vec()
}
fn main() {
let num_list = vec![1, 2, 3, 4, 5];
let n = 3;
let result = solution(num_list, n);
println!("Result: {:?}", result);
}13.5 n개 간격의 원소들
정수 리스트 num_list와 정수 n이 주어질 때, num_list의 첫 번째 원소부터 마지막 원소까지 n개 간격으로 저장되어있는 원소들을 차례로 담은 리스트를 return하도록 solution 함수를 완성해주세요.
13.5.1 파이썬
from typing import List
def solution(num_list: List[int], n: int) -> List[int]:
return num_list[::n]13.5.2 러스트
fn solution(num_list: Vec<i32>, n: usize) -> Vec<i32> {
num_list.iter().step_by(n).cloned().collect()
}
fn main() {
let num_list = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let n = 2;
let result = solution(num_list, n);
println!("Result: {:?}", result);
}14 Day 14 리스트 (배열)
14.1 홀수 vs 짝수
정수 리스트 num_list가 주어집니다. 가장 첫 번째 원소를 1번 원소라고 할 때, 홀수 번째 원소들의 합과 짝수 번째 원소들의 합 중 큰 값을 return 하도록 solution 함수를 완성해주세요. 두 값이 같을 경우 그 값을 return합니다.
14.1.1 파이썬
from typing import List
def solution(num_list: List[int]) -> int:
odd_sum = sum(num_list[::2]) # 홀수 번째 원소들의 합
even_sum = sum(num_list[1::2]) # 짝수 번째 원소들의 합
return max(odd_sum, even_sum)14.1.2 러스트
fn solution(num_list: Vec<i32>) -> i32 {
let odd_sum: i32 = num_list.iter().step_by(2).sum();
let even_sum: i32 = num_list.iter().skip(1).step_by(2).sum();
odd_sum.max(even_sum)
}
fn main() {
let num_list = vec![4, 2, 6, 1, 7, 6];
let result = solution(num_list);
println!("Result: {}", result);
}14.2 5명씩
최대 5명씩 탑승가능한 놀이기구를 타기 위해 줄을 서있는 사람들의 이름이 담긴 문자열 리스트 names가 주어질 때, 앞에서 부터 5명씩 묶은 그룹의 가장 앞에 서있는 사람들의 이름을 담은 리스트를 return하도록 solution 함수를 완성해주세요. 마지막 그룹이 5명이 되지 않더라도 가장 앞에 있는 사람의 이름을 포함합니다.
14.2.1 파이썬
from typing import List
def solution(names: List[str]):
return names[::5]14.2.2 러스트
fn solution(names: Vec<String>) -> Vec<String> {
names.into_iter().step_by(5).collect()
}
fn main() {
let names = vec![
"Jane".to_string(),
"Kim".to_string(),
];
let result = solution(names);
println!("Result: {:?}", result);
}14.3 할 일 목록
오늘 해야 할 일이 담긴 문자열 배열 todo_list와 각각의 일을 지금 마쳤는지를 나타내는 boolean 배열 finished가 매개변수로 주어질 때, todo_list에서 아직 마치지 못한 일들을 순서대로 담은 문자열 배열을 return 하는 solution 함수를 작성해 주세요.
14.3.1 파이썬
from typing import List
def solution(todo_list: List[str], finished: List[bool]) -> List[str]:
return [task for task, is_finished in zip(todo_list, finished) if not is_finished]14.3.2 러스트
fn solution(todo_list: Vec<String>, finished: Vec<bool>) -> Vec<String> {
todo_list
.into_iter()
.zip(finished)
.filter(|(_, is_finished)| !is_finished)
.map(|(task, _)| task)
.collect()
}
fn main() {
let todo_list = vec![
"laundry".to_string(),
"dishes".to_string(),
"vacuum".to_string(),
"groceries".to_string(),
];
let finished = vec![true, false, true, false];
let result = solution(todo_list, finished);
println!("Unfinished tasks: {:?}", result);
}14.4 n보다 커질 때까지 더하기
정수 배열 numbers와 정수 n이 매개변수로 주어집니다. numbers의 원소를 앞에서부터 하나씩 더하다가 그 합이 n보다 커지는 순간 이때까지 더했던 원소들의 합을 return 하는 solution 함수를 작성해 주세요.
14.4.1 파이썬
from typing import List
def solution(numbers: List[str], n: int) -> int:
total = 0
for num in numbers:
total += num
if total > n:
return total
return total14.4.2 러스트
fn solution(numbers: Vec<String>, n: i32) -> i32 {
let mut total = 0;
for num in numbers {
total += num.parse::<i32>().unwrap();
if total > n {
return total;
}
}
total
}
fn main() {
let numbers = vec![
"1".to_string(),
"2".to_string(),
"3".to_string(),
"4".to_string(),
"5".to_string(),
];
let n = 8;
let result = solution(numbers, n);
println!("Result: {}", result);
}14.5 수열과 구간 쿼리 1
정수 배열 arr와 2차원 정수 배열 queries이 주어집니다. queries의 원소는 각각 하나의 query를 나타내며, [s, e] 꼴입니다. 각 query마다 순서대로 s ≤ i ≤ e인 모든 i에 대해 arr[i]에 1을 더합니다. 위 규칙에 따라 queries를 처리한 이후의 arr를 return 하는 solution 함수를 완성해 주세요.
14.5.1 파이썬
from typing import List
def solution(arr: List[int], queries: List[int]) -> List[int]:
for s, e in queries:
for i in range(s, e + 1):
arr[i] += 1
return arr14.5.2 러스트
fn solution(mut arr: Vec<i32>, queries: Vec<(usize, usize)>) -> Vec<i32> {
for (s, e) in queries {
for i in s..=e {
arr[i] += 1;
}
}
arr
}
fn main() {
let arr = vec![0, 1, 2, 3, 4];
let queries = vec![(0, 3), (1, 2)];
let result = solution(arr, queries);
println!("Result: {:?}", result);
}15 Day 15 리스트 (배열), 문자열
15.1 조건에 맞게 수열 변환하기 1
정수 배열 arr가 주어집니다. arr의 각 원소에 대해 값이 50보다 크거나 같은 짝수라면 2로 나누고, 50보다 작은 홀수라면 2를 곱합니다. 그 결과인 정수 배열을 return 하는 solution 함수를 완성해 주세요.
15.1.1 파이썬
from typing import List
def solution(arr: List[int]) -> List[int]:
return [num // 2 if num >= 50 and num % 2 == 0 else num * 2 if num < 50 and num % 2 == 1 else num for num in arr]15.1.2 러스트
fn solution(arr: Vec<i32>) -> Vec<i32> {
arr.into_iter().map(|num| {
if num >= 50 && num % 2 == 0 {
num / 2
} else if num < 50 && num % 2 == 1 {
num * 2
} else {
num
}
}).collect()
}
fn main() {
let arr = vec![10, 51, 50, 49, 48]; // Example input
let result = solution(arr);
println!("{:?}", result);
}15.2 조건에 맞게 수열 변환하기 2
정수 배열 arr가 주어집니다. arr의 각 원소에 대해 값이 50보다 크거나 같은 짝수라면 2로 나누고, 50보다 작은 홀수라면 2를 곱하고 다시 1을 더합니다.
이러한 작업을 x번 반복한 결과인 배열을 arr(x)라고 표현했을 때, arr(x) = arr(x + 1)인 x가 항상 존재합니다. 이러한 x 중 가장 작은 값을 return 하는 solution 함수를 완성해 주세요.
단, 두 배열에 대한 “=”는 두 배열의 크기가 서로 같으며, 같은 인덱스의 원소가 각각 서로 같음을 의미합니다.
15.2.1 파이썬
from typing import List
def solution(arr: List[int]) -> int:
x = 0
prev_arr = arr.copy()
while True:
new_arr = []
for num in prev_arr:
if num >= 50 and num % 2 == 0:
new_arr.append(num // 2)
elif num < 50 and num % 2 == 1:
new_arr.append(num * 2 + 1)
else:
new_arr.append(num)
if new_arr == prev_arr:
return x
prev_arr = new_arr
x += 115.2.2 러스트
fn solution(arr: Vec<i32>) -> i32 {
let mut x = 0;
let mut prev_arr = arr;
loop {
let new_arr: Vec<i32> = prev_arr.iter().map(|&num| {
if num >= 50 && num % 2 == 0 {
num / 2
} else if num < 50 && num % 2 == 1 {
num * 2 + 1
} else {
num
}
}).collect();
if new_arr == prev_arr {
return x;
}
prev_arr = new_arr;
x += 1;
}
}
fn main() {
let arr = vec![10, 51, 50, 49, 48]; // Example input
let result = solution(arr);
println!("Result: {}", result);
}15.3 1로 만들기
정수가 있을 때, 짝수라면 반으로 나누고, 홀수라면 1을 뺀 뒤 반으로 나누면, 마지막엔 1이 됩니다. 예를 들어 10이 있다면 다음과 같은 과정으로 1이 됩니다.
10 / 2 = 5
(5 - 1) / 2 = 2
2 / 2 = 1위와 같이 3번의 나누기 연산으로 1이 되었습니다.
정수들이 담긴 리스트 num_list가 주어질 때, num_list의 모든 원소를 1로 만들기 위해서 필요한 나누기 연산의 횟수를 return하도록 solution 함수를 완성해주세요.
15.3.1 파이썬
from typing import List
def solution(num_list: List[int]) -> int:
def count_operations(num):
count = 0
while num > 1:
if num % 2 == 0:
num //= 2
else:
num = (num - 1) // 2
count += 1
return count
return sum(count_operations(num) for num in num_list)15.3.2 러스트
fn solution(num_list: Vec<i32>) -> i32 {
fn count_operations(mut num: i32) -> i32 {
let mut count = 0;
while num > 1 {
if num % 2 == 0 {
num /= 2;
} else {
num = (num - 1) / 2;
}
count += 1;
}
count
}
num_list.iter().map(|&num| count_operations(num)).sum()
}
fn main() {
let num_list = vec![12, 15, 7, 8]; // Example input
let result = solution(num_list);
println!("Result: {}", result);
}15.4 길이에 따른 연산
정수가 담긴 리스트 num_list가 주어질 때, 리스트의 길이가 11 이상이면 리스트에 있는 모든 원소의 합을 10 이하이면 모든 원소의 곱을 return하도록 solution 함수를 완성해주세요.
15.4.1 파이썬
import math
from typing import List
def solution(num_list: List[int]) -> int:
if len(num_list) >= 11:
return sum(num_list)
else:
return math.prod(num_list)15.4.2 러스트
fn solution(num_list: Vec<i32>) -> i32 {
if num_list.len() >= 11 {
num_list.iter().sum()
} else {
num_list.iter().product()
}
}
fn main() {
let num_list1 = vec![1, 2, 3, 4, 5]; // Example input with less than 11 elements
let num_list2 = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]; // Example input with 11 elements
println!("Result 1: {}", solution(num_list1));
println!("Result 2: {}", solution(num_list2));
}15.5 원하는 문자열 찾기
알파벳으로 이루어진 문자열 myString과 pat이 주어집니다. myString의 연속된 부분 문자열 중 pat이 존재하면 1을 그렇지 않으면 0을 return 하는 solution 함수를 완성해 주세요. 단, 알파벳 대문자와 소문자는 구분하지 않습니다.
15.5.1 파이썬
def solution(myString: str, pat: str) -> int:
return int(pat.lower() in myString.lower())15.5.2 러스트
// Import necessary modules
use std::collections::HashMap; // Example import
// Define structs or enums if needed
struct MyStruct {
field1: i32,
field2: String,
}
// Implement methods for structs if needed
impl MyStruct {
fn new(value1: i32, value2: String) -> Self {
MyStruct {
field1: value1,
field2: value2,
}
}
fn some_method(&self) -> i32 {
// Method implementation
self.field1
}
}
// Main function
fn main() {
// Your converted code logic here
let my_instance = MyStruct::new(42, String::from("Hello"));
println!("Result: {}", my_instance.some_method());
}
// Helper functions
fn helper_function(param: i32) -> i32 {
// Function implementation
param * 2
}16 Day 16 문자열
16.1 대문자로 바꾸기
알파벳으로 이루어진 문자열 myString이 주어집니다. 모든 알파벳을 대문자로 변환하여 return 하는 solution 함수를 완성해 주세요.
16.1.1 파이썬
def solution(myString: str) -> str:
return myString.upper()16.1.2 러스트
fn solution(my_string: &str) -> String {
my_string.to_uppercase()
}
fn main() {
let example_string = "Hello, World!";
let result = solution(example_string);
println!("Original: {}", example_string);
println!("Uppercase: {}", result);
}16.2 소문자로 바꾸기
알파벳으로 이루어진 문자열 myString이 주어집니다. 모든 알파벳을 소문자로 변환하여 return 하는 solution 함수를 완성해 주세요.
16.2.1 파이썬
def solution(myString:str) -> str:
return myString.lower()16.2.2 러스트
fn solution(my_string: &str) -> String {
my_string.to_lowercase()
}
fn main() {
let example_string = "Hello, World!";
let result = solution(example_string);
println!("Original: {}", example_string);
println!("Lowercase: {}", result);
}16.3 배열에서 문자열 대소문자 변환
문자열 배열 strArr가 주어집니다. 모든 원소가 알파벳으로만 이루어져 있을 때, 배열에서 홀수번째 인덱스의 문자열은 모든 문자를 대문자로, 짝수번째 인덱스의 문자열은 모든 문자를 소문자로 바꿔서 반환하는 solution 함수를 완성해 주세요.
16.3.1 파이썬
from typing import List
def solution(strArr: List[str]) -> List[str]:
return [s.lower() if i % 2 == 0 else s.upper() for i, s in enumerate(strArr)]16.3.2 러스트
fn solution(str_arr: Vec<String>) -> Vec<String> {
str_arr.iter().enumerate().map(|(i, s)| {
if i % 2 == 0 {
s.to_lowercase()
} else {
s.to_uppercase()
}
}).collect()
}
fn main() {
let example_vec = vec![
String::from("Hello"),
String::from("World"),
String::from("Rust"),
String::from("Programming")
];
let result = solution(example_vec.clone());
println!("Original: {:?}", example_vec);
println!("Result: {:?}", result);
}16.4 A 강조하기
문자열 myString이 주어집니다. myString에서 알파벳 “a”가 등장하면 전부 “A”로 변환하고, “A”가 아닌 모든 대문자 알파벳은 소문자 알파벳으로 변환하여 return 하는 solution 함수를 완성하세요.
16.4.1 파이썬
def solution(myString: str) -> str:
return ''.join(['A' if c.lower() == 'a' else c.lower() for c in myString])16.4.2 러스트
fn solution(my_string: &str) -> String {
my_string.chars().map(|c| {
if c.to_ascii_lowercase() == 'a' {
'A'
} else {
c.to_ascii_lowercase()
}
}).collect()
}
fn main() {
let example_string = "AbCdEfG";
let result = solution(example_string);
println!("Original: {}", example_string);
println!("Result: {}", result);
}16.5 특정한 문자를 대문자로 바꾸기
영소문자로 이루어진 문자열 my_string과 영소문자 1글자로 이루어진 문자열 alp가 매개변수로 주어질 때, my_string에서 alp에 해당하는 모든 글자를 대문자로 바꾼 문자열을 return 하는 solution 함수를 작성해 주세요.
16.5.1 파이썬
def solution(my_string: str, alp:str) -> str:
return my_string.replace(alp, alp.upper())16.5.2 러스트
fn solution(my_string: &str, alp: &str) -> String {
my_string.replace(alp, &alp.to_uppercase())
}
fn main() {
let example_string = "hello world";
let example_alp = "o";
let result = solution(example_string, example_alp);
println!("Original: {}", example_string);
println!("Replace '{}' with '{}': {}", example_alp, example_alp.to_uppercase(), result);
}17 Day 17 문자열
17.1 특정 문자열로 끝나는 가장 긴 부분 문자열 찾기
17.1.1 파이썬
def solution(myString, pat):
for i in range(len(myString), -1, -1):
if myString[:i].endswith(pat):
return myString[:i]17.2 문자열이 몇 번 등장하는지 세기
17.2.1 파이썬
def solution(myString, pat):
answer = 0
for i in range(len(myString) - len(pat) + 1):
if myString[i:i+len(pat)] == pat:
answer += 1
return answer17.2.2 러스트
fn solution(my_string: &str, pat: &str) -> i32 {
let mut answer = 0;
let pat_len = pat.len();
for i in 0..=my_string.len() - pat_len {
if &my_string[i..i+pat_len] == pat {
answer += 1;
}
}
answer
}
fn main() {
let my_string = "banana";
let pat = "ana";
let result = solution(my_string, pat);
println!("Result: {}", result);
}17.3 문자열에서 ad 제거하기
17.3.1 파이썬
def solution(strArr):
return [s for s in strArr if "ad" not in s]17.3.2 러스트
fn solution(str_arr: Vec<String>) -> Vec<String> {
str_arr.into_iter().filter(|s| !s.contains("ad")).collect()
}
fn main() {
let str_arr = vec![
"bad".to_string(),
"good".to_string(),
"mad".to_string(),
"glad".to_string(),
"sad".to_string(),
];
let result = solution(str_arr);
println!("Result: {:?}", result);
}17.4 공백으로 구분하기 1
단어가 공백 한 개로 구분되어 있는 문자열 my_string이 매개변수로 주어질 때, my_string에 나온 단어를 앞에서부터 순서대로 담은 문자열 배열을 return 하는 solution 함수를 작성해 주세요.
17.4.1 파이썬
from typing import List
def solution(my_string: str) -> List[str]:
return my_string.split()17.4.2 러스트
fn solution(my_string: &str) -> Vec<String> {
my_string.split_whitespace().map(String::from).collect()
}
fn main() {
let example_string = "Hello world Rust programming";
let result = solution(example_string);
println!("Original string: {}", example_string);
println!("Split result: {:?}", result);
}17.5 공백으로 구분하기 2
단어가 공백 한 개 이상으로 구분되어 있는 문자열 my_string이 매개변수로 주어질 때, my_string에 나온 단어를 앞에서부터 순서대로 담은 문자열 배열을 return 하는 solution 함수를 작성해 주세요.
17.5.1 파이썬
from typing import List
def solution(my_string: str) -> List[str]:
return my_string.split()17.5.2 러스트
fn solution(my_string: &str) -> Vec<String> {
my_string.split_whitespace().map(String::from).collect()
}
fn main() {
let example_string = "Hello world Rust programming";
let result = solution(example_string);
println!("Original string: {}", example_string);
println!("Split result: {:?}", result);
}18 Day 18 문자열
18.1 x사이의 개수
문자열 myString이 주어집니다. myString을 문자 “x”를 기준으로 나눴을 때 나눠진 문자열 각각의 길이를 순서대로 저장한 배열을 return 하는 solution 함수를 완성해 주세요.
18.1.1 파이썬
from typing import List
def solution(myString:str) -> List[int]:
return [len(s) for s in myString.split('x')]18.1.2 러스트
fn solution(my_string: &str) -> Vec<usize> {
my_string.split('x').map(|s| s.len()).collect()
}
fn main() {
let my_string = "examplexstringxhere"; // Example input
let result = solution(my_string);
println!("{:?}", result);
}18.2 문자열 잘라서 정렬하기
문자열 myString이 주어집니다. “x”를 기준으로 해당 문자열을 잘라내 배열을 만든 후 사전순으로 정렬한 배열을 return 하는 solution 함수를 완성해 주세요. 단, 빈 문자열은 반환할 배열에 넣지 않습니다.
18.2.1 파이썬
from typing import List
def solution(myString: str) -> List[int]:
return sorted([s for s in myString.split('x') if s])18.2.2 러스트
fn solution(my_string: &str) -> Vec<String> {
let mut result: Vec<String> = my_string.split('x')
.filter(|s| !s.is_empty())
.map(String::from)
.collect();
result.sort();
result
}
fn main() {
let my_string = "axbxcxxdxe"; // Example input
let result = solution(my_string);
println!("{:?}", result);
}18.3 간단한 식 계산하기
문자열 binomial이 매개변수로 주어집니다. binomial은 “a op b” 형태의 이항식이고 a와 b는 음이 아닌 정수, op는 ‘+’, ‘-’, ’*’ 중 하나입니다. 주어진 식을 계산한 정수를 return 하는 solution 함수를 작성해 주세요.
18.3.1 파이썬
def solution(binomial: str) -> int:
a, op, b = binomial.split()
a, b = int(a), int(b)
if op == '+':
return a + b
elif op == '-':
return a - b
else: # op == '*'
return a * b18.3.2 러스트
fn solution(binomial: &str) -> i32 {
let parts: Vec<&str> = binomial.split_whitespace().collect();
let a: i32 = parts[0].parse().unwrap();
let op: &str = parts[1];
let b: i32 = parts[2].parse().unwrap();
match op {
"+" => a + b,
"-" => a - b,
_ => a * b, // Assumes '*' for any other operator
}
}
fn main() {
let binomial = "3 + 4";
let result = solution(binomial);
println!("Result: {}", result);
}18.4 문자열 바꿔서 찾기
문자 “A”와 “B”로 이루어진 문자열 myString과 pat가 주어집니다. myString의 “A”를 “B”로, “B”를 “A”로 바꾼 문자열의 연속하는 부분 문자열 중 pat이 있으면 1을 아니면 0을 return 하는 solution 함수를 완성하세요.
18.4.1 파이썬
def solution(myString: str, pat: str) -> int:
# myString의 "A"를 "B"로, "B"를 "A"로 바꾸는 함수
def swap(s):
return ''.join('A' if c == 'B' else 'B' for c in s)
# myString을 변환하고 pat이 포함되어 있는지 확인
return 1 if swap(pat) in myString else 018.4.2 러스트
fn swap(s: &str) -> String {
s.chars().map(|c| match c {
'A' => 'B',
'B' => 'A',
_ => c,
}).collect()
}
fn solution(my_string: &str, pat: &str) -> i32 {
if my_string.contains(&swap(pat)) {
1
} else {
0
}
}
fn main() {
let my_string = "ABBAA";
let pat = "AABB";
let result = solution(my_string, pat);
println!("Result: {}", result);
}18.5 rny_string
’m’과 “rn”이 모양이 비슷하게 생긴 점을 활용해 문자열에 장난을 하려고 합니다. 문자열 rny_string이 주어질 때, rny_string의 모든 ’m’을 “rn”으로 바꾼 문자열을 return 하는 solution 함수를 작성해 주세요.
18.5.1 파이썬
def solution(rny_string: str) -> str:
return rny_string.replace('m', 'rn')18.5.2 러스트
fn solution(rny_string: &str) -> String {
rny_string.replace("m", "rn")
}
fn main() {
let input = "programmer";
let result = solution(input);
println!("Result: {}", result);
}19 Day 19 문자열, 리스트(배열)
19.1 세 개의 구분자
임의의 문자열이 주어졌을 때 문자 “a”, “b”, “c”를 구분자로 사용해 문자열을 나누고자 합니다.
예를 들어 주어진 문자열이 “baconlettucetomato”라면 나눠진 문자열 목록은 ["onlettu", "etom", "to"] 가 됩니다.
문자열 myStr이 주어졌을 때 위 예시와 같이 “a”, “b”, “c”를 사용해 나눠진 문자열을 순서대로 저장한 배열을 return 하는 solution 함수를 완성해 주세요.
단, 두 구분자 사이에 다른 문자가 없을 경우에는 아무것도 저장하지 않으며, return할 배열이 빈 배열이라면 ["EMPTY"]를 return 합니다.
19.1.1 파이썬
import re
from typing import List
def solution(myStr: str) -> List[str]:
# 'a', 'b', 'c'를 구분자로 사용하여 문자열을 분할
parts = re.split('[abc]', myStr)
# 빈 문자열을 제거하고 남은 부분들만 저장
answer = [part for part in parts if part]
# 결과 배열이 비어있으면 ["EMPTY"] 반환
return answer if answer else ["EMPTY"]19.1.2 러스트
use regex::Regex;
fn solution(my_str: &str) -> Vec<String> {
// 'a', 'b', 'c'를 구분자로 사용하여 문자열을 분할
let re = Regex::new("[abc]").unwrap();
let parts: Vec<&str> = re.split(my_str).collect();
// 빈 문자열을 제거하고 남은 부분들만 저장
let mut answer: Vec<String> = parts.into_iter().filter(|part| !part.is_empty()).map(String::from).collect();
// 결과 배열이 비어있으면 ["EMPTY"] 반환
if answer.is_empty() {
answer.push("EMPTY".to_string());
}
answer
}
fn main() {
let input = "baconlettucetomato"; // Example input
let result = solution(input);
println!("{:?}", result);
}19.2 배열의 원소만큼 추가하기
아무 원소도 들어있지 않은 빈 배열 X가 있습니다. 양의 정수 배열 arr가 매개변수로 주어질 때, arr의 앞에서부터 차례대로 원소를 보면서 원소가 a라면 X의 맨 뒤에 a를 a번 추가하는 일을 반복한 뒤의 배열 X를 return 하는 solution 함수를 작성해 주세요.
19.2.1 파이썬
from typing import List
def solution(arr: List[int]) -> List[int]:
answer = []
for num in arr:
answer.extend([num] * num)
return answer19.2.2 러스트
fn solution(arr: Vec<i32>) -> Vec<i32> {
let mut answer = Vec::new();
for &num in &arr {
answer.extend(vec![num; num as usize]);
}
answer
}
fn main() {
let input = vec![1, 2, 3]; // Example input
let result = solution(input);
println!("{:?}", result);
}19.3 빈 배열에 추가, 삭제하기
아무 원소도 들어있지 않은 빈 배열 X가 있습니다. 길이가 같은 정수 배열 arr과 boolean 배열 flag가 매개변수로 주어질 때, flag를 차례대로 순회하며 flag[i]가 true라면 X의 뒤에 arr[i]를 arr[i] × 2 번 추가하고, flag[i]가 false라면 X에서 마지막 arr[i]개의 원소를 제거한 뒤 X를 return 하는 solution 함수를 작성해 주세요.
19.3.1 파이썬
from typing import List
def solution(arr: List[int], flag: List[bool]) -> List[int]:
answer = []
for i, f in enumerate(flag):
if f:
answer.extend([arr[i]] * (arr[i] * 2))
else:
answer = answer[:-arr[i]] if arr[i] <= len(answer) else []
return answer19.3.2 러스트
fn solution(arr: Vec<i32>, flag: Vec<bool>) -> Vec<i32> {
let mut answer = Vec::new();
for (i, &f) in flag.iter().enumerate() {
if f {
answer.extend(vec![arr[i]; (arr[i] * 2) as usize]);
} else {
let remove_count = arr[i] as usize;
if remove_count <= answer.len() {
answer.truncate(answer.len() - remove_count);
} else {
answer.clear();
}
}
}
answer
}
fn main() {
let arr = vec![3, 2, 4, 1, 3];
let flag = vec![true, false, true, false, false];
let result = solution(arr, flag);
println!("{:?}", result);
}19.4 배열 만들기 6
0과 1로만 이루어진 정수 배열 arr가 주어집니다. arr를 이용해 새로운 배열 stk을 만드려고 합니다.
i의 초기값을 0으로 설정하고 i가 arr의 길이보다 작으면 다음을 반복합니다.
- 만약 stk이 빈 배열이라면
arr[i]를 stk에 추가하고 i에 1을 더합니다. - stk에 원소가 있고, stk의 마지막 원소가
arr[i]와 같으면 stk의 마지막 원소를 stk에서 제거하고 i에 1을 더합니다. - stk에 원소가 있는데 stk의 마지막 원소가
arr[i]와 다르면 stk의 맨 마지막에arr[i]를 추가하고 i에 1을 더합니다. 위 작업을 마친 후 만들어진 stk을 return 하는 solution 함수를 완성해 주세요. 단, 만약 빈 배열을 return 해야한다면 [-1]을 return 합니다.
19.4.1 파이썬
from typing import List
def solution(arr: List[int]) -> List[int]:
stk = []
i = 0
while i < len(arr):
if not stk:
stk.append(arr[i])
i += 1
elif stk[-1] == arr[i]:
stk.pop()
i += 1
else:
stk.append(arr[i])
i += 1
return stk if stk else [-1]19.4.2 러스트
fn solution(arr: Vec<i32>) -> Vec<i32> {
let mut stk = Vec::new();
let mut i = 0;
while i < arr.len() {
if stk.is_empty() {
stk.push(arr[i]);
i += 1;
} else if *stk.last().unwrap() == arr[i] {
stk.pop();
i += 1;
} else {
stk.push(arr[i]);
i += 1;
}
}
if stk.is_empty() {
vec![-1]
} else {
stk
}
}
fn main() {
let arr = vec![1, 1, 3, 3, 0, 1, 1];
let result = solution(arr);
println!("{:?}", result);
}19.5 무작위로 k의 수 뽑기
랜덤으로 서로 다른 k개의 수를 저장한 배열을 만드려고 합니다. 적절한 방법이 떠오르지 않기 때문에 일정한 범위 내에서 무작위로 수를 뽑은 후, 지금까지 나온적이 없는 수이면 배열 맨 뒤에 추가하는 방식으로 만들기로 합니다.
이미 어떤 수가 무작위로 주어질지 알고 있다고 가정하고, 실제 만들어질 길이 k의 배열을 예상해봅시다.
정수 배열 arr가 주어집니다. 문제에서의 무작위의 수는 arr에 저장된 순서대로 주어질 예정이라고 했을 때, 완성될 배열을 return 하는 solution 함수를 완성해 주세요.
단, 완성될 배열의 길이가 k보다 작으면 나머지 값을 전부 -1로 채워서 return 합니다.
19.5.1 파이썬
from typing import List
def solution(arr: List[int], k: int) -> List[int]:
unique_nums = []
seen = set()
for num in arr:
if num not in seen and len(unique_nums) < k:
unique_nums.append(num)
seen.add(num)
if len(unique_nums) == k:
break
# k개의 숫자를 채우지 못했다면 -1로 채움
while len(unique_nums) < k:
unique_nums.append(-1)
return unique_nums19.5.2 러스트
use std::collections::HashSet;
fn solution(arr: Vec<i32>, k: usize) -> Vec<i32> {
let mut unique_nums = Vec::new();
let mut seen = HashSet::new();
for &num in &arr {
if !seen.contains(&num) && unique_nums.len() < k {
unique_nums.push(num);
seen.insert(num);
}
if unique_nums.len() == k {
break;
}
}
// k개의 숫자를 채우지 못했다면 -1로 채움
while unique_nums.len() < k {
unique_nums.push(-1);
}
unique_nums
}
fn main() {
let arr = vec![0, 1, 1, 2, 2, 3];
let k = 3;
let result = solution(arr, k);
println!("{:?}", result);
}20 Day 20 함수(메서드)
20.1 배열의 길이를 2의 거듭제곱으로 만들기
정수 배열 arr이 매개변수로 주어집니다. arr의 길이가 2의 정수 거듭제곱이 되도록 arr 뒤에 정수 0을 추가하려고 합니다. arr에 최소한의 개수로 0을 추가한 배열을 return 하는 solution 함수를 작성해 주세요.
20.1.1 파이썬
from typing import List
def solution(arr: List[int]) -> List[int]:
n = len(arr)
target_length = 1
while target_length < n:
target_length *= 2
return arr + [0] * (target_length - n)20.1.2 러스트
fn solution(arr: Vec<i32>) -> Vec<i32> {
let n = arr.len();
let mut target_length = 1;
while target_length < n {
target_length *= 2;
}
let mut result = arr.clone();
result.extend(vec![0; target_length - n]);
result
}
fn main() {
let arr = vec![1, 2, 3]; // Example input
let result = solution(arr);
println!("{:?}", result);
}20.2 배열 비교하기
이 문제에서 두 정수 배열의 대소관계를 다음과 같이 정의합니다.
- 두 배열의 길이가 다르다면, 배열의 길이가 긴 쪽이 더 큽니다.
- 배열의 길이가 같다면 각 배열에 있는 모든 원소의 합을 비교하여 다르다면 더 큰 쪽이 크고, 같다면 같습니다.
두 정수 배열 arr1과 arr2가 주어질 때, 위에서 정의한 배열의 대소관계에 대하여 arr2가 크다면 -1, arr1이 크다면 1, 두 배열이 같다면 0을 return 하는 solution 함수를 작성해 주세요.
20.2.1 파이썬
from typing import List
def solution(arr1: List[int], arr2: List[int]) -> int:
if len(arr1) != len(arr2):
return -1 if len(arr2) > len(arr1) else 1
sum1, sum2 = sum(arr1), sum(arr2)
if sum1 != sum2:
return -1 if sum2 > sum1 else 1
return 020.2.2 러스트
fn solution(arr1: Vec<i32>, arr2: Vec<i32>) -> i32 {
if arr1.len() != arr2.len() {
return if arr2.len() > arr1.len() { -1 } else { 1 };
}
let sum1: i32 = arr1.iter().sum();
let sum2: i32 = arr2.iter().sum();
if sum1 != sum2 {
return if sum2 > sum1 { -1 } else { 1 };
}
0
}
fn main() {
let arr1 = vec![1, 2, 3]; // Example input
let arr2 = vec![3, 2, 1]; // Example input
let result = solution(arr1, arr2);
println!("{}", result);
}20.3 문자열 묶기
문자열 배열 strArr이 주어집니다. strArr의 원소들을 길이가 같은 문자열들끼리 그룹으로 묶었을 때 가장 개수가 많은 그룹의 크기를 return 하는 solution 함수를 완성해 주세요.
20.3.1 파이썬
from collections import Counter
from typing import List
def solution(strArr: List[str]) -> int:
length_counts = Counter(len(s) for s in strArr)
return max(length_counts.values())20.3.2 러스트
use std::collections::HashMap;
fn solution(str_arr: Vec<&str>) -> usize {
let mut length_counts = HashMap::new();
for s in &str_arr {
let len = s.len();
*length_counts.entry(len).or_insert(0) += 1;
}
*length_counts.values().max().unwrap_or(&0)
}
fn main() {
let str_arr = vec!["apple", "banana", "cherry", "date", "fig", "grape"];
let result = solution(str_arr);
println!("{}", result);
}20.4 배열의 길이에 따라 다른 연산하기
정수 배열 arr과 정수 n이 매개변수로 주어집니다. arr의 길이가 홀수라면 arr의 모든 짝수 인덱스 위치에 n을 더한 배열을, arr의 길이가 짝수라면 arr의 모든 홀수 인덱스 위치에 n을 더한 배열을 return 하는 solution 함수를 작성해 주세요.
20.4.1 파이썬
from typing import List
def solution(arr: List[int], n: str) -> List[int]:
if len(arr) % 2 == 1: # 배열의 길이가 홀수인 경우
return [num + n if i % 2 == 0 else num for i, num in enumerate(arr)]
else: # 배열의 길이가 짝수인 경우
return [num + n if i % 2 == 1 else num for i, num in enumerate(arr)]20.4.2 러스트
use std::collections::HashMap;
fn solution(str_arr: Vec<&str>) -> usize {
let mut length_counts = HashMap::new();
for s in &str_arr {
let len = s.len();
*length_counts.entry(len).or_insert(0) += 1;
}
*length_counts.values().max().unwrap_or(&0)
}
fn main() {
let str_arr = vec!["apple", "banana", "cherry", "date", "fig", "grape"];
let result = solution(str_arr);
println!("{}", result);
}20.5 뒤에서 5등까지
정수로 이루어진 리스트 num_list가 주어집니다. num_list에서 가장 작은 5개의 수를 오름차순으로 담은 리스트를 return하도록 solution 함수를 완성해주세요.
20.5.1 파이썬
from typing import List
def solution(num_list: List[int]) -> List[int]:
return sorted(num_list)[:5]20.5.2 러스트
fn solution(mut num_list: Vec<i32>) -> Vec<i32> {
num_list.sort();
num_list.into_iter().take(5).collect()
}
fn main() {
let num_list = vec![10, 3, 5, 8, 2, 7, 1, 4, 6, 9]; // Example input
let result = solution(num_list);
println!("{:?}", result);
}21 Day 21 함수(메서드)
21.1 뒤에서 5등 위로
수로 이루어진 리스트 num_list가 주어집니다. num_list에서 가장 작은 5개의 수를 제외한 수들을 오름차순으로 담은 리스트를 return하도록 solution 함수를 완성해주세요. ### 파이썬
from typing import List
def solution(num_list: List[int]) -> List[int]:
return sorted(num_list)[5:]21.1.1 러스트
fn solution(mut num_list: Vec<i32>) -> Vec<i32> {
num_list.sort();
num_list.split_off(5)
}
fn main() {
let num_list = vec![12, 4, 15, 46, 38, 1, 14, 56, 32, 10];
let result = solution(num_list);
println!("Result: {:?}", result);
}21.2 전국 대회 선발 고사
0번부터 n - 1번까지 n명의 학생 중 3명을 선발하는 전국 대회 선발 고사를 보았습니다. 등수가 높은 3명을 선발해야 하지만, 개인 사정으로 전국 대회에 참여하지 못하는 학생들이 있어 참여가 가능한 학생 중 등수가 높은 3명을 선발하기로 했습니다.
각 학생들의 선발 고사 등수를 담은 정수 배열 rank와 전국 대회 참여 가능 여부가 담긴 boolean 배열 attendance가 매개변수로 주어집니다. 전국 대회에 선발된 학생 번호들을 등수가 높은 순서대로 각각 a, b, c번이라고 할 때 10000 × a + 100 × b + c를 return 하는 solution 함수를 작성해 주세요.
21.2.1 파이썬
from typing import List
def solution(rank: List[int], attendance: List[bool]) -> int:
# 참석 가능한 학생들의 등수와 번호를 저장
available = [(r, i) for i, r in enumerate(rank) if attendance[i]]
# 등수를 기준으로 정렬
available.sort()
# 상위 3명 선택
top_3 = available[:3]
# 결과 계산
return 10000 * top_3[0][1] + 100 * top_3[1][1] + top_3[2][1]21.2.2 러스트
fn solution(rank: Vec<i32>, attendance: Vec<bool>) -> i32 {
let mut available: Vec<(i32, usize)> = rank.iter()
.enumerate()
.filter(|&(i, _)| attendance[i])
.map(|(i, &r)| (r, i))
.collect();
available.sort_by_key(|&(r, _)| r);
let top_3: Vec<&(i32, usize)> = available.iter().take(3).collect();
10000 * top_3[0].1 as i32 + 100 * top_3[1].1 as i32 + top_3[2].1 as i32
}
fn main() {
let rank = vec![3, 1, 2, 4];
let attendance = vec![true, false, true, true];
let result = solution(rank, attendance);
println!("Result: {}", result);
}21.3 정수 부분
실수 flo가 매개 변수로 주어질 때, flo의 정수 부분을 return하도록 solution 함수를 완성해주세요.
21.3.1 파이썬
def solution(flo: float) -> int:
return int(flo)21.3.2 러스트
fn solution(flo: f64) -> i32 {
flo as i32
}
fn main() {
let test_cases = vec![1.42, 69.32, 3.14, 0.0, -1.5];
for flo in test_cases {
let result = solution(flo);
println!("입력: {}, 결과: {}", flo, result);
}
}21.4 문자열 정수의 합
한 자리 정수로 이루어진 문자열 num_str이 주어질 때, 각 자리수의 합을 return하도록 solution 함수를 완성해주세요. ### 파이썬
def solution(num_str: str) -> int:
return sum(int(digit) for digit in num_str)21.4.1 러스트
fn solution(num_str: &str) -> i32 {
num_str.chars()
.filter_map(|c| c.to_digit(10))
.map(|d| d as i32)
.sum()
}
fn main() {
let test_cases = vec!["123", "456", "789", "0", "9999"];
for num_str in test_cases {
let result = solution(num_str);
println!("입력: {}, 결과: {}", num_str, result);
}
}21.5 문자열을 정수로 변환하기
숫자로만 이루어진 문자열 n_str이 주어질 때, n_str을 정수로 변환하여 return하도록 solution 함수를 완성해주세요. ### 파이썬
def solution(n_str:str) -> int:
return int(n_str)21.5.1 러스트
fn solution(n_str: &str) -> i32 {
n_str.parse().unwrap()
}
fn main() {
let test_cases = vec!["123", "456", "789", "0", "9999"];
for n_str in test_cases {
let result = solution(n_str);
println!("입력: {}, 결과: {}", n_str, result);
}
}22 Day 22 함수(메서드), 조건문 활용
22.1 0 떼기
정수로 이루어진 문자열 n_str이 주어질 때, n_str의 가장 왼쪽에 처음으로 등장하는 0들을 뗀 문자열을 return하도록 solution 함수를 완성해주세요. ### 파이썬
def solution(n_str:str) -> str:
return str(int(n_str))22.1.1 러스트
fn solution(n_str: &str) -> String {
n_str.parse::<i32>().unwrap().to_string()
}
fn main() {
let test_cases = vec!["00123", "0456", "000789", "0", "0000"];
for n_str in test_cases {
let result = solution(n_str);
println!("입력: {}, 결과: {}", n_str, result);
}
}22.2 두 수의 합
0 이상의 두 정수가 문자열 a, b로 주어질 때, a + b의 값을 문자열로 return 하는 solution 함수를 작성해 주세요. ### 파이썬
def solution(a: str, b: str) -> str:
return str(int(a) + int(b))22.2.1 러스트
fn solution(a: &str, b: &str) -> String {
(a.parse::<i32>().unwrap() + b.parse::<i32>().unwrap()).to_string()
}
fn main() {
let test_cases = vec![("123", "456"), ("100", "200"), ("0", "0"), ("999", "1")];
for (a, b) in test_cases {
let result = solution(a, b);
println!("입력: ({} + {}), 결과: {}", a, b, result);
}
}22.3 문자열로 변환
정수 n이 주어질 때, n을 문자열로 변환하여 return하도록 solution 함수를 완성해주세요. ### 파이썬
def solution(n: int) -> str:
return str(n)22.3.1 러스트
fn solution(n: i32) -> String {
n.to_string()
}
fn main() {
let test_cases = vec![123, 456, 789, 0, -42];
for n in test_cases {
let result = solution(n);
println!("입력: {}, 결과: {}", n, result);
}
}22.4 배열의 원소 삭제하기
정수 배열 arr과 delete_list가 있습니다. arr의 원소 중 delete_list의 원소를 모두 삭제하고 남은 원소들은 기존의 arr에 있던 순서를 유지한 배열을 return 하는 solution 함수를 작성해 주세요. ### 파이썬
from typing import List
def solution(arr: List[int], delete_list: List[int]) -> List[int]:
return [x for x in arr if x not in delete_list]22.4.1 러스트
fn solution(arr: Vec<i32>, delete_list: Vec<i32>) -> Vec<i32> {
arr.into_iter().filter(|&x| !delete_list.contains(&x)).collect()
}
fn main() {
let arr = vec![1, 2, 3, 4, 5];
let delete_list = vec![2, 4];
let result = solution(arr, delete_list);
println!("Result: {:?}", result);
}22.5 부분 문자열인지 확인하기
부분 문자열이란 문자열에서 연속된 일부분에 해당하는 문자열을 의미합니다. 예를 들어, 문자열 “ana”, “ban”, “anana”, “banana”, “n”는 모두 문자열 “banana”의 부분 문자열이지만, “aaa”, “bnana”, “wxyz”는 모두 “banana”의 부분 문자열이 아닙니다.
문자열 my_string과 target이 매개변수로 주어질 때, target이 문자열 my_string의 부분 문자열이라면 1을, 아니라면 0을 return 하는 solution 함수를 작성해 주세요.
22.5.1 파이썬
def solution(my_string: str, target: str) -> int:
return int(target in my_string)22.5.2 러스트
fn solution(my_string: &str, target: &str) -> i32 {
my_string.contains(target) as i32
}
fn main() {
let test_cases = vec![
("abcdef", "ab"),
("hello world", "bye"),
("Python", "on"),
("Rust", "rust"),
];
for (my_string, target) in test_cases {
let result = solution(my_string, target);
println!("my_string: '{}', target: '{}', 결과: {}", my_string, target, result);
}
}23 Day 23 조건문 활용
23.1 부분 문자열
어떤 문자열 A가 다른 문자열 B안에 속하면 A를 B의 부분 문자열이라고 합니다. 예를 들어 문자열 “abc”는 문자열 “aabcc”의 부분 문자열입니다.
문자열 str1과 str2가 주어질 때, str1이 str2의 부분 문자열이라면 1을 부분 문자열이 아니라면 0을 return하도록 solution 함수를 완성해주세요. ### 파이썬
def solution(str1: str, str2: str) -> int:
return 1 if str1 in str2 else 023.1.1 러스트
fn solution(str1: &str, str2: &str) -> i32 {
if str2.contains(str1) { 1 } else { 0 }
}
fn main() {
let test_cases = vec![
("abc", "abcdef"),
("hello", "world"),
("rust", "Rust is great"),
("", "empty"),
];
for (str1, str2) in test_cases {
let result = solution(str1, str2);
println!("str1: '{}', str2: '{}', 결과: {}", str1, str2, result);
}
}23.2 꼬리 문자열
문자열들이 담긴 리스트가 주어졌을 때, 모든 문자열들을 순서대로 합친 문자열을 꼬리 문자열이라고 합니다. 꼬리 문자열을 만들 때 특정 문자열을 포함한 문자열은 제외시키려고 합니다. 예를 들어 문자열 리스트 ["abc", "def", "ghi"]가 있고 문자열 “ef”를 포함한 문자열은 제외하고 꼬리 문자열을 만들면 “abcghi”가 됩니다.
문자열 리스트 str_list와 제외하려는 문자열 ex가 주어질 때, str_list에서 ex를 포함한 문자열을 제외하고 만든 꼬리 문자열을 return하도록 solution 함수를 완성해주세요. ### 파이썬
from typing import List
def solution(str_list: List[str], ex: str) -> str:
return ''.join([s for s in str_list if ex not in s])23.2.1 러스트
fn solution(str_list: Vec<String>, ex: &str) -> String {
str_list.into_iter()
.filter(|s| !s.contains(ex))
.collect()
}
fn main() {
let str_list = vec!["hello".to_string(), "world".to_string(), "example".to_string(), "rust".to_string()];
let ex = "ex";
let result = solution(str_list, ex);
println!("Result: {}", result);
}23.3 정수 찾기
정수 리스트 num_list와 찾으려는 정수 n이 주어질 때, num_list안에 n이 있으면 1을 없으면 0을 return하도록 solution 함수를 완성해주세요. ### 파이썬
from typing import List
def solution(num_list: List[int], n: int) -> int:
return int(n in num_list)23.3.1 러스트
fn solution(num_list: Vec<i32>, n: i32) -> i32 {
num_list.contains(&n) as i32
}
fn main() {
let test_cases = vec![
(vec![1, 2, 3, 4, 5], 3),
(vec![15, 98, 23, 45, 67], 20),
(vec![0, 0, 0], 0),
(vec![-1, -2, -3], -2),
];
for (num_list, n) in test_cases {
let result = solution(num_list.clone(), n);
println!("num_list: {:?}, n: {}, 결과: {}", num_list, n, result);
}
}23.4 주사위 게임 1
1부터 6까지 숫자가 적힌 주사위가 두 개 있습니다. 두 주사위를 굴렸을 때 나온 숫자를 각각 a, b라고 했을 때 얻는 점수는 다음과 같습니다.
- a와 b가 모두 홀수라면 \(a2 + b2\) 점을 얻습니다.
- a와 b 중 하나만 홀수라면 \(2 × (a + b)\) 점을 얻습니다.
- a와 b 모두 홀수가 아니라면 \(|a - b|\) 점을 얻습니다.
두 정수 a와 b가 매개변수로 주어질 때, 얻는 점수를 return 하는 solution 함수를 작성해 주세요. ### 파이썬
def solution(a: int, b: int) -> int:
if a % 2 == 1 and b % 2 == 1:
return a**2 + b**2
elif a % 2 == 1 or b % 2 == 1:
return 2 * (a + b)
else:
return abs(a - b)23.4.1 러스트
fn solution(a: i32, b: i32) -> i32 {
if a % 2 == 1 && b % 2 == 1 {
a.pow(2) + b.pow(2)
} else if a % 2 == 1 || b % 2 == 1 {
2 * (a + b)
} else {
(a - b).abs()
}
}
fn main() {
let test_cases = vec![(3, 5), (2, 4), (3, 4), (7, 7), (6, 6)];
for (a, b) in test_cases {
let result = solution(a, b);
println!("a: {}, b: {}, result: {}", a, b, result);
}
}23.5 날짜 비교하기
정수 배열 date1과 date2가 주어집니다. 두 배열은 각각 날짜를 나타내며 \([year, month, day]\) 꼴로 주어집니다. 각 배열에서 year는 연도를, month는 월을, day는 날짜를 나타냅니다. 만약 date1이 date2보다 앞서는 날짜라면 1을, 아니면 0을 return 하는 solution 함수를 완성해 주세요.
23.5.1 파이썬
from typing import List
def solution(date1:List[int], date2:List[int]) -> int:
for i in range(3):
if date1[i] < date2[i]:
return 1
elif date1[i] > date2[i]:
return 0
return 023.5.2 러스트
fn solution(date1: Vec<i32>, date2: Vec<i32>) -> i32 {
for i in 0..3 {
if date1[i] < date2[i] {
return 1;
} else if date1[i] > date2[i] {
return 0;
}
}
0
}
fn main() {
let test_cases = vec![
(vec![2021, 12, 28], vec![2021, 12, 29]),
(vec![1024, 10, 24], vec![1024, 10, 24]),
(vec![2022, 1, 1], vec![2021, 12, 31]),
];
for (date1, date2) in test_cases {
let result = solution(date1.clone(), date2.clone());
println!("date1: {:?}, date2: {:?}, result: {}", date1, date2, result);
}
}24 Day 24 조건문 활용, 반복문 활용, 이차원 리스트(배열)
24.1 커피 심부름
팀의 막내인 철수는 아메리카노와 카페 라테만 판매하는 카페에서 팀원들의 커피를 사려고 합니다. 아메리카노와 카페 라테의 가격은 차가운 것과 뜨거운 것 상관없이 각각 4500, 5000원입니다. 각 팀원에게 마실 메뉴를 적어달라고 하였고, 그 중에서 메뉴만 적은 팀원의 것은 차가운 것으로 통일하고 “아무거나”를 적은 팀원의 것은 차가운 아메리카노로 통일하기로 하였습니다.
각 직원이 적은 메뉴가 문자열 배열 order로 주어질 때, 카페에서 결제하게 될 금액을 return 하는 solution 함수를 작성해주세요. order의 원소는 아래의 것들만 들어오고, 각각의 의미는 다음과 같습니다. ### 파이썬
from typing import List
def solution(order: List[str]) -> int:
total = 0
for drink in order:
if 'cafelatte' in drink:
total += 5000
else:
total += 4500
return total24.1.1 러스트
fn solution(order: Vec<String>) -> i32 {
let mut total = 0;
for drink in order {
if drink.contains("cafelatte") {
total += 5000;
} else {
total += 4500;
}
}
total
}
fn main() {
let test_orders = vec![
vec!["cafelatte".to_string(), "americano".to_string(), "cafelatte".to_string()],
vec!["americano".to_string(), "americano".to_string()],
vec!["cafelatte".to_string(), "americano".to_string(), "espresso".to_string()],
];
for order in test_orders {
let total = solution(order.clone());
println!("Order: {:?}, Total: {}", order, total);
}
}24.2 그림 확대
직사각형 형태의 그림 파일이 있고, 이 그림 파일은 1 × 1 크기의 정사각형 크기의 픽셀로 이루어져 있습니다. 이 그림 파일을 나타낸 문자열 배열 picture과 정수 k가 매개변수로 주어질 때, 이 그림 파일을 가로 세로로 k배 늘린 그림 파일을 나타내도록 문자열 배열을 return 하는 solution 함수를 작성해 주세요.
24.2.1 파이썬
from typing import List
def solution(picture: List[str], k: int) -> List[str]:
result = []
for row in picture:
expanded_row = ''.join([char * k for char in row])
for _ in range(k):
result.append(expanded_row)
return result24.2.2 러스트
fn solution(picture: Vec<String>, k: usize) -> Vec<String> {
let mut result = Vec::new();
for row in picture {
let expanded_row: String = row.chars().flat_map(|c| std::iter::repeat(c).take(k)).collect();
for _ in 0..k {
result.push(expanded_row.clone());
}
}
result
}
fn main() {
let picture = vec!["abc".to_string(), "def".to_string()];
let k = 2;
let result = solution(picture, k);
println!("{:?}", result);
}24.3 조건에 맞게 수열 변환하기 3
정수 배열 arr와 자연수 k가 주어집니다. 만약 k가 홀수라면 arr의 모든 원소에 k를 곱하고, k가 짝수라면 arr의 모든 원소에 k를 더합니다. 이러한 변환을 마친 후의 arr를 return 하는 solution 함수를 완성해 주세요.
24.3.1 파이썬
from typing import List
def solution(arr: List[int], k: int) -> List[int]:
if k % 2 == 1: # k가 홀수인 경우
return [num * k for num in arr]
else: # k가 짝수인 경우
return [num + k for num in arr]24.3.2 러스트
fn solution(arr: Vec<i32>, k: i32) -> Vec<i32> {
if k % 2 == 1 {
arr.into_iter().map(|num| num * k).collect()
} else {
arr.into_iter().map(|num| num + k).collect()
}
}24.4 l로 만들기
알파벳 소문자로 이루어진 문자열 myString이 주어집니다. 알파벳 순서에서 “l”보다 앞서는 모든 문자를 “l”로 바꾼 문자열을 return 하는 solution 함수를 완성해 주세요. ### 파이썬
def solution(myString: str) -> str:
return ''.join(['l' if c < 'l' else c for c in myString])24.4.1 러스트
fn solution(my_string: &str) -> String {
my_string.chars().map(|c| if c < 'l' { 'l' } else { c }).collect()
}
fn main() {
let test_cases = vec!["abcdevwxyz", "jjnnllkkmm", "task"];
for case in test_cases {
let result = solution(case);
println!("Input: {}, Output: {}", case, result);
}
}24.5 특별한 이차원 배열 1
정수 n이 매개변수로 주어질 때, 다음과 같은 \(n × n\) 크기의 이차원 배열 arr를 return 하는 solution 함수를 작성해 주세요. - \(arr[i][j] (0 ≤ i, j < n)의 값은 i = j라면 1, 아니라면 0입니다.\)
24.5.1 파이썬
from typing import List
def solution(n: int) -> List[List[int]]:
return [[1 if i == j else 0 for j in range(n)] for i in range(n)]24.5.2 러스트
fn solution(n: usize) -> Vec<Vec<i32>> {
(0..n).map(|i|
(0..n).map(|j|
if i == j { 1 } else { 0 }
).collect()
).collect()
}
fn main() {
let test_cases = vec![3, 5, 2];
for n in test_cases {
let result = solution(n);
println!("n = {}:", n);
for row in &result {
println!("{:?}", row);
}
println!();
}
}25 Day 25 이차원 리스트(배열)
25.1 정수를 나선형으로 배치하기
양의 정수 n이 매개변수로 주어집니다. \(n × n\) 배열에 1부터 n2 까지 정수를 인덱스 \([0][0]\)부터 시계방향 나선형으로 배치한 이차원 배열을 return 하는 solution 함수를 작성해 주세요.
25.1.1 파이썬
from typing import List
def solution(n:int) -> List[int]:
# n x n 크기의 2차원 배열 초기화
answer = [[0 for _ in range(n)] for _ in range(n)]
# 시작 위치와 방향 설정
x, y = 0, 0
dx, dy = 0, 1 # 처음에는 오른쪽으로 이동
# 1부터 n^2까지 숫자 채우기
for i in range(1, n*n + 1):
answer[x][y] = i
# 다음 위치 계산
nx, ny = x + dx, y + dy
# 방향 전환이 필요한 경우
if nx < 0 or nx >= n or ny < 0 or ny >= n or answer[nx][ny] != 0:
# 방향 전환 (시계 방향)
dx, dy = dy, -dx
nx, ny = x + dx, y + dy
x, y = nx, ny
return answer25.1.2 러스트
fn solution(n: usize) -> Vec<Vec<usize>> {
let mut answer = vec![vec![0; n]; n]; // Initialize a 2D array with zeros
let (mut x, mut y) = (0, 0); // Starting position
let (mut dx, mut dy) = (0, 1); // Initial direction: right
for i in 1..=n * n {
answer[x][y] = i; // Fill the current cell
// Calculate the next position
let (nx, ny) = (x as isize + dx, y as isize + dy);
// Check if we need to change direction
if nx < 0 || nx >= n as isize || ny < 0 || ny >= n as isize || answer[nx as usize][ny as usize] != 0 {
// Change direction (clockwise)
let (new_dx, new_dy) = (dy, -dx);
dx = new_dx;
dy = new_dy;
}
// Update position
x = (x as isize + dx) as usize;
y = (y as isize + dy) as usize;
}
answer
}25.2 특별한 이차원 배열 2
\(n × n\) 크기의 이차원 배열 arr이 매개변수로 주어질 때, arr이 다음을 만족하면 1을 아니라면 0을 return 하는 solution 함수를 작성해 주세요.
- \(0 ≤ i, j < n인 정수 i, j에 대하여 arr[i][j] = arr[j][i]\)
25.2.1 파이썬
from typing import List
def solution(arr: List[List[int]]) -> int:
n = len(arr)
for i in range(n):
for j in range(n):
if arr[i][j] != arr[j][i]:
return 0
return 125.2.2 러스트
fn solution(arr: Vec<Vec<i32>>) -> i32 {
let n = arr.len();
for i in 0..n {
for j in 0..n {
if arr[i][j] != arr[j][i] {
return 0;
}
}
}
1
}
fn main() {
let test_cases = vec![
vec![vec![5, 192, 33], vec![192, 72, 95], vec![33, 95, 999]],
vec![vec![19, 498, 258, 587], vec![63, 93, 7, 754], vec![258, 7, 1000, 723], vec![587, 754, 723, 81]],
];
for (index, case) in test_cases.iter().enumerate() {
let result = solution(case.to_vec());
println!("Test case {}: {}", index + 1, result);
}
}25.3 정사각형으로 만들기
이차원 정수 배열 arr이 매개변수로 주어집니다. arr의 행의 수가 더 많다면 열의 수가 행의 수와 같아지도록 각 행의 끝에 0을 추가하고, 열의 수가 더 많다면 행의 수가 열의 수와 같아지도록 각 열의 끝에 0을 추가한 이차원 배열을 return 하는 solution 함수를 작성해 주세요. ### 파이썬
from typing import List
def solution(arr: List[List[int]]) -> List[List[int]]:
rows = len(arr)
cols = len(arr[0])
max_size = max(rows, cols)
result = []
for row in arr:
new_row = row + [0] * (max_size - len(row))
result.append(new_row)
while len(result) < max_size:
result.append([0] * max_size)
return result25.3.1 러스트
fn solution(arr: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
let rows = arr.len();
let cols = arr[0].len();
let max_size = rows.max(cols);
let mut result = Vec::new();
for row in arr {
let mut new_row = row;
new_row.resize(max_size, 0);
result.push(new_row);
}
result.resize_with(max_size, || vec![0; max_size]);
result
}
fn main() {
let test_cases = vec![
vec![vec![1, 2], vec![3, 4]],
vec![vec![1], vec![2]],
vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]],
];
for (i, case) in test_cases.iter().enumerate() {
let result = solution(case.to_vec());
println!("Test case {}:", i + 1);
for row in result {
println!("{:?}", row);
}
println!();
}
}25.4 이차원 배열 대각선 순회하기
2차원 정수 배열 board와 정수 k가 주어집니다. \(i + j <= k\)를 만족하는 모든 \((i, j)\)에 대한 board[i][j]의 합을 return 하는 solution 함수를 완성해 주세요.
25.4.1 파이썬
from typing import List
def solution(board: List[List[int]], k: int) -> int:
answer = 0
for i in range(len(board)):
for j in range(len(board[0])):
if i + j <= k:
answer += board[i][j]
return answer25.4.2 러스트
fn solution(board: Vec<Vec<i32>>, k: i32) -> i32 {
let mut answer = 0;
for i in 0..board.len() {
for j in 0..board[0].len() {
if (i as i32 + j as i32) <= k {
answer += board[i][j];
}
}
}
answer
}
fn main() {
let board = vec![
vec![0, 1, 2],
vec![1, 2, 3],
vec![2, 3, 4],
];
let k = 2;
let result = solution(board, k);
println!("Result: {}", result);
}