반응형
오늘은 자료구조의 기본 구조 중 하나인 큐에 대해서 알아보고자 한다.
가장 기본적인 구조로 선입선출 ( FIFO, First In First Out ) 방식을 가진다.
먼저 온 사람이 나가는 흔히 매장에 줄 서는 과정이라 볼 수 있다.
( Queue 단어 자체가 표 같은 것을 구매하기 위해 줄 서는 것을 의미 )

 

큐 ( Queue )

  • 선입 선출 ( FIFO, First In First Out )
  • 데이터가 들어오는 위치는 가장 뒤 Rear or Back 에서 이루어지고, 데이터가 나가는 위치인 가장 앞 Front, 양쪽에서 삽입 삭제가 이루어진다.
  • BFS ( 너비 우선 탐색 ), 프로세서 핸들링 ( CPU 헤드링 ) 등에 사용.
class Queue{
    private LinkedList<Integer> queue;

    public Queue(){
        queue = new LinkedList<>();
    }
    ....
}

큐의 기본 연산

1. Enqueue(value): 데이터 삽입

  • 큐의 맨 뒤(back)에 데이터를 추가하는 연산
    public void enQueue(int x){
        queue.addLast(x);
    }

 

2. Dequeue(): 데이터 제거

  • 큐의 맨 앞(front)에 있는 데이터를 제거하고 반환하는 연산
    public int depQueue(){
        if(queue.isEmpty()){
            return -1;
        }
        return queue.removeFirst();
    }

3. peek() : 최상단 데이터 확인

  • 큐의 맨 앞(front)에 있는 데이터를 반환하지만, 제거하지 않음
    public int peek(){
        if(queue.isEmpty()){
            return -1;
        }
        return queue.getFirst();
    }

4. isEmpty(): 큐이 비어 있는지 확인

  • 큐가 비어 있으면 true, 아니면 false 반환
    public boolean isEmpty(){
        return queue.isEmpty() ? true : false;
    }

로직 예시)

1. 빈 큐다

2. Enqueue ( 2 ) 를 통해 가장 앞 부터 채워 넣는다.

3. Enqueue ( 4 ) 를 통해 2 다음에(뒤에서부터) 채워 넣는다.

4. Dequeue 릍 통해 가장 앞에 있는 2를 꺼내고 4를 앞으로 옮긴다.

추가 - JAVA의 큐 관련 클래스

자바에서 큐는 Interface로 구현되어 ArrayDeque, LinkedList, PriorityQueue로 직접 구현할 수 있다.

그 밖에도 Blocking 즉 고정된 크기의 배열을 사용하는 큐도 존재한다.

이는 자바에서 원형 큐의 고정된 크기를 구현하기 위함으로 보인다.

이 글에서는 LinkedList로 정의된 큐와 달리 양쪽에서 삽입과 삭제가 이루어질 수 있는 양방향 큐이며, 메모리 동적인 요소를 가지고 있다.

 

ArrayDeque도 비슷하나 LinkedList와는 다르다. 배열로 사용되며 동적으로 변하긴 하지만, 배열을 다시 늘려야하는 번거로움이 있다. 추후 ArrayList와 LinkedList의 차이에 대해 포스팅할 예정이다.

DeQueue

 양방향에서 삽입/삭제가 이루어 질 수 있는 양방향 큐를 의미한다.

원형 큐

blocking으로 정의된 큐는 원형 큐라고 할 수 있으며 다음과 같은 형태을 가진다.

데이터가 삽입/삭제 됨에 따라 front와 back(rear)를 가리키는 위치가 계속 변하지만, 크기는 고정된 상태로 이루어진다.

다음과 같이 예시를 볼 수 있다.

PriorityQueue

우선순위 큐로 우선순위 비교는 Comparable interface를 활용하여 구현하거나 Comparator를 사용하여 설정할 수 있다.

중복 요소를 허용하고, 정렬된 순서로 요소를 처리하기 때문에 성능에 영향이 줄 수 있는 큐다.

PriorityQueue<Integer> queue = new PriorityQueue<>();
queue.add(3);
queue.add(1);
queue.add(2);

System.out.println(queue.poll());  // 1 (가장 작은 값이 먼저 출력됨)
PriorityQueue<Integer> queue = new PriorityQueue<>(Comparator.reverseOrder());
queue.add(1);
queue.add(3);
queue.add(2);

System.out.println(queue.poll());  // 3 (가장 큰 값이 먼저 출력됨)
이미 많고 다양한 큐가 만들어져 있기 때문에
편한 방법과 
편한 클래스가 자바처럼 다양하게 존재하지만,
기본 자료구조를 이해하지 못한다면 활용하기가 어렵다.
때문에 그걸 사용하기 이전에 기본에 대한 이해를 점검하고 사용하도록 하자.
( ctrl + 클릭 을 통해 자바 클래스 내부를 확인 할 수 있다. )

 

반응형
반응형
취업 준비하면서 공부를 하다 개발자로써는 사실 거의 의미 없다고들 하지만,
네트워크 관련 흥미가 생겨 공부하다 겸사겸사 하게 되었습니다.
준비해서 나쁠것도 없고, 시험이 쉬운편이라고 하니 한 번 해보시길 바랍니다.

 

 

네트워크 관리사 2급

  • 네트워크 관리사 2급은 네트워크 관련 업무 수행을 위한 일반적인 운용지식과 구축기술, NOS운영, Packet분석, Monitoring, 인터넷 기술, Protocol 등 기초 이론과 실무능력 검정 기준으로 한다.
  • 2급은 공인 민간 자격으로 국가공인 자격이다.
  • 자격발급기관은 한국정보통신자격협회에서 주관합니다.
  • 1급은 기준이 있으나 2급은 제한없이 응시 할 수 있습니다.
  • 필기 시험시간은 1급 60분 2급 50분입니다.
 

