7번 과제 안 내신 분

문제

X대학 M교수님은 프로그래밍 수업을 맡고 있다. 교실엔 학생이 30명이 있는데, 학생 명부엔 각 학생별로 1번부터 30번까지 출석번호가 붙어 있다. 

 

교수님이 내준 특별과제를 28명이 제출했는데, 그중에서 제출 안 한 학생 2명의 출석번호를 구하는 프로그램을 작성하시오.

 

입력

입력은 총 28줄로 각 제출자(학생)의 출석번호 n(1 ≤ n ≤ 30)가 한 줄에 하나씩 주어진다. 출석번호에 중복은 없다.

 

출력

출력은 2줄이다. 1번째 줄엔 제출하지 않은 학생의 출석번호 중 가장 작은 것을 출력하고, 2번째 줄에선 그다음 출석번호를 출력한다.

 

배열 사이즈는 학생 수만큼, 각 인덱스에는 다음 입력에서 들어오는 과제를 제출한 학생의 출석번호 - 1의 인덱스에 체크를 해준다.

 

C++

#include <iostream>
#include <vector>
using namespace std;
int main(){
    vector<int> num_vec(30);
    for (int i = 0; i < 28; i++){
        int num;
        cin >> num;
        num_vec[num - 1] = 1;
    }
    int count = 1;
    for (int i : num_vec){
        if (i != 1){
            cout << count << "\n";
        }
        count++;
    }
    return 0;
}

 

과제를 제출한 학생의 인덱스는 1의 값으로 체크해 두고 출력 시 확인한다.

 

C#

using System;
using System.Collections.Generic;
class Program{
    static void Main(string[] args){
        List<int> num_list = new List<int>(new int[30]);
        for (int i = 0; i < 28; i++){
            int num = int.Parse(Console.ReadLine());
            num_list[num - 1] = 1;
        }
        int count = 1;
        foreach(int i in num_list){
            if (i != 1)
                Console.WriteLine(count);
            count++;
        }
    }
}

 

Python

num_list = [0] * 30
for i in range(28):
    num = int(input())
    num_list[num - 1] = 1
count = 1
for i in range(30):
    if num_list[i] != 1:
        print(f"{count}")
    count += 1

 

8번 나머지

문제

두 자연수 A와 B가 있을 때, A% B는 A를 B로 나눈 나머지이다. 예를 들어, 7, 14, 27, 38을 3으로 나눈 나머지는 1, 2, 0, 2이다. 

 

수 10개를 입력받은 뒤, 이를 42로 나눈 나머지를 구한다. 그다음 서로 다른 값이 몇 개 있는지 출력하는 프로그램을 작성하시오.

 

입력

첫째 줄부터 열 번째 줄 까지 숫자가 한 줄에 하나씩 주어진다. 이 숫자는 1,000보다 작거나 같고, 음이 아닌 정수이다.

 

출력

첫째 줄에, 42로 나누었을 때, 서로 다른 나머지가 몇 개 있는지 출력한다.

 

입력받은 수를 42로 나누고 나머지를 저장해 둔다. 이 나머지 중에서 서로 다른 것들만 출력한다.

입력되는 수의 범위는 0이 아닌 1000 이하의 정수이다. 배열에 나머지를 저장할 때 요소에 해당 나머지가 없을 때만 저장해 둔다.

 

C++

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
    int num, remain;
    vector<int> num_vec;
    for (int i = 0; i < 10; i++){
        cin >> num;
        remain = num % 42;
        if (find(num_vec.begin(), num_vec.end(), remain) == num_vec.end()){
            num_vec.push_back(remain);
        }
    }
    cout << num_vec.size();
    return 0;
}

 

find를 사용해서 배열에 해당 요소가 있는지 검색 후 없으면 추가한다.

 

C#

using System;
using System.Collections.Generic;
class Program{
    static void Main(string[] args){
        List<int> num_list = new List<int>();
        for (int i = 0; i < 10; i++){
            int num = int.Parse(Console.ReadLine());
            int remain = num % 42;
            if (!num_list.Contains(remain)){
                num_list.Add(remain);
            }
        }
        Console.WriteLine(num_list.Count);
    }
}

 

List는 Contains를 사용해서 요소를 포함하고 있는지 확인할 수 있다.

 

Python

num_list = []
for i in range(10):
    num = int(input());
    remain = num % 42
    if remain not in num_list:
        num_list.append(remain)
print(len(num_list))

 

파이썬의 경우 조건문의 문법에서 리스트의 요소를 검색해 볼 수 있다.

 

Node.js

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin','utf8').split('\n').map(Number);
const list = [];
for (let i = 0; i < 10; i++){
    const num = input[i];
    const remain = num % 42;
    if (!list.includes(remain)){
        list.push(remain);
    }
}
console.log(list.length);

 

includes를 사용해서 배열을 탐색하고 push로 값을 넣는다.

 

9번 바구니 뒤집기

문제

도현이는 바구니를 총 N개 가지고 있고, 각각의 바구니에는 1번부터 N번까지 번호가 순서대로 적혀 있다. 바구니는 일렬로 놓여 있고, 가장 왼쪽 바구니를 1번째 바구니, 그다음 바구니를 2번째 바구니,..., 가장 오른쪽 바구니를 N번째 바구니라고 부른다. 

 

도현이는 앞으로 M번 바구니의 순서를 역순으로 만들려고 한다. 도현이는 한 번 순서를 역순으로 바꿀 때, 순서를 역순으로 만들 범위를 정하고, 그 범위에 들어있는 바구니의 순서를 역순으로 만든다. 

 

바구니의 순서를 어떻게 바꿀지 주어졌을 때, M번 바구니의 순서를 역순으로 만든 다음, 바구니에 적혀있는 번호를 가장 왼쪽 바구니부터 출력하는 프로그램을 작성하시오.

 

입력

첫째 줄에 N (1 ≤ N ≤ 100)과 M (1 ≤ M ≤ 100)이 주어진다. 

 

둘째 줄부터 M개의 줄에는 바구니의 순서를 역순으로 만드는 방법이 주어진다. 방법은 i j로 나타내고, 왼쪽으로부터 i번째 바구니부터 j번째 바구니의 순서를 역순으로 만든다는 뜻이다. (1 ≤ i ≤ j ≤ N) 

 

도현이는 입력으로 주어진 순서대로 바구니의 순서를 바꾼다.

 

출력

모든 순서를 바꾼 다음에, 가장 왼쪽에 있는 바구니부터 바구니에 적혀있는 순서를 공백으로 구분해 출력한다.

 

N크기의 배열의 특정 인덱스 범위의 순서를 M번 뒤집는 작업을 하고 최종 출력한다.

 

C++

#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
using namespace std;
int main(){
    int n, m, i, j;
    cin >> n >> m;
    vector<int> num_vec(n);
    iota(num_vec.begin(), num_vec.end(), 1);
    for (int k = 0; k < m; k++){
        cin >> i >> j;
        reverse(num_vec.begin() + i - 1, num_vec.begin() + j);
    }
    for (int l : num_vec){
        cout << l << " ";
    }
    return 0;
}

 

reverse를 사용해서 배열의 특정 인덱스 범위에서 요소를 뒤집는다.

 

C#

using System;
using System.Collections.Generic;
using System.Linq;
class Program{
    static void Main(string[] args){
        int n, m, i, j;
        int[] info = Console.ReadLine().Split().Select(int.Parse).ToArray();
        n = info[0];
        m = info[1];
        List<int> num_list = Enumerable.Range(1, n).ToList();
        for (int k = 0; k < m; k++){
            int[] data = Console.ReadLine().Split().Select(int.Parse).ToArray();
            i = data[0] - 1;
            j = data[1] - 1;
            num_list.Reverse(i, j - i + 1);
        }
        Console.WriteLine(string.Join(" ", num_list));
    }
}

 

Reverse 함수를 사용해서 특정한 범위의 인덱스 값을 뒤지어준다. 이때 인수는 시작 인덱스와 개수이다. 

 

Python

info_list = list(map(int, input().split()))
n = info_list[0]
m = info_list[1]
num_list = list(range(1, n + 1))
for k in range(m):
    idxs = list(map(int, input().split()))
    i = idxs[0] - 1
    j = idxs[1] - 1
    num_list[i:j+1] = num_list[i:j+1][::-1]
print(" ".join(map(str, num_list)))

 

num_list [i:j+1] = num_list [i:j+1][::-1] 

 

파이썬의 슬라이싱을 사용해서 배열의 인덱스를 특정해서 순서를 바꾸는 방법이다.

 

배열의 순서를 뒤집는 방법에는 몇 가지 있다.

 

reverse()

# reverse()
num_list = [1, 2, 3, 4, 5]
num_list.reverse()
print(num_list)  # [5, 4, 3, 2, 1]

 

reverse를 사용하면 원본 리스트의 요소가 뒤집어진다.

 

슬라이싱

# Slicing
num_list = [1, 2, 3, 4, 5]
reversed_list = num_list[::-1]
print(reversed_list)  # [5, 4, 3, 2, 1]

 

슬라이싱을 사용하면 해당 리스트의 요소를 뒤집은 새로운 리스트를 생성한다.

 

reversed()

num_list = [1, 2, 3, 4, 5]
reversed_list = list(reversed(num_list))
print(reversed_list)  # [5, 4, 3, 2, 1]

 

reversed 함수를 사용하면 리스트의 역순으로 정렬된 반복자를 반환한다. 이 반환값을 다시 리스트로 변환하면 뒤집어진 리스트를 만들 수 있다.

 

Node.js

const fs = require('fs');
const info_list = fs.readFileSync('/dev/stdin','utf8').split('\n');
const [n,m] = info_list[0].split(' ').map(Number);
let num_list = Array.from({ length: n }, (_, index) => index + 1);
for (k = 1; k <= m; k++){
    const [i, j] = info_list[k].split(' ').map(Number);
    const start = i - 1;
    const end = j - 1; 
    num_list.splice(start, end - start + 1, ...num_list.slice(start, end + 1).reverse());
}
console.log(num_list.join(' '));

 

 

