개발하는 시나몬

[백준 1275] 커피숍2

sanadoing_ — Sat, 21 Sep 2024 12:07:04 +0900

package javaSana.Day0917.segmentTree;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class B_1275 {

	static int N, Q;
	static long[] arr, tree;

	public static void main(String[] args) throws Exception {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		N = Integer.parseInt(st.nextToken());
		Q = Integer.parseInt(st.nextToken());

		arr = new long[N + 1];

		st = new StringTokenizer(br.readLine());
		for (int i = 1; i <= N; i++) {
			arr[i] = Long.parseLong(st.nextToken());
		}

		tree = new long[N * 4];
		init(1, N, 1);
		for (int i = 0; i < Q; i++) {
			st = new StringTokenizer(br.readLine());
			int x = Integer.parseInt(st.nextToken());
			int y = Integer.parseInt(st.nextToken());
			
			int a = Integer.parseInt(st.nextToken());
			long b = Long.parseLong(st.nextToken());

			int minN = Math.min(x, y);
			int maxN = Math.max(x, y);
			
			System.out.println(sum(1, N, 1, minN, maxN));
			
			long dif = b - arr[a];
			arr[a] = b;
			
			update(1, N, 1, a, dif);
		}

	}

	static long init(int start, int end, int node) {
		if (start == end) {

			return tree[node] = arr[start];
		}

		int mid = (start + end) / 2;
		return tree[node] = init(start, mid, node * 2) + init(mid + 1, end, node * 2 + 1);
	}

	static void update(int start, int end, int node, int idx, long dif) {
		if (idx < start || end < idx)
			return;

		tree[node] += dif;
		if (start == end)
			return;

		int mid = (start + end) / 2;
		update(start, mid, node * 2, idx, dif);
		update(mid + 1, end, node * 2 + 1, idx, dif);

	}

	static long sum(int start, int end, int node, int left, int right) {
		if (right < start || end < left) {
			return 0;
		}
		if (left <= start && end <= right) {
			return tree[node];
		}

		int mid = (start + end) / 2;
		return sum(start, mid, node * 2, left, right) + sum(mid + 1, end, node * 2 + 1, left, right);
	}

}

[백준 14428] 수열과 쿼리 16

sanadoing_ — Sat, 21 Sep 2024 12:06:24 +0900

package javaSana.Day0920.segmentTree;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class B_14428 {

	static class Point {
		int idx;
		int value;

		Point(int i, int v) {
			this.idx = i;
			this.value = v;
		}
	}

	static int N, M;
	static int[] arr;
	static Point[] tree;

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		N = Integer.parseInt(br.readLine());
		arr = new int[N + 1];

		StringTokenizer st = new StringTokenizer(br.readLine());
		for (int i = 1; i <= N; i++) {
			arr[i] = Integer.parseInt(st.nextToken());
		}

		M = Integer.parseInt(br.readLine());
		tree = new Point[N*4];
		
		init(1, N, 1);
		for (int i = 0; i < M; i++) {
			st = new StringTokenizer(br.readLine());
			int mode = Integer.parseInt(st.nextToken());
			int a = Integer.parseInt(st.nextToken());
			int b = Integer.parseInt(st.nextToken());

			if (mode == 1) { // arr[a] = b
				arr[a] = b;
				update(1, N, 1, a, b);
			} else if (mode == 2) { // a ~ b 에서 min값 출력
				Point p = query(1, N, 1, a, b);
				System.out.println(p.idx);
			}

		}
	}

	static Point init(int start, int end, int node) {
		if (start == end)
			return tree[node] = new Point(start, arr[start]);

		int mid = (start + end) / 2;
		
		Point lPoint = init(start, mid, node * 2);
		Point rPoint = init(mid + 1, end, node * 2 + 1);
		
		return tree[node] = compareTo(lPoint, rPoint);
	}

	static void update(int start, int end, int node, int idx, int change) {
		if (idx < start || end < idx) {
			return;
		}
		if (start == end && start == idx) {
			
				tree[node].value = change;
			
		} 
		if(start != end){
			int mid = (start + end) / 2;

			update(start, mid, node * 2, idx, change);
			update(mid + 1, end, node * 2 + 1, idx, change);
			tree[node] = compareTo(tree[node * 2], tree[node * 2 + 1]);
		}

	}

	static Point query(int start, int end, int node, int left, int right) {
		if (right < start || end < left)
			return new Point(Integer.MAX_VALUE, Integer.MAX_VALUE);

		if (left <= start && end <= right) {
			return tree[node];
		}

		int mid = (start + end) / 2;
		Point lPoint = query(start, mid, node * 2, left, right);
		Point rPoint = query(mid + 1, end, node * 2 + 1, left, right);

		return compareTo(lPoint, rPoint);

	}

	static Point compareTo(Point p1, Point p2) {
		if (p1.value == p2.value) {
			if (p1.idx < p2.idx) {
				return new Point(p1.idx, p1.value);
			} else {
				return new Point(p2.idx, p2.value);
			}
		} else {
			if (p1.value < p2.value) {
				return new Point(p1.idx, p1.value);
			} else {
				return new Point(p2.idx, p2.value);
			}
		}
	}

}

[백준 2268번] 수들의 합 7

sanadoing_ — Sat, 21 Sep 2024 12:05:44 +0900

package javaSana.Day0917.segmentTree;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class B_2268 {
	static int N, M;
	static long[] arr, tree;

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());

		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());

		arr = new long[N + 1];
		tree = new long[N * 4];

		Arrays.fill(arr, 0);

		for (int i = 0; i < M; i++) {
			st = new StringTokenizer(br.readLine());
			int a = Integer.parseInt(st.nextToken());
			int b = Integer.parseInt(st.nextToken());
			int c = Integer.parseInt(st.nextToken());

			if (a == 0) { // sum

				System.out.println(sum(1, N, 1, Math.min(b, c), Math.max(b, c)));
			} else if (a == 1) { // modify
				long dif = c - arr[b];
				arr[b] = c;
				modify(1, N, 1, b, dif);

			}

		}
	}

	static long sum(int start, int end, int node, int left, int right) {
		if (right < start || end < left)
			return 0;

		if (left <= start && end <= right) {
			return tree[node];
		}

		int mid = (start + end) / 2;
		return sum(start, mid, node * 2, left, right) + sum(mid + 1, end, node * 2 + 1, left, right);
	}

	static void modify(int start, int end, int node, int idx, long dif) {
		if (idx < start || end < idx)
			return;

		tree[node] += dif;

		if (start == end)
			return;

		int mid = (start + end) / 2;
		modify(start, mid, node * 2, idx, dif);
		modify(mid + 1, end, node * 2 + 1, idx, dif);

	}
}