(사)한국정보통신자격협회

개요 및 검정기준 네트워크관리사란 서버를 구축하고 보안 설정, 시스템 최적화 등 네트워크구축 및 이를 효과적으로 관리할 수 있는 인터넷 관련 기술력에 대한 자격이다. 자격명칭 검정기준

www.icqa.or.kr

시험일정

1급은 서울에서만 응시할 수 있고 2회만 존재합니다.

2급은 매년 4회 응시할 수 있고 여러 지역에서 응시 가능합니다.

준비물

  • 신분증, 볼펜
  • 신분증이 없으면 응시가 절대 불가합니다.

가격

2급은 필기은 43,000원, 실기는 78,000원입니다.

 

합격

합격은 모두 100점 만점에 60점 이상입니다.

 

필기 공부법

  • 교재는 사실상 필요없는 수준입니다.
  • 만약 컴퓨터 관련과가 아닌상태여서 이론이 부족하시다면 교재사서 공부하시면 될 것 같습니다.
  • CBT 에서 문제 풀고 틀린 문제 위주로 공부했습니다.
 

최강 자격증 기출문제 전자문제집 CBT

전자문제집, CBT, 컴씨비티, 씨비티, 기사, 산업기사, 기능사, 컴활, 컴퓨터활용능력, 1급, 2급, 워드, 정보처리, 전기, 소방, 기계, 사무자동화, 정보기기, 제과, 제빵, 한국사, 공무원, 수능, 필기,

www.comcbt.com

필기 합격률은 평균 30% 정도지만, 많은 풀이와 개념을 이해한다면 아주 쉬운 시험입니다.
예를 들어 SSH에 대해 물어본다면 SSH가 무엇인지 무슨 포트를 사용하며 무슨 목적으로 사용되는지..

물론 시험을 통과하기만을 위한 공부법도 있지만,
저는 공부하면서 시험보는 만큼 문제에 나온 설명을 통해 유추하여 푸는 과정으로 공부했습니다.
그렇다고 시험 자체 난이도는 매우 쉬운편으로 속했기 때문에 시험 시간은 10분정도였습니다.

모두 합격하시길 바라며 다음에는 실기 합격으로 돌아오겠습니다.
반응형
반응형
이번 글에서는 4949번 문제를 통해 스택을 활용,
괄호의 균형을 맞춰완벽한 문장을 나타내 보자.


 

 