splice 함수는 배열의 특정 범위를 제거하거나 추가할 때 사용한다. 

array.splice(start, deleteCount, item1, item2, ...)

 

start는 필수 매개변수로 deleteCount를 따로 지정하지 않으면 start부터 인덱스 끝까지 제거한다.

 

item 매개변수들은 선택 사항으로 start 인덱스 뒤에 item을 배열에 추가한다.

 

10번 평균

문제

세준이는 기말고사를 망쳤다. 세준이는 점수를 조작해서 집에 가져가기로 했다. 일단 세준이는 자기 점수 중에 최댓값을 골랐다. 이 값을 M이라고 한다. 그러고 나서 모든 점수를 '점수/M*100'으로 고쳤다. 

 

예를 들어, 세준이의 최고점이 70이고, 수학점수가 50이었으면 수학점수는 50/70*100이 되어 71.43점이 된다. 

 

세준이의 성적을 위의 방법대로 새로 계산했을 때, 새로운 평균을 구하는 프로그램을 작성하시오.

 

입력

첫째 줄에 시험 본 과목의 개수 N이 주어진다. 이 값은 1000보다 작거나 같다. 둘째 줄에 세준이의 현재 성적이 주어진다. 이 값은 100보다 작거나 같은 음이 아닌 정수이고, 적어도 하나의 값은 0보다 크다.

 

출력

첫째 줄에 새로운 평균을 출력한다. 실제 정답과 출력값의 절대오차 또는 상대오차가 10^-2 이하이면 정답이다.

 

기말고사를 망친 세준이의 성적을 조작한다.

 

최고 점수를 사용해서 점수를 조작하고 조작된 점수들의 평균을 내서 출력한다.

C++

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;
int main(){
    int n;
    cin >> n;
    vector<float> num_vec(n);
    for (int i = 0; i < n; i++){
        float score;
        cin >> score;
        num_vec[i] = score;
    }
    auto max_iter = max_element(num_vec.begin(), num_vec.end());
    float max_val = *max_iter;
    for (int i = 0; i < n; i++){
        num_vec[i] = num_vec[i] / max_val * 100;
    }
    float sum = accumulate(num_vec.begin(), num_vec.end(), 0.0f);
    cout << sum / n;
    return 0;
}

 

본래의 성적을 저장하고 최대 값을 구한 뒤 조작한 성적을 다시 배열에 저장하고 합산하여 평균을 구한다.

 

accumulate 함수를 사용해서 배열 요소들의 합을 구한다.

 

C#

using System;
using System.Collections.Generic;
using System.Linq;
class Program{
    static void Main(string[] args){
        int n = int.Parse(Console.ReadLine());
        List<float> num_list = Console.ReadLine().Split().Select(float.Parse).ToList();
        float max_val = num_list.Max();
        for (int i = 0; i < n; i++){
            num_list[i] = num_list[i] / max_val * 100;
        }
        float sum = num_list.Sum();
        Console.WriteLine(sum / n);
    }
}

 

List.Sum() 함수는 요소의 합산을 구할 수 있다.

 

Python

n = int(input())
num_list = map(float, input().split(' '))
max_val = max(num_list);
for i in range(n):
    num_list[i] = num_list[i] / max_val * 100
sum_val = sum(num_list)
print(f"{sum_val / n}")

 

Node.js

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin','utf8').split('\n');
const n = parseInt(input[0]);
const num_list = input[1].split(' ').map(Number);
const max = Math.max(...num_list);
for (let i = 0; i < n; i++){
    num_list[i] = num_list[i] / max * 100;
}
const sum = num_list.reduce((acc, curr) => acc + curr, 0);
console.log(sum / n);

 

Math.max를 사용할 때는 스프레드 연산자로 매개변수를 전달해야 한다.

728x90
반응형

4번 최댓값

문제

9개의 서로 다른 자연수가 주어질 때, 이들 중 최댓값을 찾고 그 최댓값이 몇 번째 수인지를 구하는 프로그램을 작성하시오. 

 

예를 들어, 서로 다른 9개의 자연수 3, 29, 38, 12, 57, 74, 40, 85, 61 이 주어지면, 이들 중 최댓값은 85이고, 이 값은 8번째 수이다.

 

입력

첫째 줄부터 아홉 번째 줄까지 한 줄에 하나의 자연수가 주어진다. 주어지는 자연수는 100 보다 작다.

 

출력

첫째 줄에 최댓값을 출력하고, 둘째 줄에 최댓값이 몇 번째 수인지를 출력한다.

 

C++

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
    int n;
    vector<int> vec;
    while(cin >> n){
        vec.push_back(n);
    }
    auto iter = max_element(vec.begin(), vec.end());
    int index = distance(vec.begin(), iter);
    cout << *iter << "\n" << index + 1;
    return 0;
}

 

distance 함수를 사용해서 iter가 해당 벡터에서 몇 번째 인덱스인지 구한다.

 

C#

using System;
using System.Collections.Generic;
using System.Linq;
class Program{
    static void Main(string[] args){
        List<int> num_list = new List<int>();
        for (int i = 0; i < 9; i++){
            int val = int.Parse(Console.ReadLine());
            num_list.Add(val);
        }
        int max = num_list.Max();
        int index = num_list.IndexOf(max);
        Console.WriteLine($"{max}\n{index+1}");
    }
}

 

Python

num_list = []
for i in range(9):
    num_list.append(int(input()))
max_val = max(num_list)
index = num_list.index(max_val)
print(max_val)
print(index + 1)

 

[]로 가변 배열을 선언한다. 이 배열은 기본 타입인 list와 동일한 타입의 객체이다.

 num_list = list()와 동일한 객체

이 객체는 apeend를 사용해서 값을 추가할 수 있고 index로 요소의 인덱스를 검색할 수 있다.

 

Node.js

const fs = require('fs');
const num_list = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n').map(Number);
const max_num = Math.max(...num_list);
const index = num_list.indexOf(max_num);
console.log(max_num);
console.log(index + 1);

 

indexOf 메서드로 최댓값의 인덱스를 찾을 수 있다.

 

5번 공 넣기

문제

도현이는 바구니를 총 N개 가지고 있고, 각각의 바구니에는 1번부터 N번까지 번호가 매겨져 있다. 또, 1번부터 N번까지 번호가 적혀있는 공을 매우 많이 가지고 있다. 가장 처음 바구니에는 공이 들어있지 않으며, 바구니에는 공을 1개만 넣을 수 있다.

 

도현이는 앞으로 M번 공을 넣으려고 한다. 도현이는 한 번 공을 넣을 때, 공을 넣을 바구니 범위를 정하고, 정한 바구니에 모두 같은 번호가 적혀있는 공을 넣는다. 만약, 바구니에 공이 이미 있는 경우에는 들어있는 공을 빼고, 새로 공을 넣는다. 공을 넣을 바구니는 연속되어 있어야 한다.

 

공을 어떻게 넣을지가 주어졌을 때, M번 공을 넣은 이후에 각 바구니에 어떤 공이 들어 있는지 구하는 프로그램을 작성하시오.

 

입력

첫째 줄에 N (1 ≤ N ≤ 100)과 M (1 ≤ M ≤ 100)이 주어진다.

 

둘째 줄부터 M개의 줄에 걸쳐서 공을 넣는 방법이 주어진다. 각 방법은 세 정수 i j k로 이루어져 있으며, i번 바구니부터 j번 바구니까지에 k번 번호가 적혀 있는 공을 넣는다는 뜻이다. 예를 들어, 2 5 6은 2번 바구니부터 5번 바구니까지에 6번 공을 넣는다는 뜻이다. (1 ≤ i ≤ j ≤ N, 1 ≤ k ≤ N)

 

도현이는 입력으로 주어진 순서대로 공을 넣는다.

 

출력

1번 바구니부터 N번 바구니에 들어있는 공의 번호를 공백으로 구분해 출력한다. 공이 들어있지 않은 바구니는 0을 출력한다.

 

나열된 바구니들을 배열 각 바구니들 인덱스로 보면 된다. 공에는 번호가 지정되어 있고 규칙에 맞춰 공을 바구니에 넣는다.

 

입력의 첫 줄에서 바구니의 개수 N과 바구니에 공을 담는 규칙 M개가 들어온다.

 

그다음에 M개의 줄에 각각 규칙이 들어오는데 순서대로 i j k 각 수는 i , j는 바구니의 범위, k는 넣을 공의 번호이다.

 

C++

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
    int n, m, i, j, k;
    cin >> n;
    cin >> m;
    vector<int> num_vec(n, 0);
    for (int l = 0; l < m; l++){
        cin >> i >> j >> k;
        fill(num_vec.begin() + i - 1, num_vec.begin() + j, k);
    }
     for (int num : num_vec) {
        cout << num << " ";
    }
    return 0;
}

 

컨테이너는 바구니의 개수만큼 사이즈를 만들고 값은 0으로 초기화해서 값이 없을 때 0으로 출력되도록 한다.

컨테이너의 범위 내에 특정 값을 채우기 위해서 fill 함수를 사용한다.

시작과 끝 범위, 채울 값을 인자로 받는다.

 

C#

using System;
using System.Collections.Generic;
using System.Linq;
class Program{
    static void Main(string[] args){
        int[] input = Console.ReadLine().Split().Select(int.Parse).ToArray();
        int n, m, i, j, k;
        n = input[0];
        m = input[1];
        List<int> num_list = new List<int>(new int[n]);
        for (int l = 0; l < m; l++){
            int[] rules = Console.ReadLine().Split().Select(int.Parse).ToArray();
            i = rules[0] - 1;
            j = rules[1] - 1;
            k = rules[2];
            for (int o = i; o <= j; o++){
                num_list[o] = k;
            }
        }
        
        foreach(int val in num_list){
            Console.Write($"{val} ");
        }
    }
}

 

리스트의 경우 특정 범위 내의 요소에 값을 넣을 때 사용할만한 메서드가 없어 이중 반복문으로 처리했다.

 

Python