[삼성 전자 PRO] JAVA 정렬 알고리즘

sanadoing_ — Thu, 29 Aug 2024 23:46:59 +0900

PRO 시험까지 약 3주 정도가 남았는데요.

다시 1일 1잔디 실천해 보겠습니닷

기초 알고리즘 및 자료 구조 기본기 다지기 1탄 !

정렬 알고리즘 : 버블 정렬, 선택 정렬, 퀵 정렬, 병합 정렬

버블 정렬

두 인접한 데이터의 크기를 비교해 정렬.

시간 복잡도 O(n²)

public class Main {
  public static int[] array = new int[5];

  public static void main(String[] args) {

    array = new int[] { 5, 3, 1, 7, 9 };

    bubbleSort(array);
    for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
    }
  }

  static void bubbleSort(int[] array) {
    int temp = 0;
    for (int i = 0; i < array.length - 1; i++) {
      for (int j = 1; j < array.length - i; j++) {
        if (array[j] < array[j - 1]) {
          temp = array[j - 1];
          array[j - 1] = array[j];
          array[j] = temp;
        }
      }
    }
  }

}

선택 정렬

데이터에서 최솟(최댓)값을 찾아 선택하고, 선택된 최솟값을 순서대로 바꿔가면서 정렬

시간 복잡도 O(n²)

1. 데이터에서 최솟(최댓)값을 찾음.

2. 가장 앞에 있는 데이터와 선택된 데이터 swap

3. 가장 앞에 있는 index + 1

4. 계속 반복.

public class Main {
  public static int[] array = new int[5];

  public static void main(String[] args) {

    array = new int[] { 5, 3, 1, 7, 9 };

    selectionSort(array);
    for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
    }
  }

  static void selectionSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
      int minIdx = i;
      for (int j = i + 1; j < array.length; j++) {
        if (array[j] < array[minIdx]) {
          minIdx = j;
        }
      }
      int temp = array[i];
      array[i] = array[minIdx];
      array[minIdx] = temp;
    }

  }

}

퀵 정렬

데이터에서 최솟(최댓)값을 찾아 선택하고, 선택된 최솟값을 순서대로 바꿔가면서 정렬

시간 복잡도 O(n²)

병 정렬

데이터에서 최솟(최댓)값을 찾아 선택하고, 선택된 최솟값을 순서대로 바꿔가면서 정렬

시간 복잡도 O(n²)

삼성전자 SW 역량테스트 B형 준비

sanadoing_ — Fri, 26 Jul 2024 11:08:26 +0900

svp 자기주도학습 겸 앞으로 칠 SW 역량테스트 B형에 대해 미리 정리해놓고자 함

: 1문제를 4시간 동안 푸는 시험

: main 함수는 수정할 수 없고 solution 함수만 구현

: A형에서는 볼 수 없는 엄청난 사이즈의 제약사항 (1억, 10억…)

[ 문제 풀이 순서 ]

-> 문제 이해

-> 아이디어 도출

-> 설계(시간복잡도 계산)

-> 구현

-> 디버깅

-> 최적화 (중복된 연산, 불필요한 연산 등을 찾아 최적화)

[ 공부해볼만한 키워드 ]

Array, Linked List, Bitwise 연산, Greedy, 완전탐색(Brute-Force), BFS, DFS, DP, 분할정복, Sort, Binary Search, Graph, Dijkstra, Tree, LCA, Heap, Trie, KMP, Hash, Union Find, 부분합, Segment Tree, Priority Queue

BFS

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

int number = 9;
int visit[9];
vector<int> a[10];

void bfs(int start){
    queue<int> q;
    q.push(start);
    visit[start] = true;
    
    while(!q.empty()){
        // 큐에 값이 있을경우 계속 반복 실행
        // 큐에 값이 있다. => 아직 방문하지 않은 노드가 존재 한다. 
        int x = q.front();
        q.pop();
        printf("%d ", x);
        for(int i=0; i< a[x].size(); i++){
            int y = a[x][i];
            if(!visit[y]){
                // 방문하지 않았다면..
                q.push(y);
                visit[y] = true; 
            }
        }
    }
}

int main(void){
    
    // 1과 2를 연결 
    a[1].push_back(2);
    a[2].push_back(1);
    
    // 1과 3을 연결 
    a[1].push_back(3);
    a[3].push_back(1);
    
    // 2와 4를 연결 
    a[2].push_back(4);
    a[4].push_back(2);

    // 2와 5를 연결 
    a[2].push_back(5);
    a[5].push_back(2);
    
    // 4와 8을 연결 
    a[4].push_back(8);
    a[8].push_back(4);
    
    // 5와 9를 연결 
    a[5].push_back(9);
    a[9].push_back(5);
    
    // 3과 6을 연결 
    a[3].push_back(6);
    a[6].push_back(3);
    
    // 3과 7을 연결 
    a[3].push_back(7);
    a[7].push_back(3);
    
    // 1번 노드부터 bfs 탐색 실행 
    bfs(1);
    
    return 0;
} 
출처: https://hongku.tistory.com/156 [IT에 취.하.개.:티스토리]

[삼성 전자 DX] SW 개발 직무 면접 준비

sanadoing_ — Sat, 1 Jun 2024 17:47:20 +0900

이 게시물도 저를 위한 게시물이 되지 않을까 싶네요

일정 / 진행 방식
sw 역량 테스트	2024. 04. 14 (일)
삼성전자 면접 스터디 첫 시작	2024. 04. 16 (화)
면접 스터디 1주차	04. 16 (화) ~ 04. 20 (토)
	- 온라인 (구글 미트) 진행으로 전반적인 스터디 방식 정함 - 인성, 직무, 창의성 3개의 면접 준비를 위해 각각 준비해올 것을 정함. (오프라인 스터디 까지 할 것) (공통질문을 각자 조사해서 노션에 적어놓기)
1차 오프라인 면접 스터디	- 부산 하단역 스타벅스에서 모임 [ 오프라인에서 진행한 것 ] 1. 자기소개서 코멘트 템플릿을 사용해서 서로의 자기소개서에 대한 코멘트 달아줌. => 실제로 스터디원이 나의 자기소개서를 읽고 궁금했던 점에 대한 질문에 임원 면접에 몇개 나왔음. 2. 각자가 조사한 공통 질문에 중복되는 것들 없애고, 공통으로 준비할 액기스 질문만 뽑음. (정리 !) 3. 2주차 면접 오프라인 스터디 전까지 할 것들 정함.
면접 스터디 2주차	04. 21 (일) ~ 04. 27 (토)
	1. [공통 면접] 액기스 질문만 뽑은 공통질문에 대해 스크립트 작성 2. [직무 면접] (면접을 위한 CS 전공 지식 노트) chap 03장까지 노션에 정리하면서 공부함. (각자 방법대로) => 근데 난 이 책 pdf가 생각보다 이해가 안돼서, 전혀 외워지지가 않았고 그냥 기계적으로 타자치면서 정리하는 느낌이고 머리에 안들어와서 다른 방법이 필요하다고 생각을 함. 3. [창의성 면접] IT 주제 조사 1개