문제 핵심

  • 문자열은 ( ),  [ ] 이 두 소괄호와 대괄호가 짝을 이루어야 한다.
  • 1 : 1 매칭만 가능하다.
  • 공백 이후의 . 과 같은 괄호가 없는 문장도 균형 잡힌 문자열이다.
  • (, [ 이 나온 후에 ), ] 가 나와야 짝이 이루어 진다. 
    • ] [ 은 짝이 아닌 경우 

풀이 과정

먼저 우리가 찾아야 할 것은 괄호들이다.

이는 StringTokenizer를 활용해 볼 예정이다. ( 물론 chatAt()을 사용하면 더 빠르다. )

다음 자료구조 스택에 대한 글과 split과 StringTokenizer비교에 관한 글을 참고하면 좋을 것 같다.

 

 

스택 ( 자료구조 ) - JAVA

오늘은 자료구조의 기본 구조 중 하나인 스택에 대해서 알아보고자 한다.가장 기본적인 구조로 후입선출 ( LIFO, Last In First Out ) 방식을 가진다.접시를 쌓아올린다고 생각하면 된다.스택 ( Stack )후

p-coding.tistory.com

 

 

[ JAVA ] 문자열 자르기 Splite VS StringTokenizer

문자열을 특정 구분자로 분리할 수 있는 StringTokenizer와 Splite을 사용하던 중구체적인 차이점이 무엇인지 궁금하여 조사하게 되었다.메모리에서 장점을 가진다고 하지만 정확히 어떤구조로 작용

p-coding.tistory.com

 

 

1. 괄호 문자 저장

먼저 StringTokenizer를 통해 소괄호, 대괄호를 기준으로 문자를 나눈다.

그렇게 되면 구분자를 저장하는 StringTokenizer의 특성을 활용해 문자를 가져올 수 있다.

true로 설정하면 구분자도 Token에 포함된다.

stringTokenizer = new StringTokenizer(sentence,"([)]",true);

 

2. 괄호 문자 찾아 균형확인하기

1. 구분자에 포함된 토큰 중에 괄호를 찾는다.

2. (, [ 라면 스택에 넣는다

3 - 1. ], ) 라면 스택에서 꺼내 비교한다

3 - 2. 이 때, 동일한 모양의 괄호 즉, )일 때 ( 괄호가 나오지 않는다면 균형이 맞지 않는 문자열로 처리

while(stringTokenizer.hasMoreTokens()) {

    String token = stringTokenizer.nextToken();

    if (token.equals("(") || token.equals("[")) {
        push(token);
    }
    else if (token.equals(")")) {
        if (!pop().equals("(")) {
            isPerfect = false;
            break;
        }
    }
    else if (token.equals("]")) {
        if (!pop().equals("[")) {
            isPerfect = false;
            break;
        }
    }
}

 

 

3. 스택에 남아있는 값 확인

마지막으로 스택에 남아 있는 경우 즉, (() 와 같은 문자열이 들어온다면 ( 이 스택에 남아 균형이 맞지 않는다.

if (!delimStack.isEmpty()) isPerfect = false;

 

스택을 활용하여 푸는 문제로 괄호를 저장하고 저장한 값을 꺼내 올 때,
다양한 경우에 대비하여 반론이 없게 푸는 것이 중요하다.
이번 문제는 빠르게 풀 수도 있지만, charAt함수가 아닌 StringTokenizer를 사용하듯이
다양한 방법으로 풀어보는 것을 추천한다.



전체 코드

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

public class Main {

    private static LinkedList<String> delimStack;

    private static void push(String delim){
        delimStack.addLast(delim);
    }

    private static String pop(){
        return delimStack.isEmpty() ? " " : delimStack.removeLast();
    }


    public static void main(String[] args) throws IOException {
        delimStack = new LinkedList<>();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder stringBuilder = new StringBuilder();

        boolean isPerfect;
        StringTokenizer stringTokenizer;

        while (true) {
            isPerfect = true;
            delimStack.clear();
            String sentence = bufferedReader.readLine();

            if(sentence.equals(".")) break;

            stringTokenizer = new StringTokenizer(sentence,"([)]",true);


            while(stringTokenizer.hasMoreTokens()) {

                String token = stringTokenizer.nextToken();

                if (token.equals("(") || token.equals("[")) {
                    push(token);
                }
                else if (token.equals(")")) {
                    if (!pop().equals("(")) {
                        isPerfect = false;
                        break;
                    }
                }
                else if (token.equals("]")) {
                    if (!pop().equals("[")) {
                        isPerfect = false;
                        break;
                    }
                }
            }

            if (!delimStack.isEmpty()) isPerfect = false;


            stringBuilder.append(isPerfect ? "yes\n" : "no\n");
        }

        System.out.println(stringBuilder);
    }
}
반응형
반응형
인공지능 개발시 Tensorflow를 사용할 때 겪는 어려움이 상당하다.
환경 변수로 인해 머리가 너무 아프고 막상 설치한다고 해도
대부분 Jupyter NoteBook을 통해 개발하는데 에러 메시지가 정확하게 나오지 않는다.
때문에 그 모든 과정을 포스팅하려고 한다.

해당 컴퓨터 사양은 Window11 RTX 3070 환경이나 다른 환경도 할 수 있게끔 설명하도록 하겠습니다.
많은 분들이 힘드실 Cuda 버전에서는 Tensorflow가 윈도우 지원은 2.10.0 까지 하기 때문에
Cuda 12버전은 되지 않는다는 점 미리 말씀드립니다. ( 성공하신 분 있으면 댓글 달아주세요 )

가상환경을 쓰는 이유는 앞 서 말한 이유로 인해 이전 버전을 사용하기 때문에 기존의 Python과 라이브러리 충돌이 일어나지 않게끔 독립적으로 유지하기 위함이다. 때문에 귀찮더라도 모두 설치하기 바랍니다.


1.  GPU 드라이버 설치 ( Tensorflow호환성 체크 )

1 - 1. 전체 적인 호환성 체크

먼저 Cuda Toolkit 과 cuDNN 라이브러리, Tensorflow의 호환성을 체크해야 한다.

( 이는 3070기준이며 각자의 맞게 사용하기 바란다. ) 

 

먼저 내 그래픽 카드가 어떤 Cuda에 맞게 사용되는지 알아야 한다. 다음 사이트에서 두 가지 표를 보고 확인 가능하다.

 

CUDA - Wikipedia

From Wikipedia, the free encyclopedia Parallel computing platform and programming model In computing, CUDA (Compute Unified Device Architecture) is a proprietary[2] parallel computing platform and application programming interface (API) that allows softwar

en.wikipedia.org

 

내 그래픽 카드를 검색하고 맨 앞에 숫자를 체크한다.

 

그리고 다음 표를 보며 내 그래픽 카드가 사용 가능한 Cuda 를 체크한다.

8.6이 포함된 모든 Cuda 11.1 ~ 12.8 최신버전까지 모두 사용 가능하다.

 

Tensorflow가 버전에 따라 지원하는 Cuda 버전들을 확인한다.

 

Windows의 소스에서 빌드,Windows의 소스에서 빌드  |  TensorFlow

이 페이지는 Cloud Translation API를 통해 번역되었습니다. Windows의 소스에서 빌드,Windows의 소스에서 빌드 컬렉션을 사용해 정리하기 내 환경설정을 기준으로 콘텐츠를 저장하고 분류하세요. 소스에

www.tensorflow.org

 

다음은 Tensorflow에 대한 설치 가이드로 설치해야하는 버전이 나와 있다. 

다음과 같이 Window에서의 GPU 지원은 2.10 이하의 버전에서만 사용 가능하다.

 

cuDNN과 쿠다(Cuda)라고 적힌 부분에 11.2라고 적혀있지만

사실상 11.x버전을 지원하는 경우이며 11.0이나 10은 11.x, 10.x를 지원하지 않는 듯 하다.

때문에 지원하는 가장 최신 버전 선택했다.

 

1 - 2. 그래픽 카드 드라이버 환경 설치

참고할 점

여기서 드라이버를 먼저 설치 했더라면 아마 CUDA가 버전에 맞게 설치 되어있는 경우들이 있다.

최신 버전으로 업데이트 했더라면 12.8로 나올 것이다. 환경 변수를 바꾸는 방법도 있지만, 삭제하고 설치하는 것이 맘이 편하다.

제어판에 있는 다음 항목들을 모두 삭제하고 진행한다면 편할 것이다. 

Cuda Toolkit다운시에 모두 다운로드 된다.

 

Cuda Toolkit  설치

다음 사이트에서 Cuda 11.x 버전을 다운 받아 준다. ( 각자 맞게 다운로드 하길 바란다. ) 

 

CUDA Toolkit Archive

Previous releases of the CUDA Toolkit, GPU Computing SDK, documentation and developer drivers can be found using the links below. Please select the release you want from the list below, and be sure to check www.nvidia.com/drivers for more recent production

developer.nvidia.com

Cuda 라이브러리 다운

그리고 아까 확인했던 RTX 3070 기준 v8.6.0을 Cuda 11.x 버전에 맞게 다운로드 받고 압축을 풀어 준다.

 

라이브러리 복사

그러면 다음과 같은 경로에 Toolkit이 버전에 맞게 설치 되어있다.

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.8

 

다운받았던 라이브러리 파일을 복사해서 넣어준다.

 

1 - 3. 환경 변수 설정

다음과 같이 환경 변수 설정에서 CUDA_PATH는 버전에 맞게 설치되어 있다. 

이제 시스템 변수의 path에서 새로 만들기를 통해 다음 세 줄을 하나씩 추가한다.

( 찾아보면 bin은 있을 것이다. )

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.8\bin
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.8\include
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.8\lib

1 - 4. 설치 확인

다음 명령어를 통해 Cuda Version이 맞게 설치된 것을 알 수 있다.

> nvidia-smi

 

환경 변수에 인식된 Cuda 버전도 확인할 수 있다.

> nvcc --version

처음 말했던 삭제하고 설치하라는 이유가 간 혹 nvidia-smi 명령어에서는 12.8로 확인되고, nvcc --version에서는 11.8로 확인되는 경우가 있다. 드라이버가 함께 설치되어 인식하는 버전은 Cuda 12.8이고 환경 변수로 컴퓨터에서 인식하는 버전은 11.8인 경우이다.  



2. 아나콘다 설치

 

Anaconda | Built to Advance Open Source AI

Anaconda simplifies, safeguards, and accelerates open-source AI with a trusted platform, enabling secure scaling, real-time insights, and community collaboration.

www.anaconda.com

 

 

2 - 1. 다음과 같이 Free Download를 통해 사이트를 접속하고 이메일을 Submit하면 이메일로 다운로드 링크를 보내준다.

 

이후에 설치 창에서 Recommnad 추천하는 경우를 선택하고 설치해주는 것이 좋다.

 

2 - 2. Anaconda Prompt 실행 후 가상환경 생성

 

가상환경을 생성하기 위해서는 아까 봤던 tensorflow 표를 통해 python version을 설정하여 생성하면 된다.

 

 

일단 가상 환경에 설정할 Python은 3.7에서 3.10으로 나와 있지만,

3.8 ~ 3.9가 안정적이다라고 많은 평가가 있으며,

3.10 버전은 이후 세팅을 위한 과정에서 어려움을 겪을 수 있으니 3.8 ~ 3.9를 추천한다.

 

가상환경 생성

먼저 가상환경을 생성해 준다.

> conda create --name (사용할 가상환경 이름) python=3.9

 

생성된 가상환경을 활성화 준다. 다음과 같이 앞이 설정한 이름으로 바뀌는 것을 알 수 있다.

> conda activate ( 사용했던 가상환경 이름 )

 

라이브러리 설치 ( tensorflow )

최신 버전의 conda는 더이상 tensorflow-gpu=2.10.0의 설치 지원을 하지 않기 때문에 pip 설치로 대체한다. 

둘다 설치한다. 이후 버전은 통합하였지만 따로따로 사용해야 한다.

> pip install tensorflow-gpu==2.10.0
> pip install tensorflow==2.10.0

라이브러리 설치 ( numpy )

이렇게 설치 한다면 tensorflow에 필요한 라이브러리들이 자동적으로 설치된다.

이때 numpy가 최신버전으로 설치 되기 때문에 다운그레이드를 해야한다. 이 경우도 conda가 지원하지 않아 pip로 진행

1.23 버전이 다른 라이브러리 버전과 호환된다.

> pip install numpy==1.23

 

GPU 인식 확인

꼭 다음 명령어를 conda가상환경이 활성화 된 상태에서 하기 바란다.

jupyter Notebook or Visual Code에서는 인식하는 과정이 느리고 오류가 제대로 나오지 않기 때문에 확인이 어렵다

다음과 같은 코드를 입력했을 때 되지않는다 하더라도 에러 내용이 제대로 나오기 때문에 대처가 가능하다.

> python -c "import tensorflow as tf; print('TensorFlow Version:', tf.__version__); print('GPU 사용 가능 여부:', tf.config.list_physical_devices('GPU'))"

 

위와 같이 GPU 인식이 가능하다.

 

 

추가 에러 상황 - zlibwapi.dll error

다음 오류는 Visual code에서 Jupyter Notebook으로 사용했을 때 생기는 오류이다. ( 그 외에도 생길 수 있다. )

 

Could not load library cudnn_cnn_infer64_8.dll. Error code 193

the zlibwapi files are there, the paths are there. Still getting the same error. However the links you provided for downloading the 64 bit versions are NOT secure. It has been more than 2 months with this and it takes you 2 weeks to provide vage answers th

forums.developer.nvidia.com

다음 사이트를 통해 사양에 맞는 비트를 선택하고 설치한 파일 내에 zlibwapi.dll만 복사해서 다음 경로에 붙여넣기 하면된다.

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.8\bin

 

계속 CPU 기기만 인식해서 많은 블로그와 공식 가이드 문서들을 찾아보았지만 호환성에 대해서 정확한 내용이 거의 없었다. 때문에 Cuda버전들을 삭제하고 다시 설치 하는 수 많은 과정을 통해 이 글을 작성하게 되었다.
다른 분들께서는 이 글을 통해 인식이 되지 않는 문제 없이 한 번에 이루어지는 쾌거를 느끼시길 바란다.

추가적인 오류가 있다면 댓글로 남겨주시면 감사하겠습니다.
반응형
반응형
이번 글에서는 백준 28278번 문제를 통해
스택(자료구조)를 구현하고 활용해 보자.

문제 핵심

  • N : 명령의 수 ( 1 <= N <= 1,000,000 )
  • 명령 1 ~ 5 까지 주어진다.
  • 1. Push
  • 2. Pop
  • 3. Size
  • 4. IsEmpty
  • 5. Peek
  • 명령은 하나씩 주어진다.

풀이 과정

다음 문제는 스택을 구현하고 처리하는 과정이라고 할 수 있다.

 

1. 함수 구현하기

1 ~ 5의 명령어와 같이 스택에 필요한 함수들을 구현하자.

	private static int isEmpty() {
        if (list.isEmpty()) {
            return 1;
        }
        return 0;
    }

    private static Integer peek() {
        if (list.isEmpty()) {
            return -1;
        }
        return list.getFirst();
    }

    private static Integer pop() {
        if (list.isEmpty()) {
            return -1;
        }
        return list.removeFirst();
    }

    private static void push(int num) {
        list.addFirst(num);
    }

 

문제에 맞게 명령어들을 변형하여 함수를 구현하였다.

2. 구현한 함수 활용하기 ( Main 작성 )

  • 문제를 다음과 같이 풀었지만, 1 ~ 5의 단순한 숫자나 문자열로 처리할 경우 Switch문이 더 적합하며 범위 계산이나 null 값 계산 등이 아니라면 Switch문으로 처리하는 것이 좋아 보인다.
  • List 는 JAVA의 LinkedList<> 클래스를 활용하였다.
    • ArrayList or List를 활용해서 사용할 수 있기도 하지만, 미리 만들어두는 구조보다는 문제제목과 같은 자료구조에 맞춰서 사용하였다.
private static final LinkedList<Integer> list = new LinkedList<>();

    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder stringBuilder = new StringBuilder();

        int num = Integer.parseInt(bufferedReader.readLine());
        StringTokenizer stringTokenizer;

        String command;

        for (int i = 0; i < num; i++) {
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());

            command = stringTokenizer.nextToken();

            if (command.equals("1")) {
                push(Integer.parseInt(stringTokenizer.nextToken()));
            } else if (command.equals("2")) {
                stringBuilder.append(pop())
                        .append("\n");
            } else if (command.equals("3")) {
                stringBuilder.append(list.size())
                        .append("\n");
            } else if (command.equals("4")) {
                stringBuilder.append(isEmpty())
                        .append("\n");
            } else if (command.equals("5")) {
                stringBuilder.append(peek())
                        .append("\n");
            }

        }
        System.out.println(stringBuilder);
    }

 

 

스택 ( 자료구조 ) - JAVA

오늘은 자료구조의 기본 구조 중 하나인 스택에 대해서 알아보고자 한다.가장 기본적인 구조로 후입선출 ( LIFO, Last In First Out ) 방식을 가진다.접시를 쌓아올린다고 생각하면 된다.스택 ( Stack )후

p-coding.tistory.com

 

백준에서는 여러 프로그래밍 언어 중 Java가 비교적 느린 편이기 때문에, 많은 사람이 속도 최적화에 집중하거나 단순히 문제를 해결하는 데만 초점을 맞춰 코드를 작성하는 경우가 많다. (물론 브론즈 ~ 실버 수준의 문제에서는 속도 차이가 크게 중요하지 않다.)

하지만 이러한 문제의 핵심은 스택을 직접 구현하고 이해하는 것에 있다.


예를 들어, 명령어가 4일 때 list.isEmpty() ? 1 : 0을 사용하면 간편하게 해결할 수 있다.
그러나 이는 LinkedList 클래스의 isEmpty() 메서드를 활용한 것이지,
우리가 구현해야 할 스택의 isEmpty()가 아니다.

비록 같은 기능을 수행하지만, 개념적으로 다른 의미를 가진다.


즉,
문제를 통과하는 것에만 집중하기보다는, 정확한 개념을 이해하고 접근하는 것이 더 중요하다.


전체 코드

물론 다음 코드도 완벽하지는 않다.

package org.example;

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

public class Main {

    private static final LinkedList<Integer> list = new LinkedList<>();

    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder stringBuilder = new StringBuilder();

        int num = Integer.parseInt(bufferedReader.readLine());
        StringTokenizer stringTokenizer;

        String command;

        for (int i = 0; i < num; i++) {
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());

            command = stringTokenizer.nextToken();

            if (command.equals("1")) {
                push(Integer.parseInt(stringTokenizer.nextToken()));
            } else if (command.equals("2")) {
                stringBuilder.append(pop())
                        .append("\n");
            } else if (command.equals("3")) {
                stringBuilder.append(list.size())
                        .append("\n");
            } else if (command.equals("4")) {
                stringBuilder.append(isEmpty())
                        .append("\n");
            } else if (command.equals("5")) {
                stringBuilder.append(peek())
                        .append("\n");
            }

        }
        System.out.println(stringBuilder);
    }

    private static int isEmpty() {
        if (list.isEmpty()) {
            return 1;
        }
        return 0;
    }

    private static Integer peek() {
        if (list.isEmpty()) {
            return -1;
        }
        return list.getFirst();
    }

    private static Integer pop() {
        if (list.isEmpty()) {
            return -1;
        }
        return list.removeFirst();
    }

    private static void push(int num) {
        list.addFirst(num);
    }
}
반응형
반응형
오늘은 자료구조의 기본 구조 중 하나인 스택에 대해서 알아보고자 한다.
가장 기본적인 구조로 후입선출 ( LIFO, Last In First Out ) 방식을 가진다.
접시를 쌓아올린다고 생각하면 된다.