input_val = list(map(int, input().split()))
n = input_val[0]
m = input_val[1]
num_list = [0] * n
for l in range(m):
    rules = list(map(int, input().split()))
    i = rules[0]
    j = rules[1]
    k = rules[2]
    for index in range(i - 1, j):
        num_list[index] = k
print(" ".join(map(str, num_list)))

 

Node.js

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin','utf8').split('\n');
const [n, m] = input[0].split(' ').map(Number);
let num_list = Array(n).fill(0);
for (let l = 1; l <= m; l++){
    const [i, j, k] = input[l].split(' ').map(Number);
    for (let idx = i - 1; idx < j; idx++){
        num_list[idx] = k;
    }
}
console.log(num_list.join(' '));

 

Array(n)로 n크기의 배열을 선언하고 fill(0)으로 값을 0으로 초기화한다.

 

6번 공 바꾸기

문제

도현이는 바구니를 총 N개 가지고 있고, 각각의 바구니에는 1번부터 N번까지 번호가 매겨져 있다. 바구니에는 공이 1개씩 들어있고, 처음에는 바구니에 적혀있는 번호와 같은 번호가 적힌 공이 들어있다. 

 

도현이는 앞으로 M번 공을 바꾸려고 한다. 도현이는 공을 바꿀 바구니 2개를 선택하고, 두 바구니에 들어있는 공을 서로 교환한다. 

 

공을 어떻게 바꿀지가 주어졌을 때, M번 공을 바꾼 이후에 각 바구니에 어떤 공이 들어있는지 구하는 프로그램을 작성하시오.

 

입력

첫째 줄에 N (1 ≤ N ≤ 100)과 M (1 ≤ M ≤ 100)이 주어진다. 

 

둘째 줄부터 M개의 줄에 걸쳐서 공을 교환할 방법이 주어진다. 각 방법은 두 정수 i j로 이루어져 있으며, i번 바구니와 j번 바구니에 들어있는 공을 교환한다는 뜻이다. (1 ≤ i ≤ j ≤ N) 

 

도현이는 입력으로 주어진 순서대로 공을 교환한다.

 

출력

1번 바구니부터 N번 바구니에 들어있는 공의 번호를 공백으로 구분해 출력한다.

 

N 사이즈의 배열에 요소들은 index+1 값으로 초기화한 상태로 시작된다.

 

C++

#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
using namespace std;
int main(){
    int n, m, i, j;
    cin >> n >> m;
    vector<int> num_vec(n);
    iota(num_vec.begin(), num_vec.end(), 1);
    for (int k = 0; k < m; k++){
        cin >> i >> j;
        swap(num_vec[i - 1], num_vec[j - 1]);
    }
    for (int num : num_vec){
        cout << num << " ";
    }
    return 0;
}

 

iota 함수를 사용해서 컨테이너의 각 요소를 인덱스  + 1의 값으로 초기화한다.

algorithm의 swap 함수를 사용해서 컨테이너의 두 인덱스의 값을 교환한다.

 

C#

using System;
using System.Collections.Generic;
using System.Linq;
class Program{
    static void Main(string[] args){
        int[] input = Console.ReadLine().Split().Select(int.Parse).ToArray();
        int n = input[0];
        int m = input[1];
        List<int> num_list = new List<int>(Enumerable.Range(1, n));
        
        for (int l = 0; l < m; l++){
            int[] data = Console.ReadLine().Split().Select(int.Parse).ToArray();
            int i = data[0] - 1;
            int j = data[1] - 1;
            int tmp = num_list[i];
            num_list[i] = num_list[j];
            num_list[j] = tmp;
        }
        foreach(int num in num_list){
            Console.Write(num + " ");
        }
    }
}

 

new List <int>(Enumerable.Range(1, n)) 으로 각 요소를 1부터 n으로 초기화한다.

 

Python

input_str = list(map(int, input().split()))
n = input_str[0]
m = input_str[1]
num_list = list(range(1, n + 1))
for _ in range(m):
    i, j = map(int, input().split())
    num_list[i - 1], num_list[j - 1] = num_list[j - 1], num_list[i - 1]
print(" ".join(map(str, num_list)))

 

파이썬에서 리스트를 초기화할 때 range(1, n + 1) 초기화 시 값을 인덱스 + 1로 값을 넣는다.

 

출력 시 현재 리스트는 정수타입이므로 문자열로 변환 후 값마다 띄어쓰기를 추가해서 출력한다.

 

Node.js

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin', 'utf8').split('\n');
const [n, m] = input[0].split(' ').map(Number);
let num_list = Array.from({ length : n }, (_, i) => i + 1);
for (let k = 1; k <= m; k++){
    const [i, j] = input[k].split(' ').map(Number);
    [num_list[i - 1], num_list[j - 1]] = [num_list[j - 1], num_list[i - 1]];
}
console.log(num_list.join(' '));

 

Array.from({length : n}, (_, i) => i+1) 이렇게 인덱스 + 1로 각 요소들의 값을 초기화할 수 있다.

값을 교환하는 코드는 파이썬과 동일한 문법으로 우선 좌항과 우항의 오른쪽에 위치한 배열들의 값이 평가되면서 추출된다. 그리고 추출된 값들이 왼쪽에 대응하는 변수에 할당되면서 요소의 교환이 이루어진다. 

728x90
반응형

3번 최소, 최대

문제

N개의 정수가 주어진다. 이때, 최솟값과 최댓값을 구하는 프로그램을 작성하시오.

 

입력

첫째 줄에 정수의 개수 N (1 ≤ N ≤ 1,000,000)이 주어진다. 둘째 줄에는 N개의 정수를 공백으로 구분해서 주어진다. 모든 정수는 -1,000,000보다 크거나 같고, 1,000,000보다 작거나 같은 정수이다.

 

출력

첫째 줄에 주어진 정수 N개의 최솟값과 최댓값을 공백으로 구분해 출력한다.

 

C++

vector를 사용해서 풀어본다.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
    int n;
    cin >> n;
    vector<int> vec(n);
    for (int i = 0; i < n; i++){
        cin >> vec[i];
    }
    vector<int>::iterator min_iter = min_element(vec.begin(), vec.end());
    vector<int>::iterator max_iter = max_element(vec.begin(), vec.end());
    cout << *min_iter << " " << *max_iter;
    return 0;
}

 

vector는 가변 배열이지만 사이즈를 특정해서 고정 크기로 사용할 수 있다.

algorithm을 사용해서 배열 안에서 min, max 요소를 찾아서 반복자를 반환받아서 값을 출력한다.

min, max_element 함수가 반복자를 반환하는 이유는 중복된 값을 저장할 필요 없이 컨테이너의 요소를 직접 참조할 수 있으며 컨테이너의 종류에 상관없이 유연하게 사용할 수 있기 때문이다. 또한 반복자에 접근해서 컨테이너의 요소를 직접 조작할 수도 있다.

 

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
    int n;
    cin >> n;
    vector<int> vec;
    for (int i = 0; i < n; i++){
        int val;
        cin >> val;
        vec.push_back(val);
    }
    vector<int>::iterator min_iter = min_element(vec.begin(), vec.end());
    vector<int>::iterator max_iter = max_element(vec.begin(), vec.end());
    cout << *min_iter << " " << *max_iter;
    return 0;
}

 

가변적으로 사용할 때는 push_back을 사용하면 된다.

 

C#

using System;
using System.Collections.Generic;
using System.Linq;
class Program{
    static void Main(string[] args){
        int n = int.Parse(Console.ReadLine());
        string[] input_arr = Console.ReadLine().Split(' ');
        List<int> num_list = new List<int>();
        for (int i = 0; i < n; i++){
            num_list.Add(int.Parse(input_arr[i]));
        }
        int min = num_list.Min();
        int max = num_list.Max();
        Console.WriteLine($"{min} {max}");
    }
}

 

C#에서는 List <T>를 사용할 수 있다. List는 Collections.Generic에 포함되어 있고 Min, Max를 사용하기 위해서 Linq도 사용한다.

 

리스트에 값을 넣는 과정도 Select와 ToList를 사용하면 한 번에 초기화할 수 있다.

string[] input_arr = Console.ReadLine().Split(' ');
List<int> num_list = new List<int>();
for (int i = 0; i < n; i++){
    num_list.Add(int.Parse(input_arr[i]));
}

//================================================
List<int> numbers = Console.ReadLine().Split(' ').Select(int.Parse).ToList();

 

Linq는 이외에도 배열이나 컬렉션 등을 처리할 때 유용한 기능들을 제공하기 때문에 함께 사용하는 경우가 많다. 하지만 강력한 기능인만큼 많은 메모리를 사용하기 때문에 주의해야 한다.

 

Python

n = int(input())
num_list = list(map(int, input().split()))
min_val = min(num_list)
max_val = max(num_list)
print(f"{min_val} {max_val}")

 

파이썬은 list()를 사용할 수 있다.

map은 해당 함수가 반복 가능한 객체의 각 요소에 대해 적용된 결과를 반환하는 map객체를 생성하는데 이 객체는 필요에 따라 리스트나 튜플로 변환하여 사용할 수 있다.

map을 사용해서 입력되는 값을 공백으로 구분하고 각 문자열을 정수로 변환하여 반환되는 map으로 list를 초기화한다.

 

Node.js

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin','utf8').split('\n');
const n = parseInt(input[0]);
const nums = input[1].split(' ').map(Number);
let min_val = nums[0];
let max_val = nums[0];
for (int i = 1; i < n; i++){
    if (nums[i] < min_val)
        min_val = nums[i]
    else if (nums[i] > max_val)
        max_val = nums[i]
}
console.log(`${min_val} ${max_val}`);

 

js도 map을 사용해서 배열을 초기화시킬 수 있다. 입력받은 값을 Number함수로 각 요소를 숫자로 변환한 map을 반환한다.

 

최대 최소를 구하는 방법은 함수를 쓰지 않고 각 요소들의 크기를 작으면 min, 크면 max로 비교하여 구할 수 있다.

 