2차 오프라인 면접 스터디	04. 27 (토) 1. 창의성 면접 진행 : 각자가 조사한 it나 시사 주제 가져온 거로 하자고 했으나, https://www.youtube.com/watch?v=s7eypFXCvWg&t=245s 이 유튜브에 있는 1, 3번 (?) 문제로 진행함. 실제로 창의성 모의 면접을 하진 않았고, 각각 문제마다 30분을 정해서 면접 템플릿을 서로 맞춰 만들고 그에 따라 답변 준비하고 한번씩 읽어봄. (이때 사용한 템플릿 + 각 면접별로 준비한 건 아래에 적겠음) => 이렇게 해보니까, 혼자 준비할 때는 진짜 [창의성 면접]은 어떻게 준비해야할지 막막했었는데, 주어진 주제에 대해 답변을 준비하면서 같이 맞춰보니까 어느정도 어떻게 준비해야할 지 감을 잡음. (심리적 안정감 good) 2. 3주차 면접 오프라인 스터디 전까지 할 것들 정함.
면접 스터디 3주차	04. 27 (일) ~ 05. 04 (토)
	1. [직무 면접] 각자 CS 공부 -> 직무 면접 준비 => 나는 (면접을 위한 CS 전공 지식 노트) 공부에서 전혀 머리속에 남는 것이 없다는 것을 깨닫고 https://inpa.tistory.com/ 를 계속 읽음. 진짜 이해도 잘되고 흐름대로 정리가 잘 되어있어서 머릿속에 내용들이 쏙쏙 들어옴. 그리고 혼자 있을 때 계속 거울 보면서 말하는 연습하고, 블로그 보면서 cs공부할 때도 괜히 말하면서 공부함. 그리고 양치하면서나 틈틈이 이런 개념이 나왔을 때 대답할 것, 외운 것들 계속 말해봄. 2. [직무 면접] cs 기반 질문할 것 준비 3. [직무 면접] 프로젝트 활동 정리 이건 '민욱님' 의 템플릿을 그대로 복붙했는데, 진짜 도움이 많이 됨. 프로젝트 별로, (뭐 만들었는지, 과제 배경, 특징(차별점), 아이템 구성, 시나리오, 맡은 역할, 프로젝트를 진행하면서 어려웠던 점 및 해결, 배운 점, 아쉬운 점 + 사용한 기술들에 대한 개념 정리) 에 대해 다 적음. 4. 각자 [공통 질문] 에 대해 스크립트 작성한 거에 대한 피드백 일일이 다 해줌.
3차 오프라인 면접 스터디	05. 04 (토) 1. 직무 모의 면접 진행 cs 개념 + 각자 프로젝트에 관해 질문 함 각자 50분 ~ 1시간 정도 모의 면접 진행 => 이때 아직 면접 확정이 안되어있었지만, 아는 사람 앞에서 모의면접을 한다는 거에 일주일동안 긴장감에 시달림. 이 과정으로 실제 면접에 더 긴장을 안할 수 있었지 않나 .. 그리고 1주일 동안 cs 공부한게 너무 유익했음. (그러고 실제 면접 전까지 cs공부를 미룸 .. 그래도 이 일주일을 통해서 임원면접 준비할 수 있는 시간을 벌 수 있었달까 !) 그리고 모의 면접 하면서 내가 질문 받았던 것과 특히 답변 잘 못했던 것들을 적으면서 진행했는데, 부족한 개념이 어떤 것인지 알 수 있었음. => 그리고 추후에 각자 모의 면접 자세나 이런 저런 것들에 대해 피드백도 적었는데, 도움이 많이 됨. 내가 부족한 것이 무엇이고, 어떤 질문에 내가 답을 못했는지, 알 수 있음.
	그러곤 ! 곧 역량테스트 결과가 나올 것이라고 생각하고, 결과가 나오면 그 다음주 오프라인을 진행할지 말지 결정하기로 함.
sw 역량테스트 결과 발표 (일정 및 장소는 몇시간 뒤에 발표 됨.)	2024. 05. 10 (금) 나는 일정이 있어, 그 주에 오프라인 스터디를 못했고, 다음 주에 바로 면접을 보는 스터디원이 있어 저번주의 오프라인 스터디가 마지막이였음.
1차 ssafy 면접 컨설팅	2024. 05. 16 (목)
	1. 컨설턴트님이 미리 주신 면접 질문 리스트에 대해 스크립트 작성한 것을 바탕으로 스크립트 첨삭 진행. => 생각보다 내가 작성한 스크립트가 너무 추상적이였고, 그래서 질문 폭탄으로 이어질 수도 있다는 점을 알 수 있었음. 다음 컨설팅 때 더 보완해서 첨삭받기로 함.
김보은 아나운서님 스피치 코칭	2024. 05. 22 (수) 8시 ~ 9시
	엄마의 추천으로 하게 됨. ssafy 출근하는데 전화주셔서 간단히 주신 질문에 대한 답변이 준비되어있는지를 판단하시고 (준비가 너무 안되어 있으면 1회도 안해주신다고 하시던데 .. 다행 .. ), 남은 시간이 별로 없기에 1회 정도 진행하기로 함. => 아침에 전화 온 내용과 내가 답변해보면서 자신감이 많이 하락이 되어서 .. 면접이 2일 남은 시점에서 자신감이 떨어지진 않을까 걱정하긴 했는데, 내가 생각하지 못한 질문과 답변을 해보면서 결과적으로는 [임원 면접]에 도움이 많이 됨. 그리고 내가 어떤 식의 말투와 자세로 답변을 하는지 파악하고, 놓쳤던 질문들에 대한 답변을 준비할 수 있었음.
2차 ssafy 면접 컨설팅	2024. 05. 23 (목) 오전 10시
	원래 20일에 진행할 예정이였으나, 스크립트 피드백에 대해 내가 다시 스크립트를 작성했던 부분이 거의 없었음. (ssafy에서 그 당시 마지막 파이널 관통 프로젝트를 진행하고 있어, 병행하기 너무 힘들었음.. ) 그래서 23일로 연기해서 더 준비해서 컨설팅 진행함. 1. 스크립트 2차 피드백 2. 간단히 모의 면접 진행함. (들어오거나 나가는 자세와 인사하는 것들 봐주시고, 1분 자기소개까지 하면서 내 말투와 속도와 같은 부분 봐주심.) => 이때 1분 자기소개 외에도 더 질문 받고 싶은거 있냐고 물어봐주셨는데, 내가 고민하면서 스크립트 작성에 시간투자는 많이 했으나, 나는 이게 외우지 않았고, 내 것으로 되어있지 않아 답할 수 없는 상황이였다고 생각해서 1분 자기소개만 함 (면접 하루전인데 ? 외우지 못했다는 생각에 너무 마음이 급했음) 그래도 준비를 꼼꼼히 해서 놀라셨다는 컨설턴트님의 말씀 + 여러가지 응원의 말씀으로 면접 하루 전에 자신감을 되찾을 수 있었음 !! (너무 감사했음)