스택 ( Stack )

  • 후입 선출 ( LIFO, Last In First Out )
  • 한쪽 끝에서만 데이터 삽입( push )과 삭제( pop )가 이루어짐
  • 재귀 호출, 백트래킹, 수식 계산 등 다양한 알고리즘에서 활용됨
    private int[] stack;
    private int top;

    public TestStack(int size){
        stack = new int[size];
        top = -1;
    }

스택의 기본 연산

1. push(value): 데이터 삽입

  • 스택의 맨 위(top)에 데이터를 추가하는 연산
    public void push(int value){
        if(top == stack.length -1 ) {
            System.out.println("스택이 가득 찼습니다.");
            return;
        }

        stack[++top] = value;
    }

2. pop(): 데이터 제거

  • 스택의 맨 위(top)에 있는 데이터를 제거하고 반환하는 연산
  • 만약 스택이 비어 있다면 언더플로우(Underflow, 데이터 부족 에러) 발생
    public int pop() {
        if (isEmpty()){
            System.out.println("스택이 비어 있습니다.");
            return -1;
        }
        return stack[top--];
    }

3. peek() (또는 top()): 최상단 데이터 확인

  • 스택의 맨 위(top)에 있는 데이터를 반환하지만, 제거하지 않음
    public int peek() {
        if (isEmpty()) {
            System.out.println("스택이 비어 있습니다.");
            return -1;
        }
        return stack[top];
    }