js에서도 최대 최솟값을 구하는 Math.min, Math.max를 지원한다.

 

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin','utf8').split('\n');
const n = parseInt(input[0]);
const nums = input[1].split(' ').map(Number);
const min_val = Math.min(...nums);
const max_val = Math.max(...nums);
console.log(`${min_val} ${max_val}`);

 

728x90
반응형

1번 개수 세기

문제 

총 N개의 정수가 주어졌을 때, 정수 v가 몇 개인지 구하는 프로그램을 작성하시오.

 

입력

첫째 줄에 정수의 개수 N(1 ≤ N ≤ 100)이 주어진다. 둘째 줄에는 정수가 공백으로 구분되어 있다. 셋째 줄에는 찾으려고 하는 정수 v가 주어진다. 입력으로 주어지는 정수와 v는 -100보다 크거나 같으며, 100보다 작거나 같다.

 

출력

첫째 줄에 입력으로 주어진 N개의 정수 중에 v가 몇 개인지 출력한다.

 

배열에 저장하고 조건에 맞는 값을 출력한다.

 

C++

#include <iostream>
using namespace std;
int main(){
    int n, v, count;
    cin >> n;
    int arr[n];
    for (int i = 0; i < n; i++){
        cin >> arr[i];
    }
    
    cin >> v;
    for (int i = 0; i < n; i++){
        if (arr[i] == v)
            count++;
    }
    cout << count;
    return 0;
}

 

입력될 크기인 n 만큼의 크기의 배열을 선언하고 반복문으로 배열에 값들을 저장한다.

 

그리고 v의 입력을 받아 반복문으로 배열을 순회하면서 같은 값인 경우 count를 증가시키고 최종 개수를 출력한다.

 

C#

using System;
class Program{
    static void Main(string[] args){
        int n = int.Parse(Console.ReadLine());
        int[] arr = new int[n];
        string input = Console.ReadLine().Trim();
        string[] input_arr = input.Split(' ');
        for (int i = 0; i < n; i++){
            arr[i] = int.Parse(input_arr[i]);
        }
        int v = int.Parse(Console.ReadLine());
        int count = 0;
        for (int i = 0; i < n; i++){
            if (arr[i] == v)
                count++;
        }
        Console.WriteLine(count);
    }
}

 

Python

n = int(input())
values = input().strip().split(' ')
arr = [0] * n
for i in range(n):
    arr[i] = int(values[i]);
v = int(input())
count = 0;
for i in range(n):
    if arr[i] == v:
        count += 1
print(count)

 

Node.js

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin','utf8').split('\n');
const n = parseInt(input[0]);
const values = input[1].split(' ');
const v = parseInt(input[2]);
let count = 0;
const val_arr = new Array(n);
for (let i = 0; i < n; i++){
    val_arr[i] = parseInt(values[i]);
}
for (let i = 0; i < n; i++){
    if (val_arr[i] === v)
        count++;
}
console.log(count);

 

더 효율적인 방법도 있지만 1차원 배열을 사용해서 푸는걸 중점으로 두었기 때문에 불필요한 변수와 반복문이 사용되기도 한다.

 

2번 X보다 작은 수

문제

정수 N개로 이루어진 수열 A와 정수 X가 주어진다. 이때, A에서 X보다 작은 수를 모두 출력하는 프로그램을 작성하시오.

 

입력

첫째 줄에 N과 X가 주어진다. 

(1 ≤ N, X ≤ 10,000) 둘째 줄에 수열 A를 이루는 정수 N개가 주어진다. 주어지는 정수는 모두 1보다 크거나 같고, 10,000보다 작거나 같은 정수이다.

 

출력

X보다 작은 수를 입력받은 순서대로 공백으로 구분해 출력한다. X보다 작은 수는 적어도 하나 존재한다.

 

1번을 풀었던 것처럼 배열을 사용하는데 중점을 둔다.

 

C++

#include <iostream>
using namespace std;
int main(){
    cin.tie(NULL);
    ios_base::sync_with_stdio(false);
    int n, x;
    cin >> n;
    cin >> x;
    int arr[n];
    for (int i = 0; i < n; i++){
        cin >> arr[i];
    }
    for (int a : arr){
        if (a < x){
            cout << a << " ";
        }
    }
    return 0;
}

 

배열의 모든 요소를 순회할 때는 for (int a : arr)를 사용할 수 있다.

 

C#

using System;
class Program{
    static void Main(string[] args){
        string input = Console.ReadLine();
        string[] input_arr = input.Split(' ');
        int n = int.Parse(input_arr[0]);
        int x = int.Parse(input_arr[1]);
        input = Console.ReadLine();
        input_arr = input.Split(' ');
        int[] arr = new int[n];
        for (int i = 0; i < n; i++){
            arr[i] = int.Parse(input_arr[i]);
        }
        
        foreach(int a in arr){
            if (a < x){
                Console.Write($"{a} ");
            }
        }
    }
}

 

Python

n, x = map(int, input().split())
str_arr = input().split();
arr = [0] * n;
for i in range(n):
    arr[i] = int(str_arr[i])
for i in range(n):
    if arr[i] < x :
        print(f"{arr[i]} ", end="")

 

출력 시 print는 기본적으로 줄 바꿈을 실행하므로 end=""로 설정해서 줄 바꿈을 제거한다.

 

 

Node.js

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin','utf8').split('\n');
const [n, x] = input[0].split(' ').map(Number);
const values = input[1].split(' ').map(Number);
let result = [];
values.forEach(value => {
    if (value < x) {
        result.push(value);
    }
});

console.log(result.join(' '));

 

각각의 입력 값들을 정리하고 결과를 따로 배열에 저장한 뒤 일괄적으로 출력한다.

 

1, 2번 문제들은 고정 크기의 배열을 사용해서 풀었지만 가변 배열인 vector 나 list 등을 사용하면 더 간단하게 처리할 수 있는 문제이기 때문에 이후에는 가변 배열을 사용해서 풀어보기로 한다.

728x90
반응형

11번 A+B - 5

문제

두 정수 A와 B를 입력받은 다음, A+B를 출력하는 프로그램을 작성하시오.

 

입력

입력은 여러 개의 테스트 케이스로 이루어져 있다. 

각 테스트 케이스는 한 줄로 이루어져 있으며, 각 줄에 A와 B가 주어진다. (0 < A, B < 10) 

입력의 마지막에는 0 두 개가 들어온다.

 

출력

각 테스트 케이스마다 A+B를 출력한다.

 

이번에는 얼마나 반복할지 횟수를 정해주지 않고 마지막 케이스를 통해 루프를 종료하는 조건으로 사용하면 된다.

 

C++

#include <iostream>
using namespace std;
int main(){
    cin.tie(NULL);
    ios_base::sync_with_stdio(false);
    while(true){
        int a, b;
        cin >> a >> b;
        if (a + b == 0) break;
        else
            cout << a + b << "\n";
    }
}

 

두 값이 모두 0인 경우 반복문을 종료한다.

 

C#

using System;
class Program{
    static void Main(string[] args){
        using (StreamWriter writer = new StreamWriter(Console.OpenStandardOutput())){
            while(true){
                int a, b;
                string input = Console.ReadLine();
                string[] arr = input.Split(' ');
                a = int.Parse(arr[0]);
                b = int.Parse(arr[1]);
                if (a + b == 0) break;
                else
                    Console.WriteLine(a + b);
            }
        }
    }
}

 

Python

while True:
    input_str = input()
    arr = input_str.split(' ')
    a = int(arr[0])
    b = int(arr[1])
    if a + b == 0:
        break
    print(a + b)

 

파이썬의 while문 사용법을 숙지한다.

 

Node.js

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n');
for (const line of input){
    const [a, b] = line.split(' ').map(Number);
    if (a + b === 0) break;
    console.log(a + b);
}

 

js는 입력을 한 번에 받은 다음 줄 별로 처리해야 하기 때문에 while이 아닌 for를 사용해서 처리한다.

 

12번 A+B - 4

문제

두 정수 A와 B를 입력받은 다음, A+B를 출력하는 프로그램을 작성하시오.

 

입력

입력은 여러 개의 테스트 케이스로 이루어져 있다. 

각 테스트 케이스는 한 줄로 이루어져 있으며, 각 줄에 A와 B가 주어진다. (0 < A, B < 10)

 

출력

각 테스트 케이스마다 A+B를 출력한다.

 

반복문 챕터의 마지막 문제이다. 종료 조건을 어떠한 것도 주지 않은 상태로 입력이 끝날 때까지 반복하여 처리해야 한다.

 

C++

#include <iostream>
using namespace std;
int main(){
    int a, b;
    cin.tie(NULL);
    ios_base::sync_with_stdio(false);
    while(cin >> a >> b){
        if (a + b == 0)
            break;
        cout << a + b << "\n";
    }
    return 0;
}

 

cin >> a >> b를 조건으로 체크하여 입력이 더 이상 없는 경우를 판단한다.

 

조건으로 사용하게 되면 EOF(End of File)에 도달하여 더 이상 입력이 없거나 잘못된 값이 입력된 경우 반복문이 종료된다.

 

using System;
class Program{
    static void Main(string[] args){
        using (StreamWriter writer = new StreamWriter(Console.OpenStandardOutput())){
            while (true){
                string input = Console.ReadLine();
                if (input == null) break;
                string[] arr = input.Split(' ');
                int a = int.Parse(arr[0]);
                int b = int.Parse(arr[1]);
                Console.WriteLine(a+b);
            }
        }
    }
}


C#에서 string의 초기화값은 null이기 때문에 input이 없는지 확인하기 위해서 null과 비교하여 검사한다.

 

Python

import sys
input = sys.stdin.read
arr = input().splitlines()
for line in arr:
    a, b = map(int, line.split())
    print(a+b)

 

기존 input 함수를 표준 입력으로 변경하여 전체 입력된 정보를 저장한 다음 배열을 읽어서 처리하여 입력된 값들만 처리한다.

 

또 다른 방법으로는 입력이 더 이상 없을 때 발생하는 에러를 체크해서 루프를 종료시킬 수 있다.

 