오빠 집으로	2024. 05. 23 (목)
	오전에 컨설팅을 하고, 임의 조퇴를 하고 '청주'에 사는 오빠 집으로 감. 가는 길에 작성한 스크립트 계속 외움. 오빠랑 저녁 먹고, 면접장에서 혹여나 종이는 봐도 되지 않을까라는 생각에 최종 정리해둔 것 다 프린트 함. (그리고 나는 종이에 적힌 내용들이 더 잘 외워짐) 오빠 집 가서 면접복 입어보고, 오빠가 하라고 준 마스크 팩 하면서 피부 관리 까지 !! 하고 약 12:00 쯤 잠에 듦.
면접	2024. 05. 24 (금)
	장소 : 삼성전자 인재 개발원 (수원) 시간 : 07:00 AM 20분 전부터 입장 가능하기 때문에, 정말 시간이 빠르다고 생각함. 오빠 집에서 1시간 30분 정도 걸렸기 때문에, 준비 한시간 까지 + 더 공부하기 위해서 03:00 AM에 기상해서 [ 임원 면접 ] 프린트 해둔 최종 정리 스크립트를 계속 외우고, [ 직무 면접 ] CS 공부를 거의 못해서.. 나올 것 같은 개념들 (쓰레드 vs 프로세스와 같은) 한번씩 쭉 읽음. [ 창의성 면접 ] 그리고 ssafy 면접 준비할 때 사용했던 창의성 pt 면접 템플릿 그제서야 외움. (면접 스터디때를 제외하곤 거의 준비 안함.) 이건 하루 아침에 될 것은 아니라고 생각했고, 중요도는 임원 > 직무 > 창의성 이기 때문에 템플릿만 계속 외움. 가기 전에 청주에서 간단히 편의점 김밥 + 신라면 작은 거 먹음 (오빠도 많이 배고파 함) 결과적으로는, 07 : 00 에 면접장 들어가서 13 : 30 분 되서야 나옴. 구체적인 면접 진행 방식은 아래에 설명하겠음 !

[삼성 전자 DX] SW 역량 테스트 준비

sanadoing_ — Sat, 1 Jun 2024 16:35:11 +0900

나중에 제가 참고하기 위해서 기록용으로 작성해볼랍니다 !

일정 ️

일자
~ 2024. 03. 18	서류 제출 마감
2024. 04. 14	sw 역량 테스트

삼성 전자 서류 합격 후
거의 2주일 정도 뒤에 sw 역량 테스트 일정이 있었던 것 같아요 !

현재 ssafy를 하고 있어서 당시 병행하기에 조금 힘들긴 했는데,
그때 DB관련 내용을 배우고 있어서 조금 익숙하기도 했고,
선택과 집중이 필요한 시기라고 생각했기 때문에 강사님께 따로 양해를 구해서 자습을 진행했습니다 !

무조건 삼성 sw 역량테스트는 시뮬레이션 + 구현 + BFS/DFS graph 가 나오기 때문에
백준 기출 문제집을 풀이를 했습니다.
https://www.acmicpc.net/workbook/view/1152

주로 매일 매일 새로운 문제를 하나씩 풀고자 했으나 ??
시간이 없기 때문에 앞서 1주일은 시간 정해서 1시간 정도 한 문제씩 풀었고,
남은 1주일은 풀었던 문제 다시 풀어보면서 감 잡기 했습니다.

아 그리고, 한 문제를 풀더라도 오래 걸리면 바로 보고 익숙해지려고도 했는데,
2~3일은 그때 정한 문제를 시간 안에 못풀더라도 4~5시간이 걸리더라도 (주로 주말에)
계속 붙잡으면서 어느 부분에서 못풀었는지 좀 붙잡고 고민하는 시간도 필요하다고 생각합니다.
자꾸 생각하고 어느 부분이 문제인지를 고민해보는 과정도 감 잡기에 좋았다고 생각하기 때문임니다 !!!!

sw 역량테스트를 위한 나만의 방법 ✏️

1. 그리고 시뮬레이션 구현은 어려운 알고리즘을 사용한다기 보다는,
문제 그대로 풀면 되지만 ? 주어진 조건들이 많아 하나하나씩 구현할 때마다 디버깅을 그때그때 하는 것이 중요합니다.

2. 시뮬레이션에 잘 나오는 2차원배열에서의 4방향, 8방향 이동이나, 기본적인 BFS/DFS 코드를 눈 감고도 구현할 수 있게 연습했습니다. 저는 특히 DFS가 가끔 헷갈릴 때가 있어서 DFS 실버급 문제도 좀 많이 풀려고 노력했습니다.

3. 그리고, 역량테스트에서 2문제가 나오는데 문제 선택이 제일 중요하다고 생각했습니다.
(보통 골드, 플레 문제가 하나씩 나오는데 처음 고른 문제가 플레 문제라면.. 얼마나 암담합니까 !!!!)

https://www.codetree.ai/training-field/frequent-problems/company/samsung/problems

코드트리 | 코딩테스트 준비를 위한 알고리즘 정석

국가대표가 만든 코딩 공부의 가이드북 코딩 왕초보부터 꿈의 직장 코테 합격까지, 국가대표가 엄선한 커리큘럼으로 준비해보세요.

www.codetree.ai

위에 사이트가 이제껏 삼성에 나왔던 기출인데, 저는 코테 치고 난 후에 이 사이트를 알았네요 *^-^*
내용과 조건은 다 같은데, 문제에 사용하는 컨셉이(?) 좀 다르고, 더 이해하기 쉽게 나왔던 것 같아요.
저는 마법의 숲 탐색이 아니라 우주선이 떨어지고 외계인이 가장 얻을 수 있는 높은 점수들의 합을 구하는 문제였습니다.

이번 상반기 오후 타임에는 이 두 문제가 나왔고,
저는 다행히도 골드 3을 골라서 2시간 35분만에 풀었습니다.