4. isEmpty(): 스택이 비어 있는지 확인

  • 스택이 비어 있으면 true, 아니면 false 반환
    public boolean isEmpty() {
        return top == -1;
    }

 

로직 예시)

왼쪽 위부터 오른쪽으로 진행된다

 

1. 빈 스택이다

2. push를 통해 값 ( 1 ) 을 넣었다. 이 때 top은 1을 가리킨다

3. push를 통해 값 ( 2 ) 을 넣었다. 이 때 top은 2를 가리킨다.

4. peek를 통해 값 ( 2 ) 을 받았다.

5. pop을 통해 값 ( 2 ) 를 꺼냈다. 이 때 top은 1을 가리킨다.

6. pop을 통해 값 ( 1 ) 를 꺼냈다. 이 때 top은 아무것도 가리키지 않는다. ( -1 상태 )

 

배열을 활용하여 스택에 대해 설명했지만, 
List 클래스 ( 하위 클래스 포함 ArrayList 등 ) 으로도 구현 가능하다.
 개념을 이해하고 상황에 맞게 사용하면 된다.

전체 구현 코드

package org.example;


public class TestStack {
    private int[] stack;
    private int top;

    public TestStack(int size){
        stack = new int[size];
        top = -1;
    }

    public void push(int value){
        if(top == stack.length -1 ) {
            System.out.println("스택이 가득 찼습니다.");
            return;
        }

        stack[++top] = value;
    }