while True:
    try:
        input_str = input()
    except EOFError:
        break
    arr = input_str.split()
    a = int(arr[0]);
    b = int(arr[1]);
    print(a+b)

 

에러가 발생하는 지점을 예외처리하기 위해서 try ~ except를 사용한다. 입력이 더 이상 없을 때는 EOFError를 리턴한다.

 

Node.js

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n');
for (const line of input){
    const[a, b] = line.split(' ').map(Number);
    console.log(a+b);
}

 

모든 입력을 줄 바꿈으로 끊어서 배열로 저장한다. 그리고 이 배열을 순회하면서 각각의 케이스를 처리한다.

728x90
반응형

7번 A+B - 7

문제

두 정수 A와 B를 입력받은 다음, A+B를 출력하는 프로그램을 작성하시오.

 

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 

각 테스트 케이스는 한 줄로 이루어져 있으며, 각 줄에 A와 B가 주어진다. (0 < A, B < 10)

 

출력

각 테스트 케이스마다 "Case #x: "를 출력한 다음, A+B를 출력한다. 테스트 케이스 번호는 1부터 시작한다.

 

C++

#include <iostream>
using namespace std;
int main(){
    int t;
    cin.tie(NULL);
    ios_base::sync_with_stdio(false);
    cin >> t;
    for (int i = 0; i < t; i++){
        int a, b;
        cin >> a >> b;
        cout << "Case #" << i + 1 << ": " << a + b << "\n";
    }
    
    return 0;
}

 

C#

using System;
class Program{
    static void Main(string[] args){
        int t = int.Parse(Console.ReadLine());
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()));
        for (int i = 0; i < t; i++){
            int a, b;
            string input = Console.ReadLine();
            string[] arr = input.Split(' ');
            a = int.Parse(arr[0]);
            b = int.Parse(arr[1]);
            Console.WriteLine($"Case #{i+1}: {a+b}");
        }
        Console.Out.Flush();
    }
}

 

Python

import sys
t = int(input());
for i in range(t):
    input_str = sys.stdin.readline().rstrip()
    arr = input_str.split(' ');
    a = int(arr[0])
    b = int(arr[1])
    print(f"Case #{i+1}: {a+b}")

 

Node.js

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin','utf8').trim().split('\n');
const t = parseInt(input[0], 10);
const output = [];
for (let i = 1; i <= t; i++){
    const[a,b] = input[i].split(' ').map(Number);
    output.push(`Case #${i}: ${a+b}`);
}
console.log(output.join('\n'));

 

readFileSync에서 utf8로 명시적으로 인코딩해주지 않으면 반환되는 데이터가 기본적으로 Buffer 객체이므로 문자열 메서드와 함께 사용할 때 에러가 발생할 수 있다.

 

8번 A+B - 8

문제

두 정수 A와 B를 입력받은 다음, A+B를 출력하는 프로그램을 작성하시오.

 

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 

각 테스트 케이스는 한 줄로 이루어져 있으며, 각 줄에 A와 B가 주어진다. (0 < A, B < 10)

 

출력

각 테스트 케이스마다 "Case #x: A + B = C" 형식으로 출력한다. x는 테스트 케이스 번호이고 1부터 시작하며, C는 A+B이다.

 

C++

#include <iostream>
using namespace std;
int main(){
    int t;
    cin.tie(NULL);
    ios_base::sync_with_stdio(false);
    cin >> t;
    for (int i = 0; i < t; i++){
        int a, b;
        cin >> a >> b;
        cout << "Case #" << i + 1 << ": " << a << " + " << b << " = " << a+b << "\n";
    }
    return 0;
}

 

C#

using System;
class Program{
    static void Main(string[] args){
        int t = int.Parse(Console.ReadLine());
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()));
        for (int i = 0; i < t; i++){
            string input = Console.ReadLine();
            string[] arr = input.Split(' ');
            int a = int.Parse(arr[0]);
            int b = int.Parse(arr[1]);
            Console.WriteLine($"Case #{i+1}: {a} + {b} = {a+b}");
        }
        Console.Out.Flush();
    }
}

 

Python

import sys
t = int(input())
for i in range(t):
    input_str = sys.stdin.readline().rstrip()
    arr = input_str.split()
    a = int(arr[0])
    b = int(arr[1])
    print(f"Case #{i+1}: {a} + {b} = {a+b}")

 

Node.js

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n');
const t = parseInt(input[0], 10);
const output = [];
for (let i = 1; i <= t; i++){
    const[a,b] = input[i].split(' ').map(Number);
    output.push(`Case #${i}: ${a} + ${b} = ${a+b}`);
}
console.log(output.join('\n'));

 

7, 8번 문제들은 출력 형식만 다르고 앞에 풀었던 문제와 동일한 방식으로 해결되기 때문에 크게 설명할 내용은 없다.

 

9번 별 찍기 - 1 

문제

첫째 줄에는 별 1개, 둘째 줄에는 별 2개, N번째 줄에는 별 N개를 찍는 문제

 

입력

첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다.

 

출력

첫째 줄부터 N번째 줄까지 차례대로 별을 출력한다.

 

C++

string(size_t count, char ch)를 사용해서 count 만큼 문자를 출력하도록 만들어 본다.

#include <iostream>
#include <string>
using namespace std;
int main() {
    int n;
    cin.tie(NULL);
    ios_base::sync_with_stdio(false);
    cin >> n;
    for (int i = 1; i <= n; i++) {
        string stars(i, '*');
        cout << stars << "\n";
    }
    return 0;
}

 

C#

using System;
class Program{
    static void Main(string[] args){
        int n = int.Parse(Console.ReadLine());
        using(StreamWriter writer = new StreamWriter(Console.OpenStandardOutput())){
            for (int i = 1; i <= n; i++){
                string stars = new string('*', i);
                Console.WriteLine(stars);
            }
        }
    }
}

 

C#은 new string(char, count)로 사용이 가능하다. 단일 문자를 반복하는 것이기 때문에 문자열이 아닌 문자를 사용해야 한다는 걸 유의한다.

 

기존 코드를 좀 더 깔끔하게 정리하기 위해서 using을 사용해서 내부에서 동작이 끝나면 자동으로 객체가 해제되도록 한다. 자세히 정리하자면 StreamWriter의 객체의 Dipose 메서드는 내부적으로 Flush를 호출하는데 using을 사용할 경우 객체가 해제될 때 Dispose 메서드가 자동으로 호출되면서 Flush도 처리된다. 따라서 별도로 Flush를 해줄 필요가 없어진다.

 

Python

n = int(input())
for i in range(1, n + 1):
    stars = '*' * i;
    print(stars)

 

파이썬은 문자에 횟수만큼 곱연산을 해서 개수만큼 표기가 가능하다.

 

Node.js

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin','utf8').trim();
const count = parseInt(input);
for (let i = 1; i <= count; i++){
    const stars = '*'.repeat(i);
    console.log(stars);
}

 

자바스크립트에서는 char.repeat으로 문자를 개수만큼 입력할 수 있다.

 

10번 별 찍기 - 2

문제

첫째 줄에는 별 1개, 둘째 줄에는 별 2개, N번째 줄에는 별 N개를 찍는 문제

하지만, 오른쪽을 기준으로 정렬한 별(예제 참고)을 출력하시오.

 

입력

첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다.

 

출력

첫째 줄부터 N번째 줄까지 차례대로 별을 출력한다.

 

9번 문제의 변형이다. N만큼 찍힌 별을 기준으로 이전 별들에게 공백이 추가로 필요하며 이 공백은 n - i 개가 된다.

 

C++

#include <iostream>
#include <string>
using namespace std;
int main(){
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++){
        string space(n - i, ' ');
        string stars(i, '*');
        string result = space + stars;
        cout << result << "\n";
    }
    return 0;
}

 

C#

using System;
class Program{
    static void Main(string[] args){
        int n = int.Parse(Console.ReadLine());
        using(StreamWriter writer = new StreamWriter(Console.OpenStandardOutput())){
            for (int i = 1; i <= n; i++){
                string space = new string(' ', n - i);
                string stars = new string('*', i);
                string result = space + stars;
                Console.WriteLine(result);
            }     
        }
    }
}

 

Python

n = int(input())
for i in range(1, n+1):
    space = ' ' * (n - i);
    stars = '*' * i;
    result = space + stars;
    print(result);

 

Node.js

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin', 'utf8').trim();
const n = parseInt(input);
for (let i = 1; i <= n; i++){
    const space = ' '.repeat(n - i);
    const stars = '*'.repeat(i);
    const result = space + stars;
    console.log(result);
}

 

728x90
반응형

6번 빠른 A+B

문제

본격적으로 for문 문제를 풀기 전에 주의해야 할 점이 있다. 입출력 방식이 느리면 여러 줄을 입력받거나 출력할 때 시간초과가 날 수 있다는 점이다. 

 

C++을 사용하고 있고 cin/cout을 사용하고자 한다면, cin.tie(NULL)과 sync_with_stdio(false)를 둘 다 적용해 주고, endl 대신 개행문자(\n)를 쓰자. 단, 이렇게 하면 더 이상 scanf/printf/puts/getchar/putchar 등 C의 입출력 방식을 사용하면 안 된다. 

 

Java를 사용하고 있다면, Scanner와 System.out.println 대신 BufferedReader와 BufferedWriter를 사용할 수 있다. BufferedWriter.flush는 맨 마지막에 한 번만 하면 된다. 

 

Python을 사용하고 있다면, input 대신 sys.stdin.readline을 사용할 수 있다. 단, 이때는 맨 끝의 개행문자까지 같이 입력받기 때문에 문자열을 저장하고 싶을 경우. rstrip()을 추가로 해 주는 것이 좋다. 

 

또한 입력과 출력 스트림은 별개이므로, 테스트케이스를 전부 입력받아서 저장한 뒤 전부 출력할 필요는 없다. 테스트케이스를 하나 받은 뒤 하나 출력해도 된다. 자세한 설명 및 다른 언어의 경우는 이 글에 설명되어 있다. 이 블로그 글에서 BOJ의 기타 여러 가지 팁을 볼 수 있다.

 