1솔이고, 2시간 35분만에 풀어서 찾아보니까 1솔에서 1시간 30분내로 푼 사람들만 통과했다는 내용들이 대부분이였는데
다행히도 붙었네요 ...
풀이 할 때도 진짜 딱 '골드 3' 문제라고 생각해서 이거 2시간 30분 만에 풀었으니까.. 못 붙을 것 같았어요 .. 그냥 .. 작년 하반기보다는 내가 성장했구나 ~ 로 생각하기로 했었습니다. ( )

계속 예제의 값과는 더 적은 값들이 나와서, 우주선이 떨어지는 로직은 아무리 생각해도 틀린 게 없는데
우주선에 있는 외계인이 점수를 얻는 과정에서 외계인이 우주선들을 이동하는데 이동할 수 있는 조건을 하나 빼먹었더라구요 ..
그거 때문에 한시간 정도 날렸었고, 다행히도 딱 그 조건 추가하니까 10개의 예제가 한번에 다 맞아서
계속 그 문제를 붙잡고 있으면, 문제 풀이 시간이 늘어나서 확신을 가지고 다음 문제 풀이로 넘어갔습니닷 !

하지만 그 2시간 35분동안 너무 초집중 했던 시간이였어서, 다음 문제를 붙잡으려고 하니까 너무 어렵고 집중이 잘 안되더라구요.
위에 플레 4 '색깔트리' 문제보다 더 문제를 이해하기 어렵게 나왔었고,
계속 붙잡고 있었어도 플레 4문제는 저는 못 풀었을 것이라고 생각합니다 ㅎㅎ

그 때의 나의 멘탈 ..

ssafy 9-6하고 퇴근하고 집 오면 밥 먹고 먹으면 잠 오고 ..
ssafy에서의 시간도 나름의 자습을 하면서 준비했다고 생각했지만
병행하다보니까 다른 사람보다 시간을 더 투자하지 못한다는 생각에 나름 스트레스도 받기도 하고,
자꾸 잠을 이겨내지 못하는 제 자신에 너무 속상했었던 기억이 있네요

그래서 밥 먹자마자 바로 커피 드링킹하고 새벽 2시까지 하려고 했고 (좀 많이 졸았지만), 그냥 감을 잡으려고 노력했습니다.
그래서 잡은 감으로 ssafy에서 A+도 덕분에 같이 준비하면서 땄네요 >_<
그리고 A+로 자신감 얻어서 기간 겹쳤던게 감사했다 ~ 이 말 입니닷

그리고 다른 사람보다 시간을 더 못 투자한다라는 생각으로
제가 가진 시간을 더 효율적으로 퐉 집중할 수 있는 시간으로 보낼 수 있게 해주었던 생각이였다고 생각합니다.
(시간이 많다고 그 시간을 더 잘 활용하는 건 아니지 않슴니까 ?)

그래서 이러한 과정을 결국 면접을 볼 수 있었던 기회를 얻을 수 있었네요 !
sw 역량테스트 치고 한 문제를 풀었으니까 일단 붙었다고 생각하고,
ssafy에 삼성전자 같이 코테 풀었던 한 분과 B형 붙어서 코테 면제 받으셨던 분과 함께
같이 3명이서 면접 스터디를 진행했습니다.

면접 준비는 다음 포스팅에 계속 .. !!!!

[Java] 그래프 기본 템플릿

sanadoing_ — Tue, 9 Apr 2024 01:37:58 +0900

DFS

package study.blog.codingnojam;

public class Study_DFS_Recursion {

	// 방문처리에 사용 할 배열선언
	static boolean[] vistied = new boolean[9];
	
	// 그림예시 그래프의 연결상태를 2차원 배열로 표현
	static int[][] graph = {{}, {2,3,8}, {1,6,8}, {1,5}, {5,7}, {3,4,7}, {2}, {4,5}, {1,2}};
	
	public static void main(String[] args) {
		dfs(1);
	}
	
	static void dfs(int nodeIndex) {
		// 방문 처리
		vistied[nodeIndex] = true;
		
		// 방문 노드 출력
		System.out.print(nodeIndex + " -> ");
		
		// 방문한 노드에 인접한 노드 찾기
		for (int node : graph[nodeIndex]) {
			// 인접한 노드가 방문한 적이 없다면 DFS 수행
			if(!vistied[node]) {
				dfs(node);
			}
		}
	}
}

BFS

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Queue;
import java.util.StringTokenizer;

public class B_16234 {

	static int N, L, R;
	static int[][] board, new_board;
	static boolean[][] visit;
	static int[] dy = new int[] { -1, 0, 1, 0 };
	static int[] dx = new int[] { 0, 1, 0, -1 };

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		N = Integer.parseInt(st.nextToken());
		L = Integer.parseInt(st.nextToken());
		R = Integer.parseInt(st.nextToken());

		board = new int[N][N];
		new_board = new int[N][N];
		for (int i = 0; i < N; i++) {
			st = new StringTokenizer(br.readLine());
			for (int j = 0; j < N; j++) {
				board[i][j] = Integer.parseInt(st.nextToken());
			}
		}

		int t = 0;
		while (true) {

			visit = new boolean[N][N];
			boolean check = false;
			for (int i = 0; i < N; i++) {
				for (int j = 0; j < N; j++) {
					if (visit[i][j])
						continue;
					if (bfs(i, j) > 1) {
						check = true;
					}
				}
			}
			if (!check)// 연합한 국가들이 없었다면
			{
				break;
			}
			for (int i = 0; i < N; i++) {
				board[i] = new_board[i].clone();
			}

			t += 1;
		}
		System.out.println(t);

	}

	static int bfs(int sy, int sx) {

		Queue<int[]> queue = new ArrayDeque<>(); // bfs를 위한 queue
		Queue<int[]> queue2 = new ArrayDeque<>(); // 나라 상태 변화를 위한 queue - 인구 이동할 나라들을 담을 queue
		queue.offer(new int[] { sy, sx });
		queue2.offer(new int[] { sy, sx });
		visit[sy][sx] = true;

		int sumPeople = 0;
		int countryCnt = 0;

		while (!queue.isEmpty()) {
			int[] now = queue.poll();
			int ny = now[0];
			int nx = now[1];

			sumPeople += board[ny][nx];
			countryCnt += 1;

			for (int i = 0; i < 4; i++) {
				int yy = ny + dy[i];
				int xx = nx + dx[i];

				if (yy < 0 || yy > N - 1 || xx < 0 || xx > N - 1)
					continue;
				if (visit[yy][xx])
					continue;

				int gap = Math.abs(board[ny][nx] - board[yy][xx]);

				if (gap >= L && gap <= R) {
					visit[yy][xx] = true;
					queue.offer(new int[] { yy, xx });
					queue2.offer(new int[] { yy, xx });
				}
			}
		}

		// 연합할 국가들이 없다면 기존의 값 담아줌.
		if (countryCnt == 1) {

			new_board[sy][sx] = board[sy][sx];

		} else if (countryCnt > 1) { // 연합할 국가들이 있다면 new_board에 값 담아줌

			int movePeople = sumPeople / countryCnt;
			while (!queue2.isEmpty()) {
				int[] now = queue2.poll();

				new_board[now[0]][now[1]] = movePeople;

			}

		}
		return countryCnt;
	}
}