    public int pop() {
        if (isEmpty()){
            System.out.println("스택이 비어 있습니다.");
            return -1;
        }
        return stack[top--];
    }

    public int peek() {
        if (isEmpty()) {
            System.out.println("스택이 비어 있습니다.");
            return -1;
        }
        return stack[top];
    }

    public boolean isEmpty() {
        return top == -1;
    }
}
반응형
반응형
Integer와 Int 같은 정수형을 나타내는 자료형으로 볼 수 있다.
하지만 이는 객체와 기본형으로 다르게 같지만서도 다르다.
이번에는 그 차이를 알아보자.

1. primitive type ( 기본형 )

  • 값 자체를 스택 메모리에 직접 저장하는 Primitive 즉, 원시적인 자료형이다. 
  • 별도의 정의가 필요없이 사용할 수 있으며 고정된 크기를 차지한다.
  • 메소드를 사용할 수 없으며 값을 직접 저장하기 때문에 null 을 저장할 수 없습니다.
자료형 데이터 형태 메모리 크기 표현 가능 범위
boolean 논리형 1byte true / false
char 문자형 2byte 유니코드
byte 정수형 1byte -128 ~ 127
short 2byte -32,768 ~ 32,767
int 4byte -2,147,483,648
~ 2,147,483,647
long 8byte -9,223,372,036,854,775,808
~ 9,223,372,036,854,775,807
float 실수형 4byte ±3.40282347E+38
(7자리 유효숫자)
double 1byte ±1.79769313486231570E+308
(15자리 유효숫자)

 

2. Wrapper Class ( 객체형 )

  • 값은 힙 메모리에 객체에 저장되고, 스택 메모리는 그 객체를 가리키는 주소값을 저장한다.
  • 참조형 데이터이기 때문에 추가적인 메모리가 소모된다.
  • 기본 상태는 null로 초기화 된다.
Wrapper Class 자료형
Boolean boolean
Character char
Byte byte
Short short
Integer int
Long long
Float float
Double double

 

3. 메모리 구조 예시 ( 정수 )

다음과 같은 코드를 적용할 때 그림과 같이 메모리에 할당된다.

int num = 10;
Integer num = Integer.valueOf(num);

 


차이점 요약

특징 Primitive Type Wrapper Class
저장 위치 스택 힙 + 스택
메모리 사용량 고정적 더 많은 메모리 필요
속도 비교적 빠름 비교적 느림
null 허용 불가능 가능
객체 메서드, 컬렉션 사용 여부 불가능 가능

 

 

Wrapper Class는 제네릭 형태로 자주 사용되며,
특히 List<Integer> 와 같은 컬렉션 프레임워크에서 흔히 활용된다.
간단한 코드에서는 당연하게 사용하지만,
방대한 코드 작성 시에는 메모리나 성능, 기능적 요소를 고려해야 한다.
이러한 상황에 닥쳤을 때 비로소 이유를 고민하기보다, 미리 원리를 이해하고 사용하면 더 효율적일 것이다.

 

