12-froglike6

[froglike6]

🔗 문제 링크

AC

✔️ 소요된 시간

20분

✨ 수도 코드

수도 코드

    T ← 정수 입력            ▸ 테스트 케이스 개수

    T 번 반복
        func ← 문자열 입력          ▸ R 과 D 로 이루어진 명령어
        n    ← 정수 입력            ▸ 배열 원소 수

        만약 n = 0 이면
            arr ← 빈 deque 생성
            빈 배열 라인 소모        ▸ "[]"
        그렇지 않으면
            line ← 문자열 입력      ▸ "[1,2,3]" 형태
            nums ← line 의 첫·끝 문자 제거 후 "," 로 분리하여 정수로 변환
            arr ← nums 로 deque 생성

        rev ← False                 ▸ 뒤집기 상태 플래그
        err ← False                 ▸ 에러 발생 여부

        func 의 각 문자 i 에 대해
            만약 i = 'R' 이면
                rev ← not rev       ▸ 뒤집기 토글
            그렇지 않으면           ▸ i = 'D' (삭제)
                만약 arr 가 비어 있으면
                    "error" 출력
                    err ← True
                    루프 탈출
                아니고 rev 가 True 이면
                    arr.pop()       ▸ 뒤에서 제거
                아니면
                    arr.popleft()   ▸ 앞에서 제거

        에러가 발생하지 않았다면
            만약 rev 가 True 이면
                arr.reverse()       ▸ 최종 뒤집기
            결과 문자열 ← "[" + arr 원소를 "," 로 연결 + "]"
            결과 문자열 출력

이 문제는 테스트 케이스마다 배열이 주어지고, 그 배열을 주어진 명령에 따라 뒤집거나 버리는 문제입니다.
처음에는 배열에 직접 넣고 reverse함수로 직접 뒤집을까 하다가, 시간 초과가 날 것 같아 다른 방법을 찾았습니다.

rev라는 변수를 따로 선언해서, 뒤집는 명령이 들어오면 rev = not rev을 통해 표시만 하게 했습니다. 그런 다음 arr이 True이면 pop을 하고(뒤집어졌으면 왼쪽이 오른쪽이 됨!), 아니면 popleft를 하게 해서 결과적으로 O(1)만에 버리는 동작을 할 수 있었습니다.

이렇게 연산을 하고, 마지막에 뒤집어졌는지 확인하여 상태에 맞게 deque를 출력했습니다.

---

처음에 풀 때 빈 배열 처리를 안 하고 풀었더니 에러가 떴습니다 ㅎㅎ.. 이 점 고려해서 문제를 풀어야합니다.

📚 새롭게 알게된 내용

[9kyo-hwang]

매우 사소한 건데

rev ^= True

0, 1을 플립하는 거다 보니 xor 1 해주는 걸로도 가능하긴 합니다 ㅎㅎ

[dohyeondol1]

AC....진짜 풀면서 이게 맞나 싶도록 깔끔하지 않은 코드가 나와서 AC를 부르게되는...

저도 그냥 배열 전체를 뒤집어 풀어보려고 했는데 바로 틀렸습니다 ㅎ
D가 "첫번째 수를 버리는 함수"라는 점에 집중하니 그제야 덱을 사용해야겠다는 생각이 들더라구요..

C++

#include <iostream>
#include <vector>
#include <deque>
#include <string>
using namespace std;

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    int T;
    cin >> T;
    while(T--) {
        string order;
        int N;
        cin >> order >> N;

        deque<int> dq;
        char ch;
        cin >> ch;
        for(int i = 0; i < N; i++) {
            int x;
            cin >> x;
            dq.push_back(x);
            if(i != N - 1) cin >> ch;
        }
        cin >> ch;

        bool isReverse = false, isError = false;
        for(char c : order) {
            if(c == 'R') {
                isReverse = !isReverse;
            } else if(c == 'D') {
                if(dq.empty()) {
                    isError = true;
                    break;
                }
                if(!isReverse) dq.pop_front();
                else dq.pop_back();
            }
        }

        if(isError) {
            cout << "error" << '\n';
        } else {
            cout << '[';
            if(!dq.empty()) {
                if(!isReverse) {
                    for(size_t i = 0; i < dq.size(); i++) {
                        cout << dq[i];
                        if(i != dq.size() - 1) cout << ',';
                    }
                } else {
                    for(size_t i = dq.size(); i-- > 0;) {
                        cout << dq[i];
                        if(i != 0) cout << ',';
                    }
                }
            }
            cout << "]" << '\n';
        }
    }

    return 0;
}

입력에 [ 와 , 를 생각 못했다가 틀리기도 했습니다.. 방심은 금물..

[hadongun]

매번 R이 나올 때마다 뒤집으니 시간이 매우 걸리는군요

다들 하신 방법처럼 bool 타입의 reverse 변수를 통해 뒤집어졌는지, 아닌지를 확인해
pop, popleft를 통해 해결했습니다..!

점점 문제들의 난이도가 높아질수록 간결하고 효율적인 코드를 요구하는 것 같네요

파이썬

import sys
from collections import deque

t = int(input())
for _ in range(t):
    is_reverse = False
    implement = sys.stdin.readline().strip()
    
    n = int(input())
    arr = sys.stdin.readline().strip()
    arr = arr[1:-1]
    
    if arr == '':
        arr = deque()
    else:
        arr = list(map(str, arr.split(',')))
        arr = deque(arr) 

    for ch in implement:
        if ch == 'R':
            if is_reverse == False:
                is_reverse = True
            else:
                is_reverse = False
        else:
            if arr:
                if is_reverse == True:
                    arr.pop()
                else:
                    arr.popleft()
            else:
                print('error')
                break
    else:  
        if is_reverse == True:
            arr.reverse()
        print('[' + ','.join(map(str, arr)) + ']')

[caucsejunseo]

전체를 뒤집지 않고 reversed 이용해서 front rear로 접근하는 법! '[,]' 같은 문자열 처리하는 법! 등 새로운 방법 많이 배우게 된 문제네요. 문자열은 항상 버벅이게 되는거 같아요..

C

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <stdbool.h>

#define MAX 100001
int arr[MAX];




int main() 
{

    int T;
    scanf("%d", &T);

    while (T--)
    {
        char p[MAX];
        int n;
        char input[700002];
        scanf("%s", p);
        scanf("%d", &n);
        scanf("%s", input);

        int front = 0 , rear = n - 1;
        bool reversed = false, error = false;

        int idx = 0;
        char* token = strtok(input, "[,]");
        while (token != NULL)
        {
            arr[idx++] = atoi(token);
            token = strtok(NULL, "[,]");
        }

        for (int i = 0; p[i]; i++)
        {
            if (p[i] == 'R')
            {
                reversed = !reversed;
            }
            else if(p[i])
            {
                if (front > rear)
                {
                    error = true;
                    break;
                }
                if (!reversed)
                    front++;
                else
                    rear--;
            }
        }

        if (error)
        {
            printf("error\n");
        }
        else
        {
            printf("[");
            if (!reversed)
            {
                for (int i = front; i < rear+1; i++)
                {
                    printf("%d", arr[i]);
                    if (i < rear)
                    {
                        printf(",");
                    }
                }
            }
            else
            {
                for (int i = rear; i >= front; i--)
                {
                    printf("%d", arr[i]);
                    if (i > front)
                    {
                        printf(",");
                    }
                }
            }
            printf("]\n");
        }


    }

  




    return 0;
}