Dijkstra

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.StringTokenizer;

// (틀림 51%) 출발지에서 목적지로 갈 수 없는 경우에 대한 언급은 없지만
// 그럴 경우가 있으므로 그럴 땐 0을 출력해줘야 함.
public class B_13905 {

	static int houseCnt, bridgeCnt, startPoint, endPoint;
	static List<List<Node>> houseList;

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		StringTokenizer st = new StringTokenizer(br.readLine());
		houseCnt = Integer.parseInt(st.nextToken());
		bridgeCnt = Integer.parseInt(st.nextToken());

		st = new StringTokenizer(br.readLine());
		startPoint = Integer.parseInt(st.nextToken());
		endPoint = Integer.parseInt(st.nextToken());

		houseList = new ArrayList<>();
		for (int i = 0; i < houseCnt + 1; i++) {
			houseList.add(new ArrayList<>()); // 0 dummy
		}

		for (int i = 0; i < bridgeCnt; i++) {
			st = new StringTokenizer(br.readLine());
			int s = Integer.parseInt(st.nextToken());
			int e = Integer.parseInt(st.nextToken());
			int c = Integer.parseInt(st.nextToken());

			houseList.get(s).add(new Node(e, c));
			houseList.get(e).add(new Node(s, c));
		}

		System.out.println(dijkstra());
	}

	static int dijkstra() {
		boolean[] visit = new boolean[houseCnt + 1]; // 0 dummy

		Queue<Node> pqueue = new PriorityQueue<>((n1, n2) -> n2.c - n1.c);

		pqueue.offer(new Node(startPoint, 0));

		int result = Integer.MAX_VALUE;
		while (!pqueue.isEmpty()) {
			Node current = pqueue.poll();
			if (visit[current.e])
				continue;
			visit[current.e] = true;

			if (current.c != 0)
				result = Math.min(result, current.c);
			if (current.e == endPoint)
				return result;
			for (Node next : houseList.get(current.e)) {
				if (visit[next.e])
					continue;
				pqueue.offer(next);
			}
		}
		return 0;
	}

	static class Node {
		int e;
		int c;

		public Node(int e, int c) {
			super();
			this.e = e;
			this.c = c;
		}

		@Override
		public String toString() {
			return "Node [e=" + e + ", c=" + c + "]";
		}

	}
}

Prim

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.StringTokenizer;

public class B_1389 {

	static int N, M;
	static List<List<Integer>> connection;
	static int baconCnt = Integer.MAX_VALUE, answer;

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());

		connection = new ArrayList<>();
		for (int i = 0; i < N + 1; i++) {
			connection.add(new ArrayList<>());
		}

		for (int i = 0; i < M; i++) {
			st = new StringTokenizer(br.readLine());
			int s = Integer.parseInt(st.nextToken());
			int e = Integer.parseInt(st.nextToken());
			connection.get(s).add(e);
			connection.get(e).add(s);

		}

		for (int i = 1; i < N + 1; i++) {
			int s = check(i);
			if (baconCnt > s) {
				baconCnt = s;
				answer = i;
			}
		}
		System.out.println(answer);
	}

	static int check(int start) {
		Queue<int[]> queue = new ArrayDeque<>();
		queue.add(new int[] { start, 0 });
		boolean[] visited = new boolean[N + 1];
		int sum = 0;

		while (!queue.isEmpty()) {
			int[] now = queue.poll();
			int nowNode = now[0];
			int nowCnt = now[1];

			if (visited[nowNode])
				continue;

			visited[nowNode] = true;
			sum += nowCnt;

			for (int next : connection.get(nowNode)) {
				if (visited[next])
					continue;
				queue.offer(new int[] { next, nowCnt + 1 });

			}

		}
		return sum;
	}

}

참고

https://codingnojam.tistory.com/44

[백준 20058번] 마법사 상어와 파이어스톰 (Java)

sanadoing_ — Mon, 8 Apr 2024 22:47:56 +0900

> 자바, 구현, 그래프 이론, 그래프 탐색, 시뮬레이션, 너비 우선 탐색, 깊이 우선 탐색

문제 : 마법사 상어와 파이어스톰 (Java)

마법사 상어는 파이어볼과 토네이도를 조합해 파이어스톰을 시전할 수 있다. 오늘은 파이어스톰을 크기가 2N × 2N인 격자로 나누어진 얼음판에서 연습하려고 한다. 위치 (r, c)는 격자의 r행 c열을 의미하고, A[r][c]는 (r, c)에 있는 얼음의 양을 의미한다. A[r][c]가 0인 경우 얼음이 없는 것이다.

파이어스톰을 시전하려면 시전할 때마다 단계 L을 결정해야 한다. 파이어스톰은 먼저 격자를 2L × 2L 크기의 부분 격자로 나눈다. 그 후, 모든 부분 격자를 시계 방향으로 90도 회전시킨다. 이후 얼음이 있는 칸 3개 또는 그 이상과 인접해있지 않은 칸은 얼음의 양이 1 줄어든다. (r, c)와 인접한 칸은 (r-1, c), (r+1, c), (r, c-1), (r, c+1)이다. 아래 그림의 칸에 적힌 정수는 칸을 구분하기 위해 적은 정수이다.


마법을 시전하기 전	L = 1	L = 2

마법사 상어는 파이어스톰을 총 Q번 시전하려고 한다. 모든 파이어스톰을 시전한 후, 다음 2가지를 구해보자.

남아있는 얼음 A[r][c]의 합
남아있는 얼음 중 가장 큰 덩어리가 차지하는 칸의 개수

얼음이 있는 칸이 얼음이 있는 칸과 인접해 있으면, 두 칸을 연결되어 있다고 한다. 덩어리는 연결된 칸의 집합이다.

입력

첫째 줄에 N과 Q가 주어진다. 둘째 줄부터 2N개의 줄에는 격자의 각 칸에 있는 얼음의 양이 주어진다. r번째 줄에서 c번째 주어지는 정수는 A[r][c] 이다.

마지막 줄에는 마법사 상어가 시전한 단계 L1, L2, ..., LQ가 순서대로 주어진다.

출력

첫째 줄에 남아있는 얼음 A[r][c]의 합을 출력하고, 둘째 줄에 가장 큰 덩어리가 차지하는 칸의 개수를 출력한다. 단, 덩어리가 없으면 0을 출력한다.