반응형
반응형
이번 글에서는 백준 17103번 문제를 통해 소수 찾기 알고리즘인 에라토스테네스의 체를 활용,
이를 통해 소수를 찾고 짝수를 소수의 합으로 나타내보자.

문제 핵심

  • N : 짝수
    • 2 < N <= 1,000,000
  • 두 개의 소수의 합이다.
  • 순서만 다른 것은 같은 파티션이다.

풀이 과정

다음 문제는 소수를 먼저 찾아서 합을 구하면된다.

즉, 에라토스테네스의 체를 활용 소수를 효율적으로 구할 수 있다.

 

소수 찾기 ( 에라토스테네스의 체 ) - JAVA

에라토스테네스의 체 는 소수를 찾는 쉽고 빠르게 찾을 수 있는 방법이다.( 고대 그리수 수학자 에라토스테네스가 발견 ) 알고리즘다음과 같은 알고리즘을 따른다.0 ~ 50 까지의 수를 찾고자 할

p-coding.tistory.com

 

1. 소수 찾기

먼저 소수를 분별한다. ( max값을 찾아서 할 수 있지만 최대값 1,000,000인 점을 감안 미리 1,000,000까지 소수를 찾는다. )

    private static void sieveOfEratosthenes(int num) {
        isPrime = new boolean[num + 1];

        for (int i = 2; i <= num; i++) {
            isPrime[i] = true;
        }

        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (!isPrime[i]) continue;
            for (int j = i + i; j <= num; j += i) {
                isPrime[j] = false;
            }
        }
    }

 

2. 골드 바흐 파티션 구성

1. 양쪽에서 숫자를 줄여가며 소수 체크를 한다. ( 이 때 양쪽에서 검사하기 때문에 절반만 사용한다. )

2. 둘 다 소수일 때 count를 증가시킨다.

3. count를 반환한다.

    private static int findGBPartitions(int evenNum) {
        if(evenNum < 4 || evenNum % 2 != 0) {
            throw new IllegalArgumentException(" 4이상의 짝수만 입력 가능합니다. ");
        }

        int count = 0;

        for (int i = 2; i <= evenNum / 2; i++) {
            if(isPrime[i] && isPrime[evenNum - i]) {
                count++;
            }
        }
        return count;
    }

 

 

 


미리 찾아둔 소수를 활용하고 반복문을 효율적으로 사용하면 비교적 쉬운 문제이다.
1,000,000 이하의 소수는 미리 생성해도 처리 가능하지만,
숫자가 매우 커질 경우에는 입력값의 최대값을 기준으로 소수를 구하는 것이 더 효율적이다.

이번 문제는 두 수의 합이 N이 되어야 하므로, 다음과 같은 방식이 적합하다.다만, 이전에 선택 정렬 문제에서 사용한 인덱스를 활용한 방식으로 데이터를 저장하는 방법도 고려할 수 있다.

 

전체 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    private static boolean[] isPrime;

    public static void main(String[] args) throws IOException {
        solve();
    }

    private static void solve() throws IOException {

        sieveOfEratosthenes(1000000);

        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder stringBuilder = new StringBuilder();
        int N = Integer.parseInt(bufferedReader.readLine());

        for(int i = 0;i<N;i++){
            int num = Integer.parseInt(bufferedReader.readLine());
            String result = String.valueOf(findGBPartitions(num));
            stringBuilder.append(result)
                    .append("\n");
        }

        System.out.println(stringBuilder);
    }


    private static void sieveOfEratosthenes(int num) {
        isPrime = new boolean[num + 1];

        for (int i = 2; i <= num; i++) {
            isPrime[i] = true;
        }

        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (!isPrime[i]) continue;
            for (int j = i + i; j <= num; j += i) {
                isPrime[j] = false;
            }
        }
    }

    private static int findGBPartitions(int evenNum) {
        if(evenNum < 4 || evenNum % 2 != 0) {
            throw new IllegalArgumentException(" 4이상의 짝수만 입력 가능합니다. ");
        }

        int count = 0;

        for (int i = 2; i <= evenNum / 2; i++) {
            if(isPrime[i] && isPrime[evenNum - i]) {
                count++;
            }
        }
        return count;
    }
}

 

반응형
반응형

 

maven, Spring, Junit 등 IntelliJ를 사용하면 편하다.
하지만 대부분 VS Code를 대부분 처음에 사용한다고 보는데
그 때 항상 써왔던 코드 정리를 찾아 보고 한다.

키보드를 하나만 더 추가해 4개만 누르면 된다
Ctrl + Alt + Shift + L
이후 다음과 같은 창이 뜬다

 

그럼 다음과 같이 정리된다.


코드 정리 전

이해를 돕기 위해 일부러 다시 고쳤습니다.

코드 정리 후

띄어쓰기가 잘 되어 가독성이 올라갔습니다. 줄 정리도 어느정도 해주네요.

 

개발시 가독성은 매우 중요한 요소 중 하나이다.
코드 작성시 정리는 기본적인 요소이므로 해야한다. 
반응형
반응형
이번 글에서는 백준 28116번 문제를 통해 선택 정렬 알고리즘을 활용하고,
이를 통해 성능 최적화 방안을 탐구해보려 한다.
선택 정렬의 기본 개념을 바탕으로 문제 해결 과정과 효율성을 높이는 방법을 단계별로 살펴보자.

 

문제 핵심

  • 이 배열은 N까지의 정수가 정확히 한 번씩 등장한다. 즉 중간에 빠진 정수나 중복된 수가 존재하지 않는다.
  • 선택 정렬 알고리즘을 사용하여 주어진 배열을 정렬한다
  • 이 과정에서 교환이 이루어질 때 이동한 거리를 각각 저장한다.
  • N : 배열의 길이

풀이 과정