입력

첫 줄에 테스트케이스의 개수 T가 주어진다. T는 최대 1,000,000이다. 다음 T 줄에는 각각 두 정수 A와 B가 주어진다. A와 B는 1 이상, 1,000 이하이다.

 

출력

각 테스트케이스마다 A+B를 한 줄에 하나씩 순서대로 출력한다.

 

입출력 시 발생할 수 있는 문제를 해결하여 테스트케이스를 통과해야 하는 문제이다.

친절하게 문제에서 해결방법을 제시해 주었기 때문에 위 방법들을 고려하여 테스트케이스를 통과해 본다.

 

C++

오답

#include <iostream>
using namespace std;
int main(){
    int t;
    cin >> t;
    for (int i = 0; i < t; i++){
        int a, b;
        cin >> a >> b;
        cout << a + b << "\n";
    }
    return 0;
}

 

확인을 위해 제시된 방법을 사용하지 않고 코드를 작성하여 테스트해 보니 '시간 초과' 결과가 나타난다.

 

위 방법들을 사용해서 다시 풀어본다.

 

#include <iostream>
using namespace std;
int main(){
    int t;
    cin.tie(NULL);
    ios_base::sync_with_stdio(false);
    cin >> t;
    for (int i = 0; i < t; i++){
        int a, b;
        cin >> a >> b;
        cout << a + b << "\n";
    }
    return 0;
}

 

cin.tie(NULL)은 cin과 cout의 묶음을 풀어주는 기능을 한다.

기본적으로 cin으로 읽을 때 먼저 출력 버퍼를 비우는 작업이 먼저 처리되는데 이 작업을 통해서 출력이 즉시 화면에 표시되도록 한다. 하지만 이렇게 수만 번의 입력과 출력이 반복해서 처리되는 작업에서는 출력 버퍼를 비우는 작업은 고려하지 않아도 되기 때문에 테스트 케이스를 통과하기 위해서는 이런 부가적인 작업이 발생하지 않도록 해야 타임오버가 되지 않는다.

 

ios_base::sync_with_stdio(false)는 C와 C++의 버퍼를 분리한다.

C++은 C의 기능을 포함하고 있으므로 cin과 cout 사용 시 C의 입출력 라이브러리인 stdin, stdout과 연결된 스트림 객체 상태이다. 따라서 sync_with_stdio(false)를 선언하면 cin/cout은 더 이상 stdin/stdout과 동기화되지 않기 때문에 C++의 스트림 입출력 성능이 향상될 수 있지만 비활성화된 상태에서는 C의 scanf, printf와 함께 사용 시에는 문제가 발생한다.

 

개행문자 endl 은 줄 바꿈을 출력할 뿐만 아니라 출력 버퍼를 비우는 역할까지 하기 때문에 이 작업 역시 테스트케이스를 실행하게 되면 속도를 느리게 하기 때문에 단순 줄 바꿈만 하는 \n 개행문자를 사용하는 것이 속도측면에서 유리하다.

 

C#

C#의 경우 문제에서 해결방법이 제시되지 않아서 추가 정보글의 설명을 먼저 읽어 보았다.

Console.Write, WriteLine은 사용할 때마다 화면으로 내보내는 작업인 flush(C++의 출력버퍼를 비우는 작업)이 발생하는데 해결 방법으로는 StringBuilder에 출력할 내용을 모아둔 뒤 한 번에 출력하거나 auto flush를 하지 않는 output stream을 Console에 연결하는 방법이 있다.

 

StringBuilder

using System;
using System.Text;
class Program{
    static void Main(string[] args){
        StringBuilder sb = new StringBuilder();
        int t = int.Parse(Console.ReadLine());
        for (int i = 0; i < t; i++){
            int a, b;
            string input = Console.ReadLine();
            string[] arr = input.Split(' ');
            a = int.Parse(arr[0]);
            b = int.Parse(arr[1]);
            sb.AppendLine((a+b).ToString());
        }
        Console.WriteLine(sb.ToString());
    }
}

 

StringBuilder를 사용해서 문자열을 저장하고 한 번에 출력하여 flush로 인한 속도 저하를 방지한다. string이 아닌 StringBuilder를 사용하는 이유는 문자열 연결 작업에서 불변 특성을 가지기 때문에 더 효율적인 처리가 가능하고 string의 문자열을 추가하는 + 연산 작업은 새로운 문자열 객체가 생성되고 이 과정에서 메모리 사용량과 실행 시간이 증가할 수 있다.

 

Append : 문자열만 추가한다.

AppendLine : 문자열 추가하고 줄 바꿈 문자를 자동으로 추가한다.

AppendFormat : 형식 문자열을 추가한다.

 

output stream

using System;
class Program{
    static void Main(string[] args){
        int t = int.Parse(Console.ReadLine());
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()));
        for (int i = 0; i < t; i++){
            int a, b;
            string input = Console.ReadLine();
            string[] arr = input.Split(' ');
            a = int.Parse(arr[0]);
            b = int.Parse(arr[1]);
            Console.WriteLine(a + b);
        }
        Console.Out.Flush();
    }
}

 

출력 전 자동으로 flush 하는 기능을 비활성화한다. 이 기능을 사용하고 나서 코드 종료 전에 출력 버퍼를 지우는 Flush()를 호출해 주어야 한다.

 

추가로 StreamReader와 StreamWriter를 사용하는 방법

using System;
using System.IO;

class Program {
    private const int bufferSize = 131072;
    public static readonly StreamReader input = new(new BufferedStream(Console.OpenStandardInput(), bufferSize));
    public static readonly StreamWriter output = new(new BufferedStream(Console.OpenStandardOutput(), bufferSize));

    static void Main(string[] args) {
        int t = int.Parse(input.ReadLine());

        for (int i = 0; i < t; i++) {
            string[] arr = input.ReadLine().Split(' ');
            int a = int.Parse(arr[0]);
            int b = int.Parse(arr[1]);
            output.WriteLine(a + b);
        }
        output.Flush();
    }
}

 

input과 output을 구현하여 처리한다.

마찬가지로 코드가 종료되기 전에 출력버퍼를 비워준다.

 

Python

파이썬에서는 입력을 받는 함수인 input 대신 sys.stdin.readline을 사용하면 된다. 이 경우 문자열 끝에 개행문자까지 같이 입력받게 되므로. rstrip()으로 문자열만 저장하도록 한다.

import sys
t = int(input())
for i in range(t):
    input_str = sys.stdin.readline().rstrip()
    arr = input_str.split(' ');
    a = int(arr[0])
    b = int(arr[1])
    print(a+b)

 

먼저 sys를 사용하기 위해서 모듈을 임포트 해준다.

 

입력받은 문자열을 저장할 때 변수명을 str로 사용했었는데 이 키워드는 파이썬에서 내장 타입으로 사용되고 있기 때문에 문제가 되는 걸 방지하기 위해서 input_str로 사용했다.

 

input을 사용하게 되면 시간초과가 발생한다. 

sys.stdin.readline()은 C 표준 라이브러리의 fgets 함수에 가깝게 동작하는데 이는 입력 스트림에서 한 줄을 읽어오고 문자열로 반환한다. 따라서 직접적으로 표준 입력에서 빠르게 읽어오기 때문에 input보다 더 빠른 속도로 처리할 수 있다.

 

print의 경우 기존 방식을 사용해도 문제가 없다. print 함수는 기본적으로 출력 버퍼링을 사용하긴 하지만 매번 호출할 때마다 버퍼를 flush 하지 않는 게 기본 상태이다. 그리고 이를 수동으로 flush 하도록 변경할 수 있다.

print("Something print", flush=true)

 

Node.js

fs

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n');
const t = parseInt(input[0], 10);
const output = [];

for (let i = 1; i <= t; i++) {
    const [a, b] = input[i].split(' ').map(Number);
    output.push(a + b);
}

process.stdout.write(output.join('\n'));

 

반복문에서 출력할 정보를 저장해 놓고 마지막에 한 번에 출력한다. 

 

위)console.log

 

이때 console.log를 사용해도 성공했는데 process.stdout.write를 사용하는 게 조금 더 빠르게 처리되었다.

 

 

readline

const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
});
let input = [];
let lineIndex = 0;
rl.on('line', (line) => {
    input.push(line);
});
rl.on('close', () => {
    const t = parseInt(input[lineIndex++], 10);
    let output = [];
    for (let i = 0; i < t; i++) {
        const [a, b] = input[lineIndex++].split(' ').map(Number);
        output.push(a + b);
    }
    process.stdout.write(output.join('\n'));
});

 

readline 사용한 게 기본적으로 fs보다 느렸다.

아래)console.log

 

앞으로 문제들은 단순히 해결하는 것뿐만 아니라 더 나은 방법에 대해서도 알 필요가 있는 내용들이 나올듯하다.

728x90
반응형

4번 영수증

문제

준원이는 저번 주에 살면서 처음으로 코스트코를 가 봤다. 정말 멋졌다. 그런데, 몇 개 담지도 않았는데 수상하게 높은 금액이 나오는 것이다! 준원이는 영수증을 보면서 정확하게 계산된 것이 맞는지 확인해보려 한다. 

영수증에 적힌, 

 

- 구매한 각 물건의 가격과 개수

- 구매한 물건들의 총금액

 

을 보고, 구매한 물건의 가격과 개수로 계산한 총금액이 영수증에 적힌 총금액과 일치하는지 검사해 보자.

 

입력

첫째 줄에는 영수증에 적힌 총금액 X가 주어진다. 

둘째 줄에는 영수증에 적힌 구매한 물건의 종류의 수 N이 주어진다. 

이후 N개의 줄에는 각 물건의 가격 a와 개수 b가 공백을 사이에 두고 주어진다.

 

출력

구매한 물건의 가격과 개수로 계산한 총금액이 영수증에 적힌 총금액과 일치하면 Yes를 출력한다. 일치하지 않는다면 No를 출력한다.

 

제한

- 1 ≤ X ≤ 1,000,000,000

- 1 ≤ N ≤ 100