제한

2 ≤ N ≤ 6
1 ≤ Q ≤ 1,000
0 ≤ A[r][c] ≤ 100
0 ≤ Li ≤ N

예제 입력 1

3 1
1 2 3 4 5 6 7 8
8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8
8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8
8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8
8 7 6 5 4 3 2 1
1

예제 출력 1

284
64

예제 입력 2

3 2
1 2 3 4 5 6 7 8
8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8
8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8
8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8
8 7 6 5 4 3 2 1
1 2

예제 출력 2

280
64

내 코드

package a_samsung;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Queue;
import java.util.StringTokenizer;

public class B_20058_마법사상어와파이어스톰 {

  static int N, Q, L, mapSize;
  static int[][] map;
  static int[] dy = new int[] { -1, 0, 1, 0 };
  static int[] dx = new int[] { 0, 1, 0, -1 };
  static int iceSum = 0;
  static int iceCnt = 0;

  public static void main(String[] args) throws Exception {

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());
    N = Integer.parseInt(st.nextToken());
    Q = Integer.parseInt(st.nextToken());

    mapSize = (int) Math.pow(2, N);
    map = new int[mapSize][mapSize];

    for (int i = 0; i < mapSize; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 0; j < mapSize; j++) {
        map[i][j] = Integer.parseInt(st.nextToken());
      }
    }

    st = new StringTokenizer(br.readLine());
    for (int i = 0; i < Q; i++) {
      L = Integer.parseInt(st.nextToken());
      iceCnt = 0;
      if (L == 0) {
        L = 1;
      } else {
        L = (int) Math.pow(2, L);
      }

      map_change();

      melt_ice();

      find_ice();

    }
    System.out.println(iceSum);
    System.out.println(iceCnt);
  }

  static void find_ice() {
    boolean[][] visit = new boolean[mapSize][mapSize];

    for (int i = 0; i < mapSize; i++) {
      for (int j = 0; j < mapSize; j++) {
        if (visit[i][j])
          continue;
        if (map[i][j] > 0) {
          Queue<int[]> queue = new ArrayDeque<>();
          queue.offer(new int[] { i, j });
          visit[i][j] = true;
          int cnt = 1;
          while (!queue.isEmpty()) {
            int[] current = queue.poll();
            int cy = current[0];
            int cx = current[1];

            for (int k = 0; k < 4; k++) {
              int yy = cy + dy[k];
              int xx = cx + dx[k];
              if (yy < 0 || xx < 0 || yy > mapSize - 1 || xx > mapSize - 1 || visit[yy][xx])
                continue;

              if (map[yy][xx] > 0) {
                visit[yy][xx] = true;
                queue.offer(new int[] { yy, xx });
                cnt += 1;
              }
            }
          }

          iceCnt = Math.max(iceCnt, cnt);
        }
      }
    }

  }

  static void melt_ice() {
    int[][] new_map = new int[mapSize][mapSize];
    int sum = 0;

    for (int y = 0; y < mapSize; y++) {
      for (int x = 0; x < mapSize; x++) {

        int iceCnt = 0;

        for (int i = 0; i < 4; i++) {
          int yy = y + dy[i];
          int xx = x + dx[i];

          if (0 > yy || 0 > xx || yy > mapSize - 1 || xx > mapSize - 1)
            continue;

          if (map[yy][xx] > 0)
            iceCnt += 1;

        }

        if (iceCnt < 3) {
          if (map[y][x] == 0) {
            new_map[y][x] = 0;
          } else {
            new_map[y][x] = map[y][x] - 1;
          }

        } else {
          new_map[y][x] = map[y][x];
        }
        sum += new_map[y][x];
      }

    }
    for (int i = 0; i < mapSize; i++) {
      map[i] = new_map[i].clone();
    }
    iceSum = sum;

  }

  static void map_change() {

    for (int i = 0; i < mapSize / L; i++) {
      for (int j = 0; j < mapSize / L; j++) {
        int[] tempIce = new int[L * L];
        int startY = i * L;
        int startX = j * L;
        int idx = 0;

        for (int y = startY; y < startY + L; y++) {
          for (int x = startX; x < startX + L; x++) {
            tempIce[idx] = map[y][x];

            idx += 1;
          }
        }

        idx = 0;
        for (int x = startX + L - 1; x >= startX; x--) {
          for (int y = startY; y < startY + L; y++) {
            map[y][x] = tempIce[idx];
            idx += 1;
          }
        }

      }

    }

  }
}

백준

https://www.acmicpc.net/problem/20058

20058번: 마법사 상어와 파이어스톰

마법사 상어는 파이어볼과 토네이도를 조합해 파이어스톰을 시전할 수 있다. 오늘은 파이어스톰을 크기가 2N × 2N인 격자로 나누어진 얼음판에서 연습하려고 한다. 위치 (r, c)는 격자의 r행 c

www.acmicpc.net

[백준 5373번] 큐빙 (Java)

sanadoing_ — Mon, 8 Apr 2024 13:56:08 +0900

> 자바, 구현, 시뮬레이션

문제 : 큐빙 (Java)

루빅스 큐브는 삼차원 퍼즐이다. 보통 루빅스 큐브는 3×3×3개의 작은 정육면체로 이루어져 있다. 퍼즐을 풀려면 각 면에 있는 아홉 개의 작은 정육면체의 색이 동일해야 한다.

큐브는 각 면을 양방향으로 90도 만큼 돌릴 수 있도록 만들어져 있다. 회전이 마친 이후에는, 다른 면을 돌릴 수 있다. 이렇게 큐브의 서로 다른 면을 돌리다 보면, 색을 섞을 수 있다.

이 문제에서는 루빅스 큐브가 모두 풀린 상태에서 시작한다. 윗 면은 흰색, 아랫 면은 노란색, 앞 면은 빨간색, 뒷 면은 오렌지색, 왼쪽 면은 초록색, 오른쪽 면은 파란색이다.

루빅스 큐브를 돌린 방법이 순서대로 주어진다. 이때, 모두 돌린 다음에 가장 윗 면의 색상을 구하는 프로그램을 작성하시오.

위의 그림은 루빅스 큐브를 푼 그림이다. 왼쪽 면은 시계방향으로 조금 돌려져 있는 상태이다.

입력

첫째 줄에 테스트 케이스의 개수가 주어진다. 테스트 케이스는 최대 100개이다. 각 테스트 케이스는 다음과 같이 구성되어져 있다.