이전의 선택정렬의 문제와 같이 2중 반복을 통해 풀었다. 하지만 이번의 N의 최대길이가 다르다.

지난 번 23881번 문제에서는 N이 10,000 즉, O(N^2)의 시간 복잡도를 가지더라도 10,000,000의 연산을 한다.

하지만 이번 문제는 N이 500,000으로 어마 어마한 숫자다. 특히 자바로 문제는 푸는 나에게는 더욱 더 좋지 않은 상황이다. 

    private static void solve() {

        int minIndex;
        for (int i = 0; i < arr.length - 1; i++) {
            minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                 if(arr[j] < arr[minIndex]) {
                     minIndex = j;
                 }
            }

            if(minIndex != i) {
                int temp = arr[minIndex];
                arr[minIndex] = arr[i];
                arr[i] = temp;

                int distance = minIndex - i;
                arrSwapCount[arr[minIndex] - 1] += distance;
                arrSwapCount[arr[i] - 1] += distance;
            }
        }
    }

 

[ 문제 ] 시간 초과

그렇다면 위 코드는 아무리 줄여나가도 2중 반복이라는 한계로 시간초과의 문제를 해결할 수 없다. 어떻게 해야 할까?

한 개의 반복문에 모두 녹여내야 한다. 코드 몇 줄 최적화 시킨다고 해서 나아질 문제가 아닌 것이다. 

 

문제 해결

문제를 고민하던 중, 제한 조건에 있던 "각 정수는 N까지 정확히 한 번씩 등장한다"는 점이 눈에 들어왔다. 이 조건을 활용하면 인덱스를 이용한 접근이 가능하다고 판단했다. 이를 바탕으로, "위치를 저장하는 배열과 기존의 정렬 대상 배열을 비교하며 값을 처리할 수 있을 것"이라는 아이디어를 떠올렸다. 그 후, 이 규칙을 기반으로 점차 로직을 구체화하며 코드를 작성했다.

 

과정은 다음과 같다. ( 백준 두 번째 예시값 )

 

1. 초기화 단계

먼저 주어진 배열이 다음과 같이 저장되고, 값의 위치를 저장하는 배열로 두개를 선언한다.

 

0부터 시작하는 특성으로 num - 1을 선언하였으나

헷갈리지 않게 사용하려면 배열을 N + 1 만큼 사용하고 0 인덱스를 제외하여 사용하면 된다.

아래 그림에 실제 가르키는 값은 다음과 같다. 제외하고 봐도 무방하다.

    private static int[] arr;
    private static int[] numLocations;
        for (int i = 0; i < N; i++) {
            int num = Integer.parseInt(stringTokenizer.nextToken());
            arr[i] = num - 1;
            numLocations[num - 1] = i;
        }

 

그림과 같이 저장된다.

 

2. 알고리즘 단계

위 그림을 보면 감이 올지도 모른다.

한 개의 반복문에서 index를 활용하여 매치 시키고, 위치에 있어야 할 값과 맞지 않는다면

해당 위치에 있는 값원래 있어야 하는(순서에 맞는) 값을 찾고 거리값을 구한다. 

    private static void solve() {
        for (int i = 0; i < numLocations.length; i++) {
            if (arr[i] != i) {
                int distance = numLocations[numLocations[arr[i]]] - i;

                moveCounts[i] += distance;
                moveCounts[arr[i]] += distance;

                arr[numLocations[i]] = arr[i];
                numLocations[arr[i]] = numLocations[i];
            }
        }
    }

i = 0 일때

0 = 0 ( 실제로는 1 = 1 ) 이므로 위치에 맞게 존재한다.

i = 1 일때 ( num - 1 인 것을 감안해야 한다 )

위 그림과 같이 i = 1 ( 두 번째 위치) 에 1 (2) 이 있어야 한다.

그렇다면 numLocation[1] 을 통해 원래 있어야 하는 값의 위치를 찾는다.

왼쪽부터 정렬하며 오기 때문에 i값은 항상 작다. 때문에 numLocation[i] - i를 통해 거리를 계산 할 수 있다.

또한, 값의 교환이 할 필요는 없고, i 값에 해당하는 상태는 이제 필요없기 때문에 이 후 계산할 곳에만 값을 넣어준다.

이 후 distance의 값을  moveCount 배열에 더해주면 정수마다 이동한 거리 값이 계산된다.

 

나머지도 위를 통해 문제를 해결할 수 있다.

 

선택 정렬이라고 해서 무조건 2중 반복문을 사용하는게 아닌
그 틀은 그대로 유지하며 다르게 풀어나갈 수 있다는 것
활용하는 것이 가장 중요하다.

전체 코드

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

public class Main {
    private static int[] arr;
    private static int[] numLocations;
    private static int[] moveCounts;

    public static void main(String[] args) throws IOException {
        prepre();
        solve();
        Arrays.stream(moveCounts).forEach(num -> System.out.print(num + " "));
    }

    private static void prepre() throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stringTokenizer = new StringTokenizer(bufferedReader.readLine());

        int N = Integer.parseInt(stringTokenizer.nextToken());
        arr = new int[N];
        numLocations = new int[N];
        moveCounts = new int[N];
        stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        for (int i = 0; i < N; i++) {
            int num = Integer.parseInt(stringTokenizer.nextToken());
            arr[i] = num - 1;
            numLocations[num - 1] = i;
        }
    }

    private static void solve() {
        for (int i = 0; i < numLocations.length; i++) {
            if (arr[i] != i) {
                int distance = numLocations[i] - i;

                moveCounts[i] += distance;
                moveCounts[arr[i]] += distance;

                arr[numLocations[i]] = arr[i];
                numLocations[arr[i]] = numLocations[i];
            }
        }
    }
}
반응형

+ Recent posts