- 1 ≤ a ≤ 1,000,000

- 1 ≤ b ≤ 10

 

첫째 입력 영수증에 적힌 총금액 X, 

두 번째 입력 물건의 종류의 수 N,

이후 각 물건의 가격 a, 개수 b 입력된다.

 

N번 반복문을 돌려서 각 물건의 개수와 가격을 합산하여 X와 비교하여 Yes 또는 No를 출력하면 된다.

 

C++

#include <iostream>
using namespace std;
int main(){
    int total_price;
    int total_count;
    int result = 0;
    cin >> total_price >> total_count;
    for (int i = 0; i < total_count; i++){
        int a, b;
        cin >> a >> b;
        result += a * b;
    }
    if (total_price == result){
        cout << "Yes";
    }
    else cout << "No";
    return 0;
}

 

result 변수 += 연산자 사용 전 값 초기화 필요

 

C#

using System;
class Program{
    static void Main(string[] args){
        int total_price = int.Parse(Console.ReadLine());
        int total_count = int.Parse(Console.ReadLine());
        int result = 0;
        for (int i = 0; i < total_count; i++){
            string input = Console.ReadLine();
            string[] arr = input.Split(' ');
            int a = int.Parse(arr[0]);
            int b = int.Parse(arr[1]);
            result += a * b;
        }
        if (result == total_price){
            Console.WriteLine("Yes");
        }
        else{
            Console.WriteLine("No");
        }
    }
}

 

Python

total_price = int(input())
total_count = int(input())
result = 0;
for i in range(total_count):
    str = input()
    arr = str.split(' ')
    a = int(arr[0])
    b = int(arr[1])
    result += a * b
if result == total_price:
    print("Yes")
else:
    print("No")

 

Node.js

const readline = require('readline');
const rl = readline.createInterface({
    input : process.stdin,
    output : process.stdout
});
let input = [];
let result = 0;
rl.on('line', (line) => {
    input.push(line);
}).on('close', () => {
    const total_price = parseInt(input[0]);
    const total_count = parseInt(input[1]);
    for(let i = 2; i < total_count + 2; i++){
        const[a,b] = input[i].split(' ').map(Number);
        result += a * b;
    }
    if (result === total_price){
        console.log("Yes");
    }else{
        console.log("No");
    }
});

 

모든 입력을 저장하고 인덱스로 끊어서 처리한다.

 

여기서 루프는 처음과 두 번째 값으로 2부터 시작하기 때문에 total_count +  2를 해주어야 전체 값을 처리할 수 있다.

 

5번 코딩은 체육과목입니다.

문제

오늘은 혜나의 면접 날이다. 면접 준비를 열심히 해서 앞선 질문들을 잘 대답한 혜아는 이제 마지막으로 칠판에 직접 코딩하는 문제를 받았다. 

 

혜아가 받은 문제는 두 수를 더하는 문제였다. C++ 책을 열심히 읽었던 혜아는 간단히 두 수를 더하는 코드를 칠판에 적었다. 코드를 본 면접관은 다음 질문을 했다. 

 

“만약, 입출력이 $N$바이트 크기의 정수라면 프로그램을 어떻게 구현해야 할까요?” 

 

혜아는 책에 있는 정수 자료형과 관련된 내용을 기억해 냈다. 책에는 long int는 4바이트 정수까지 저장할 수 있는 정수 자료형이고 long long int는 8바이트 정수까지 저장할 수 있는 정수 자료형이라고 적혀 있었다.

 

혜아는 이런 생각이 들었다. “int 앞에 long을 하나씩 더 붙일 때마다 4바이트씩 저장할 수 있는 공간이 늘어나는 걸까? 분명 long long long int는 12바이트, long long long long int는 16바이트까지 저장할 수 있는 정수 자료형일 거야!” 그렇게 혜아는 당황하는 면접관의 얼굴을 뒤로한 채 칠판에 정수 자료형을 써 내려가기 시작했다. 혜아가 N바이트 정수까지 저장할 수 있다고 생각해서 칠판에 쓴 정수 자료형의 이름은 무엇일까?

 

입력

첫 번째 줄에는 문제의 정수 N이 주어진다. (4 N   1, 000; N은 4의 배수)

 

출력

혜아가 N바이트 정수까지 저장할 수 있다고 생각하는 정수 자료형의 이름을 출력하여라.

 

일리가 있는 생각이다. 혜아는 long이 붙을 때마다 4바이트씩 늘어난다고 생각하여 N바이트를 저장하려면 N/4 * long을 사용하면 N 바이트를 저장할 수 있을 것이라도 추론했다.

 

여기서 N%4가 0이 아니면 N/4 + 1을 해주어야 할 것이지만 N은 4의 배수라고 하니 따로 처리할 필요는 없을 것 같다.

 

물론 실제로는 long long int 까지만 존재하며 그 이상의 크기의 정수를 사용하기 위해서는 __int128_t 또는 gmp 같은 라이브러리를 사용해야 한다. __int128_t는 128비트 정수 자료형으로 16바이트 즉, long long long long int 만큼의 정수를 사용할 수 있다. gmp는 임의 정밀도 연산을 지원하는 라이브러리로 이론적으로 메모리가 허용하는 한 무한히 큰 숫자를 저장할 수 있다.

__int128_t는 <stdint> gmp는 <gmp.h>

 

C++

#include <iostream>
#include <string>
using namespace std;
int main(){
    int n;
    cin >> n;
    int count = n/4;
    string result;
    for (int i = 0; i < count; i++){
        result += "long ";
    }
    result += "int";
    cout << result;
    return 0;
}

 

C#

using System;
class Program{
    static void Main(string[] args){
        int n = int.Parse(Console.ReadLine());
        string result = "";
        int count = n / 4;
        for (int i = 0; i < count; i++){
            result += "long ";
        }
        result += "int";
        Console.WriteLine(result);
    }
}

 

C++의 경우 string 선언 시 빈 문자열로 초기화가 되지만 C#은 null로 초기화되기 때문에 바로 += 연산을 사용하기 위해서는 빈문자열로 초기화해 주는 게 필요하다.

 

Python