첫째 줄에 큐브를 돌린 횟수 n이 주어진다. (1 ≤ n ≤ 1000)
둘째 줄에는 큐브를 돌린 방법이 주어진다. 각 방법은 공백으로 구분되어져 있으며, 첫 번째 문자는 돌린 면이다. U: 윗 면, D: 아랫 면, F: 앞 면, B: 뒷 면, L: 왼쪽 면, R: 오른쪽 면이다. 두 번째 문자는 돌린 방향이다. +인 경우에는 시계 방향 (그 면을 바라봤을 때가 기준), -인 경우에는 반시계 방향이다.

출력

각 테스트 케이스에 대해서 큐브를 모두 돌린 후의 윗 면의 색상을 출력한다. 첫 번째 줄에는 뒷 면과 접하는 칸의 색을 출력하고, 두 번째, 세 번째 줄은 순서대로 출력하면 된다. 흰색은 w, 노란색은 y, 빨간색은 r, 오렌지색은 o, 초록색은 g, 파란색은 b.

예제 입력 1

4
1
L-
2
F+ B+
4
U- D- L+ R+
10
L- U- L+ U- L- U- U- L+ U+ U+

예제 출력 1

rww
rww
rww
bbb
www
ggg
gwg
owr
bwb
gwo
www
rww

내 코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class B_5373 {

	static char[] Qube, colors;
	static int[][] change;
	static StringTokenizer st;

	public static void main(String[] args) throws Exception {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int T = Integer.parseInt(br.readLine());
		for (int t = 1; t <= T; t++) {
			int N = Integer.parseInt(br.readLine());

			// 큐브 초기화
			Qube = new char[] { 'w', 'w', 'w', 'w', 'w', 'w', 'w', 'w', 'w', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g',
					'g', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'o',
					'o', 'o', 'o', 'o', 'o', 'o', 'o', 'o', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y' };
			colors = new char[] { 'w', 'g', 'r', 'b', 'o', 'y' };

			int colorIdx = 0;
			int idx = 0;

			change = new int[][] { { 38, 37, 36, 29, 28, 27, 20, 19, 18, 11, 10, 9 }, // U - w (흰)
					{ 0, 3, 6, 18, 21, 24, 45, 48, 51, 44, 41, 38 }, // L - g (초록)
					{ 6, 7, 8, 27, 30, 33, 47, 46, 45, 17, 14, 11 }, // F - r (빨간)
					{ 8, 5, 2, 36, 39, 42, 53, 50, 47, 26, 23, 20 }, // R - b (파란)
					{ 2, 1, 0, 9, 12, 15, 51, 52, 53, 35, 32, 29 }, // B - o (오렌지)
					{ 24, 25, 26, 33, 34, 35, 42, 43, 44, 15, 16, 17 } // D - y (노랑)
			};

			st = new StringTokenizer(br.readLine());

			for (int i = 0; i < N; i++) {
				String command = st.nextToken();
				char c = command.charAt(0); // U, L, F, R, B, D
				char d = command.charAt(1); // -, +

				int changeIdx = 0;
				int cnt;
				if (d == '+') {
					cnt = 1;
				} else {
					cnt = 3;
				}
				if (c == 'U') {
					changeIdx = 0;
				} else if (c == 'L') {
					changeIdx = 1;
				} else if (c == 'F') {
					changeIdx = 2;
				} else if (c == 'R') {
					changeIdx = 3;
				} else if (c == 'B') {
					changeIdx = 4;
				} else if (c == 'D') {
					changeIdx = 5;
				}

				change_qube(changeIdx, cnt);

			}
			for (int f = 0; f < 9; f++) {
				System.out.print(Qube[f]);
				if (f % 3 == 2) {
					System.out.println();
				}

			}
		}
	}

	static void change_qube(int changeIdx, int cnt) {

		for (int i = 0; i < cnt; i++) {

//			fourSide(changeIdx);
			// 다른 쪽 면 4방향의 1줄씩 회전
			char temp1 = Qube[change[changeIdx][9]];
			char temp2 = Qube[change[changeIdx][10]];
			char temp3 = Qube[change[changeIdx][11]];

			for (int j = 3; j > 0; j--) {
				Qube[change[changeIdx][j * 3 + 0]] = Qube[change[changeIdx][(j - 1) * 3 + 0]];
				Qube[change[changeIdx][j * 3 + 1]] = Qube[change[changeIdx][(j - 1) * 3 + 1]];
				Qube[change[changeIdx][j * 3 + 2]] = Qube[change[changeIdx][(j - 1) * 3 + 2]];
			}
			Qube[change[changeIdx][0]] = temp1;
			Qube[change[changeIdx][1]] = temp2;
			Qube[change[changeIdx][2]] = temp3;

//			fourSide(changeIdx);
//			nowSide(changeIdx);
			// 현재 해당하는 면 회전
			temp1 = Qube[changeIdx * 9 + 2];
			temp2 = Qube[changeIdx * 9 + 1];
			temp3 = Qube[changeIdx * 9];

			Qube[changeIdx * 9 + 2] = Qube[changeIdx * 9];
			Qube[changeIdx * 9 + 1] = Qube[changeIdx * 9 + 3];
			Qube[changeIdx * 9] = Qube[changeIdx * 9 + 6];

			Qube[changeIdx * 9] = Qube[changeIdx * 9 + 6];
			Qube[changeIdx * 9 + 3] = Qube[changeIdx * 9 + 7];
			Qube[changeIdx * 9 + 6] = Qube[changeIdx * 9 + 8];

			Qube[changeIdx * 9 + 6] = Qube[changeIdx * 9 + 8];
			Qube[changeIdx * 9 + 7] = Qube[changeIdx * 9 + 5];
			Qube[changeIdx * 9 + 8] = Qube[changeIdx * 9 + 2];

			Qube[changeIdx * 9 + 8] = temp1;
			Qube[changeIdx * 9 + 5] = temp2;
			Qube[changeIdx * 9 + 2] = temp3;

//			nowSide(changeIdx);

		}

	}

//	static void nowSide(int changeIdx) {
//		System.out.println("====nowSide====");
//		for (int f = 0; f < 9; f++) {
//			System.out.print(Qube[9 * changeIdx + f]);
//			if (f % 3 == 2) {
//				System.out.println();
//			}
//
//		}
//		System.out.println("========");
//	}
//
//	static void fourSide(int changeIdx) {
//		System.out.println("====fourSide====");
//		for (int f = 0; f < 12; f++) {
//			System.out.print(Qube[change[changeIdx][f]]);
//
//		}
//		System.out.println("========");
//	}

}

Point ! ⭐️

꼼꼼히 !!

백준

https://www.acmicpc.net/problem/5373

5373번: 큐빙

각 테스트 케이스에 대해서 큐브를 모두 돌린 후의 윗 면의 색상을 출력한다. 첫 번째 줄에는 뒷 면과 접하는 칸의 색을 출력하고, 두 번째, 세 번째 줄은 순서대로 출력하면 된다. 흰색은 w, 노란