n = int(input())
result = "";
for i in range(n//4):
    result += "long "
result += "int"
print(result)

 

몫을 정확히 구하기 위해서 // 을 사용해야 한다.

 

Node.js

const readline = require('readline');
const rl = readline.createInterface({
    input : process.stdin,
    output : process.stdout
});
rl.question('', (answer)=>{
    const n = parseInt(answer);
    let result = "";
    for (let i = 0; i < n / 4; i++){
        result += "long ";
    }
    result += "int";
    console.log(result);
    rl.close();
});

 

자바스크립트에서 습관적으로 for 문의 변수를 int로 선언하게 되는데 let으로 써야 하는 걸 유의한다.

 

 

728x90
반응형

1번 구구단

문제

N을 입력받은 뒤, 구구단 N단을 출력하는 프로그램을 작성하시오. 출력 형식에 맞춰서 출력하면 된다.

 

입력

첫째 줄에 N이 주어진다. N은 1보다 크거나 같고, 9보다 작거나 같다.

 

출력

출력형식과 같게 N*1부터 N*9까지 출력한다.

 

반복문을 사용하는 문제가 시작되었다. 입력받은 N 값을 1부터 9까지 차례로 곱하고 결과를 출력한다.

 

출력 형식은 

n * 1 = n

n * 2 = 2n 

...

n* 9 = 9n

C++

#include <iostream>
using namespace std;
int main(){
    int n;
    cin >> n;
    for(int i = 1; i < 10; i++){
        cout << n << " * " << i << " = "<< n * i << endl;
    }
    return 0;
}

 

 띄어쓰기와 줄 바꿈 등 출력 형식에 주의한다.

 

C#

using System;
class Program{
    static void Main(string[] args){
        string input = Console.ReadLine();
        int n = int.Parse(input);
        for (int i = 1; i < 10; i++){
            int result = n * i;
            Console.WriteLine($"{n} * {i} = {result}");
        }
    }
}

 

Python

inputStr = input()
n = int(inputStr);
for i in range(1, 10):
    print(f"{n} * {i} = {n*i}");

 

파이썬의 반복문 for i in range()를 사용한다. 

range는 i의 범위로 range(1, 10) 은 i는 1부터 i < 10까지 증가하면서 반복된다.

 

Node.js

const readline = require('readline');
const rl = readline.createInterface({
    input : process.stdin,
    output : process.stdout
});
rl.question('', (answer)=>{
   let n = parseInt(answer);
    for(let i = 1; i < 10; i++){
        console.log(`${n} * ${i} = ${n*i}`);
    }
    rl.close();
});

 

템플릿 리터럴 사용 숙지하기 `` 백틱 내부에서 변수는 ${var}로 문자열과 혼합 표기하면 된다.

반복문에서 i 선언 시 let을 사용해야 한다.

 

2번 A+B-3

문제

두 정수 A와 B를 입력받은 다음, A+B를 출력하는 프로그램을 작성하시오.

 

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스는 한 줄로 이루어져 있으며, 각 줄에 A와 B가 주어진다. (0 < A, B < 10)

 

출력

각 테스트 케이스마다 A+B를 출력한다.

 

처음 입력은 반복 횟수, 다음 줄부터는 A, B의 입력이 한 줄씩 묶어서 여러 묶음이 들어온다.

 

배열과 반복문을 잘 사용해야 할 것 같다. 그런데 제목에는 -3이 있는데 문제와 상관이 없어 보인다.

 

C++

#include <iostream>
using namespace std;
int main(){
    int count;
    cin >> count;
    for (int i = 0; i < count; i++){
        int a, b;
        cin >> a >> b;
        cout << a + b << endl;
    }
    return 0;
}

 

입력받은 값만큼 반복을 한다.

 

반복할 때마다 두 번의 입력을 처리해서 출력하고 다음 루프를 진행한다.

 

C#

using System;
class Program{
    static void Main(string[] args){
        int count = int.Parse(Console.ReadLine());
        for (int i = 0; i < count; i++){
            string input = Console.ReadLine();
            string[] inputArr = input.Split(' ');
            int a = int.Parse(inputArr[0]);
            int b = int.Parse(inputArr[1]);
            Console.WriteLine(a+b);
        }
    }
}

 

문제에서 입력이 한 줄씩 들어온다는 점과 Console.ReadLine이 한 줄씩 처리한다는 걸 이해하면 간단하다.

 

이 방법은 반복 횟수가 확정되어 있기 때문에 가능하며 각 줄을 입력받고 연산해서 출력하고 다음 줄로 넘어가는 방식이다.

 

Python

count = int(input())
for i in range(count):
    inputStr = input()
    arr = inputStr.split(' ')
    a = int(arr[0])
    b = int(arr[1])
    print(f"{a + b}")

 

range에 인수를 하나만 넣으면 i = 0부터 시작해서 < count까지 반복한다.

 

input은 문자열이기 때문에 int로 변환해 주는 걸 유의한다.

 

오답

const readline = require('readline');
const rl = readline.createInterface({
    input : process.stdin,
    output : process.stdout
});
rl.question('', (answerCount)=>{
   const count = parseInt(answerCount);
    for (let i = 0; i < count; i++){
        rl.question('', (case)=>{
           const [a, b] = case.split(' ').map(Number);
            console.log(a + b);
        });
    };
    rl.close();
});

 

rl.question 은 비동기 함수라서 반복문 안에서 이를 실행시키면 각 케이스가 독립적으로 처리되지 않기 때문에 위 코드는 제대로 동작하지 않는다.

 

그리고 case는 이미 사용 중인 키워드이기 때문에 이름을 다른 걸 써야 한다.

 

const readline = require('readline');
const rl = readline.createInterface({
    input : process.stdin,
    output : process.stdout
});
rl.question('', (answerCount)=>{
    const count = parseInt(answerCount);
    const results = [];
    let index = 0;
    const ask = ()=>{
        if (index < count){
            rl.question('', (caseInput) =>{
                const [a, b] = caseInput.split(' ').map(Number);
                results.push(a+b);
                index++;
                ask();
            });
        } else{
            results.forEach(result=> console.log(result));
            rl.close();
        }
    };
    ask();
});

 

오답 코드를 개선하여 한 번에 하나씩 케이스를 처리하고, 모든 질문이 완료되면 question을 종료하고 결과를 출력한다.

 

ask 메서드를 변수로 선언하여 각 케이스마다 처리한 결과를 results에 저장해 두고 이 함수를 재귀적으로 호출한다.

 

count까지의 횟수를 체크하기 위해서 index를 사용하여 현재 진행된 반복 횟수를 체크하고 모든 반복이 끝났을 때 저장해 둔 results의 요소들을 모두 출력한다.

 

그리고 이 동작을 실행시키기 위해서 한 번 ask를 실행시켜주어야 한다.

 

더 간단한 방법을 찾아보니 process.stdin을 활용하면 전체 입력을 한 번에 읽고 처리할 수 있는 방법이 있었다.

 

const readline = require('readline');
const rl = readline.createInterface({
    input : process.stdin,
    output : process.stdout
});

let input = [];
rl.on('line', (line)=>{
    input.push(line);
}).on('close', () => {
    const count = parseInt(input[0]);
    for (let i = 1; i <= count; i++){
        const [a, b] = input[i].split(' ').map(Number);
        console.log(a + b);
    }
    process.exit(0);
});

 

input 배열을 선언하고

 

rl.on('line; ~  각 줄을 입력받을 때마다 input에 저장한다.

 

rl.on('close' ~ 입력이 종료되면 반복문으로 input에 저장된 값들을 처리한다.

 

처음 입력 값인 count 만큼 반복을 실행하며 이를 제외한 i = 1부터 인덱스를 순회한다.

 

1부터 시작되는 input 에는 케이스들이 저장되어 있기 때문에 이 요소를 공백으로 구분하고 맵으로 만들어서 출력해 주면 된다.

 

앞서 풀었던 문제들도 이렇게 풀면 더 간단했던 문제도 있던 거 같았는데 이번에 이 기능들을 제대로 파악하고 가야겠다.

 

3번 합

문제

n이 주어졌을 때, 1부터 n까지 합을 구하는 프로그램을 작성하시오.

 

입력 

첫째 줄에 n (1 ≤ n ≤ 10,000)이 주어진다.

 

출력

1부터 n까지 합을 출력한다.

 

n까지의 합계를 구하는 문제이다.

 

수학 공식을 활용하면 간단하게 n * (n + 1) / 2의 결과와 동일하다.

 

C++

#include <iostream>
using namespace std;
int main(){
    int n;
    cin >> n;
    int result = 0;
    for (int i = 1; i <= n; i++){
        result += i;
    }
    cout << result;
    return 0;
}

 

먼저 문제의 주제에 맞게 반복문을 사용하여 처리해 본다.

 

수학 공식으로 처리해도 동일한 결과라는 것을 확인한다.

 

#include <iostream>
using namespace std;
int main(){
    int n;
    cin >> n;
    int result = n * (n + 1) / 2;
    cout << result;
    return 0;
}

 

반복문 챕터이기 때문에 공식은 아껴두고 반복문으로만 풀어보도록 한다.

 

C#

using System;
class Program{
    static void Main(string[] args){
        int n = int.Parse(Console.ReadLine());
        int result = 0;
        for (int i = 1; i <= n; i++){
            result += i;
        }
        Console.WriteLine(result);
    }
}

 

Python

n = int(input())
result = 0
for i in range(1, n+1):
    result += i
print(result);

 

Node.js

const fs = require('fs');
const n = parseInt(fs.readFileSync('dev/stdin').toString().trim());
let result = 0;
for (let i = 1; i <= n; i++){
    result += i;
}
console.log(result);

 

728x90
반응형

7번 주사위 세 개

문제

1에서부터 6까지의 눈을 가진 3개의 주사위를 던져서 다음과 같은 규칙에 따라 상금을 받는 게임이 있다. 같은 눈이 3개가 나오면 10,000원+(같은 눈) ×1,000원의 상금을 받게 된다. 같은 눈이 2개만 나오는 경우에는 1,000원+(같은 눈) ×100원의 상금을 받게 된다. 모두 다른 눈이 나오는 경우에는 (그중 가장 큰 눈) ×100원의 상금을 받게 된다. 예를 들어, 3개의 눈 3, 3, 6이 주어지면 상금은 1,000+3 ×100으로 계산되어 1,300원을 받게 된다. 또 3개의 눈이 2, 2, 2로 주어지면 10,000+2 ×1,000으로 계산되어 12,000원을 받게 된다. 3개의 눈이 6, 2, 5로 주어지면 그중 가장 큰 값이 6이므로 6 ×100으로 계산되어 600원을 상금으로 받게 된다. 3개 주사위의 나온 눈이 주어질 때, 상금을 계산하는 프로그램을 작성하시오.

 

입력

첫째 줄에 3개의 눈이 빈칸을 사이에 두고 각각 주어진다.

 

출력

첫째 줄에 게임의 상금을 출력한다.

 

입력받은 주사위 눈을 조건에 맞게 검사해서 상금을 출력하면 된다.

 

C++

#include <iostream>
#include <algorithm>
using namespace std;
int main(){
    int a, b, c;
    cin >> a;
    cin >> b;
    cin >> c;
    int reward;
    if (a == b && b == c){
        reward = 10000 + a * 1000;
    }
    else if (a == b || b == c || a == c){
        int val = a == b ? a : b == c ? b : c;
        reward =  1000 + val * 100;
    }
    else{
        int max_val = max({a, b, c});
        reward = max_val * 100;
    }
    cout << reward;
    return 0;
}

 

세 개의 값 중 가장 큰 값을 구할 때 <algorithm> 헤더의 std::max를 사용하여 간략하게 작성한다.

 

C#

using System;
class Program{
    static void Main(string[] args){
        string input = Console.ReadLine();
        string[] arr_input = input.Split(' ');
        int a = int.Parse(arr_input[0]);
        int b = int.Parse(arr_input[1]);
        int c = int.Parse(arr_input[2]);
        int reward;
        if (a == b && b == c){
            reward = 10000 + a * 1000;
        }
        else if (a == b || b == c || a == c){
            int val = a == b ? a : b == c ? b : c;
            reward = 1000 + val * 100;
        }
        else {
            int val = Math.Max(a, (Math.Max(b, c)));
            reward = 100 * val;
        }
        Console.WriteLine(reward);
    }
}

 

C#은 최댓값을 구하기 위해서 Math.Max를 중첩해서 사용했다.

 

다른 방법으로는 System.Linq의 Enumerable.Max를 사용할 수  있다.

using System.Linq;
~

	int [] nums = {a, b, c};
	int max_val = nums.Max();

~

 

두 방식을 비교해 보니 메모리면에서 전자의 방법이 더 나았다.

 

Python

inputData = input();
arrData = inputData.split(' ');
a = int(arrData[0]);
b = int(arrData[1]);
c = int(arrData[2]);
if a == b and b == c:
    reward = 10000 + a * 1000
elif a == b or b == c or a == c:
    val = a if a == b or a == c else b
    reward = 1000 + val * 100;
else:
    val = max(a, b, c)
    reward = 100 * val
print(reward)

 

파이썬에서 삼항 연산자는 if - else로 표현된다.

max 함수는 가장 큰 수를 반환한다.

 

Node.js

const readline = require('readline');
const rl = readline.createInterface({
    input : process.stdin,
    output : process.stdout
});

rl.question('', (answer)=>{
    const [a,b,c] = answer.split(' ').map(Number);
    let reward;
    if (a == b && b == c){
        reward = 10000 + a * 1000;
    }
    else if (a == b || b == c || a == c){
        let val = a == b ? a : b == c ? b : c;
        reward = 1000 + val * 100;
    }
    else{
        val = Math.max(a, b, c);
        reward = 100 * val;
    }
    console.log(reward);
    rl.close();
});

 

node.js는 Math.max로 세 값 중 가장 큰 값을 구할 수 있다.

728x90
반응형

+ Recent posts