devAndroid

[CS] 컴퓨터 구조 - 명령어

wbnh09 — Wed, 2 Oct 2024 19:30:25 +0900

개발자가 작성한 소스코드에서 명령어로

컴퓨터는 Java나 C/C++, Python, JavaScript 등의 언어로 작성된 소스코드를 바로 이해해서 실행하는 것이 아니다.

컴퓨터는 데이터를 재료삼아 명령어를 이해한다. 소스코드는 실행되기 전에 (명령어+데이터)로 변환되어 실행된다.

소스코드: 사람(개발자)가 이해하기 편한 언어 -> 고급 언어
명령어 & 데이터: 컴퓨터가 이해하기 편한 언어 -> 저급 언어

즉, 고급 언어로 작성된 소스코드는 내부적으로 저급언어로 구성된 명령어와 데이터로 변환된다.

저급 언어의 두 종류

기계어(컴퓨터가 직접 이해하는 언어)

기계어 예시

어셈블리어

어셈블리어 예시

C/C++, Java로 작성한 동일한 코드를 기계어나 어셈블리어로 변환했을 때 CPU의 종류나, 컴파일러 종류에 따라 다르게 변환될 수 있다.

고급 언어에서 저급 언어로 변환되는 대표적인 방식

컴파일
인터프리트

(모든 언어가 위와 같은 방식으로 변환되는 것은 아님)

컴파일(대표적인 언어: C/C++, Rust)

컴파일러

소스 코드 전체가 컴파일러에 의해 검사되고, 목적 코드(object code)로 변환.

컴파일러의 종류: gcc, clang, Visual Studio 등..

인터프리트(대표적인 언어: Python, JavaScript)

인터프리터에 의해서 소스코드 한 줄씩 검사되고, 목적코드(object code)로 변환

컴파일 방식과 인터프리트 방식의 차이

소스코드가 컴파일이 된 상태라면 컴파일 방식이 빠르다. 한줄 한줄 인터프리터에 의해서 검사하는 것보다 한번 쭉 검사해서 기계어로 바꾼다면 실행 시 컴퓨터가 직접적으로 이해할 수 있기에 더 빠를 수 있다.

인터프리터는 소스코드를 한 줄씩 검사하고 실행하기 때문에 n번째 줄에 오류가 있다면 n-1번째 줄까지는 정상적으로 실행이 된다.

하지만 컴파일러는 n번째 줄에 오류가 있다면 처음부터 실행이 안되고, '컴파일 에러'가 발생한다.

컴파일 방식과 인터프리트 방식은 소스코드가 저급 언어로 변환되는 대표적인 방식일 뿐 딱 구분되는 개념은 아니다.
컴파일 언어의 특성과 인터프리트 언어의 특성을 모두 갖춘 언어도 있다.(ex. Java 등..)

명령어의 구조

프로그램을 이루는 두 정보(0과 1로 이루어진 정보)는 두가지로 구성되어 있다.

명령어: 컴퓨터를 동작시키는 실질적인 정보
데이터: 명령어의 대상

명령어의 구성

무엇을 대상(명령의 대상)으로 무엇을 수행(명령의 동작)해라
오퍼랜드(Operand, 피연산자): 명령어를 수행할 대상
- 대상(데이터)이 직접 명시되기도 하고, 대상의 위치(레지스터 이름, 혹은 메모리 주소)가 명시되기도 한다.
- 레지스터: CPU에 있는 작은 임시저장 장치
연산코드(Op-code): 오퍼랜드로 수행할 동작

즉, 오퍼랜드로 연산코드를 수행해라.

명령의 동작	명령의 대상	명령의 대상
더해라	100과	120을
빼라	메모리 32번지 안의 값과	메모리 33번지 안의 값을
저장해라	무엇을	메모리 128번지에
출력해라	무엇을	모니터에

오퍼랜드가 없는 경우(0-주소 명령어)

연산코드(Op-code)

오퍼랜드가 1개인 경우(1-주소 명령어)

연산코드(Op-code)	피연산자(Operand)

오퍼랜드가 2개인 경우(2-주소 명령어)

연산코드(Op-code)	피연산자(Operand)	피연산자(Operand)

오퍼랜드가 3개인 경우(3-주소 명령어)

연산코드(Op-code)	피연산자(Operand)	피연산자(Operand)	피연산자(Operand)

Operand(피연산자)의 갯수는 유동적일 수 있다.

같은 코드라고 해도 Operand의 갯수에 따라 실행되는 명령어의 갯수가 달라질 수 있다

ex1) 2-주소 명령어로 "X = (A + B) * C" 계산하기

R1 <- M(A): 메모리(M)의 A번지 값을 연산을 진행할 레지스터 R1으로 옯긴다.
R1 <- R1 + M(B): 메모리(M)의 B번지 값을 R1 값에 더하고, 더한 값은 R1에 저장한다.
R1 <- R1 * M(C): 메모리(M)의 C번지 값을 R1 값에 곱하고, 곱한 값은 R1에 저장한다.
M(X) <- R1: 계산이 끝난 R1의 값을 메모리(M)의 X번지로 옮긴다.

옮겨라	A를	R1으로
더해라	B를	R1과
곱해라	C를	R1과
옯겨라	R1을	X로

ex2) 3-주소 명령어로 "X = (A + B) * C" 계산하기

R1 <- M(A) + M(B): 메모리(M)의 A번지, B번지의 값을 더해 레지스터 R1에 저장한다.
M(X) <- R1 * M(C): 메모리의 C번지 값을 R1과 곱해 메모리 X번지에 저장한다.

더해라	결과 R1에 저장	A	B
곱해라	결과 X에 저장	R1	C

이처럼 명령어에서 사용되는 Operand가 몇개 있는지에 따라서, CPU가 얼마나 복잡한 명령어를 지원하는지에 따라서 명령어의 갯수가 달라질 수 있다.

연산코드

연산코드의 종류는 CPU마다 다를 수 있다. CPU의 종류와 관계없이 대표적으로, 공통적으로 사용되는 연산코드의 종류는 정해져 있다.

데이터 전송에 관여하는 Op-code

연산코드	설명
MOVE	데이터를 옮겨라(레스터에서 레지스터로 ~)
STORE	메모리에 저장해라
LOAD(FETCH)	메모리에서 가져와라(CPU내부의 레지스터로 ~)
PUSH	스택 최상단에 데이터를 저장해라
POP	스택 최상단의 데이터를 가져와라

산술/논리 연산에 관여하는 Op-code

연산코드	설명
ADD / SUBTRACT / MULTIPLY / DIVIDE	덧셈 / 뺄셈 / 곱셈 / 나눗셈을 수행해라
INCREMENT / DECREMENT	1 증가 / 감소 시켜라
ADD / OR / NOT	AND / OR / NOT 연산을 수행해라
COMPARE	두 숫자 또는 TRUE / FALSE 값을 비교해라

제어흐름 변경에 관여하는 Op-code

연산코드	설명
JUMP	특정 주소로 실행 순서를 옮겨라(ex. JUMP 메모리 주소)
CONDITIONAL JUMP	조건에 부합할 경우 특정 주소로 실행 순서를 옮겨라
HALT	프로그램 실행을 멈춰라
CALL	되돌아올 주소를 저장한 채 특정 주소로 실행 순서를 옯겨라(함수호출, 반환 시 사용됨)
RETURN	CALL 호출 시 지정했던 주소로 돌아가라(함수호출, 반환 시 사용됨)

입출력 제어에 관여하는 Op-code

연산코드	설명
READ(INPUT)	특정 입출력 장치로부터 데이터를 읽어라
WRITE(OUTPUT)	특정 입출력 장치로 데이터를 써라
START IO	입출력 장치를 시작해라
TEST IO	입출력 장치의 상태를 확인해라

주소 지정

주소 지정이란 명령어의 연산코드의 대상이 되는 데이터를 찾아가는 방법.

주소 지정은 CPU마다 조금씩 차이가 있다. 그리고 다양한 주소 지정 방식이 있다.

오퍼랜드(Operand): 명령어를 수행할 대상
오퍼랜드가 담기는 오퍼랜드 필드에는 연산의 대상(데이터)이 직접 명시되기도 하고, 대상의 위치(레지스터 이름, 메모리 주소)가 명시되기도 한다.

Q) 왜 데이터를 직접 명시하지 않고 위치를 명시하는 것일까?

더해라	100과	120을
빼라	메모리 32번지 값과	메모리 33번지 값을
저장해라	10을	메모리 128번지에

A) 명령어의 길이는 한정되어 있기 때문에

명령어는 연산코드와 오퍼랜드로 구성되어있고, 오퍼랜드는 여러 개 있을 수 있다.

이 때, 명령어의 총 길이가 한정되어 있다면, 연산코드를 명시하기 위한 공간과 오퍼랜드를 명시하기 위한 공간이 한정되어 있게 된다.

명령어의 길이가 16bit라고 가정한다면,

오퍼랜드가 2개인 경우(2-주소 명령어)

연산코드(4bit)	오퍼랜드(6bit)	오퍼랜드(6bit)

하나의 오퍼랜드 필드로 표현할 수 있는 데이터 크기: 2^6(64)

오퍼랜드가 3개인 경우(3-주소 명령어)

연산코드(4bit)	오퍼랜드(4bit)	오퍼랜드(4bit)	오퍼랜드(4bit)

하나의 오퍼랜드 필드로 표현할 수 있는 데이터 크기: 2^4(16)

하나의 오퍼랜드에 2500 이라는 데이터를 표현해야 한다면, 이를 직접 명시할 수는 없다.
최대 표현가능한 데이터가 16밖에 안되니까

위와 같은 문제를 해결하기 위해 오퍼핸드 필드에 연산 코드의 대상이 되는 데이터를 직접 명시하기 보다는, 데이터가 저장되어있는 공간(레지스터 이름이라던지, 메모리 주소)을 명시

메모리(유효 주소 = 10번지)

레지스터(유효 주소 = R1)

유효 주소: 연산 코드에 사용할 데이터가 저장된 위치, 즉 연산의 대상이 되는 데이터가 저장된 위치
주소 지정: 유효 주소를 찾는 방법

주소 지정의 방식

1. 즉시 주소 지정(가장 간단, 많이 사용되지는 않음)

연산코드	연산코드에 사용될 데이터

연산에 사용할 데이터를 오퍼랜드 필드에 직접적으로 명시
가장 빠른 주소 지정(이론상) + 데이터 크기에 제한

2. 직접 주소 지정

직접 주소 지정

오퍼랜드 필드에 유효 주소(연산에 사용될 데이터가 저장된 메모리 주소) 명시
오퍼랜드 필드로 표현가능한 메모리 주소 크기에 제한(메모리가 커지면서 메모리 주소의 크기가 커지고 있음) -> 간접 주소 지정의 등장 배경

CPU가 레지스터에 접근하는 속도보다 메모리에 접근하는 속도가 훨씬 느리다.
레지스터에 접근함으로써 처리할 수 있는 작업은 레지스터에 접근해서 처리하는 것이
훨씬 더 빠른 성능을 보장한다.

3. 간접 주소 지정

오퍼랜드 필드에 유효 주소의 주소를 명시
유효 주소 크기에 제한은 없으나, 속도가 비교적 느림

간접 주소 지정

4. 레지스터 주소 지정

연산에 사용할 데이터를 저장한 레지스터의 이름을 오퍼랜드 필드에 직접 명시
레지스터 접근은 메모리보다 빠르다

레지스터 주소 지정

5. 레지스터 간접 주소 지정

연산에 사용할 데이터를 메모리에 저장하고, 그 주소(유효 주소)를 저장한 레지스터를 오퍼랜드 필드에 명시
메모리 접근은 한 번

레지스터 간접 주소 지정

6. +a

[scrcpy] 여러 기기가 연결되었을 때 특정 기기만 미러링하기

wbnh09 — Thu, 25 Jul 2024 23:10:26 +0900

다음과 같이 여러대의 기기가 연결되어있는 경우가 있다.

이런 경우 이전 글에서처럼 단순히

scrcpy --always-on-top

을 실행하게 되면

위와 같은 에러가 나게된다.

이때에는 -s 명령어를 추가해서 하나의 기기만 미러링할 수 있다.

scrcpy -s [기기 IP주소:포트번호] --always-on-top

[Git] 현재 branch에서 작업한 내용 삭제하기

wbnh09 — Sun, 14 Jul 2024 22:45:39 +0900

Git을 사용하면서 작업을 하다가 현재까지 작업했던 내용을 모두 삭제하고 마지막 커밋했던 시점으로 되돌리려면 2가지 방법이 있다.

1. Github Desktop을 이용하는 경우

위 이미지처럼 changed file에 우클릭하면 'Discard All Changes' 와 'Stash All Changes' 라는 옵션이 있는데 Discard를 하게 되면 하단에 있는 변경 내역들이 모두 삭제된다.

참고로 'Stash All Changes'를 누르게 되면 변경사항들은 모두 임시저장 Stack에 들어가게 되고 변경사항들은 삭제된다.

'Stash All Changes'를 선택시 'Stashed Changes'가 나오게 되고 위 사진과 같이 Stash 된 변경사항들을 Restore 할지 Discard 할지 선택하면 된다.

2. 터미널을 이용하는 경우

git checkout .

터미널에 위 명령어를 치기만 하면된다.

[Git] 지금까지 작업한 내용 임시저장하기 git stash

wbnh09 — Wed, 10 Jul 2024 17:58:37 +0900

프로젝트를 진행하다보면 Main branch에 여러 branch를 만들고 작업하는 경우가 있을 것이다.

예를 들어 a branch에서 작업하다가 main branch에서 급하게 수정해서 반영해야하거나, 다른 동료의 코드를 봐주어야할 때 지금까지 작업했던 내용들을 commit하고 branch를 바꾸기에는 애매한 상황이 있을 것이다.(commit 하기엔 애매한 코드라던가..)

그런 경우 git stash 를 통해 지금까지 작업한 내용을 임시저장하고 branch 전환하면 매우 편리하다.

1. git stash 로 임시저장하기

git stash 전

위와 같이 a-branch에서 작업하던 내용이 있을 경우 git stash 를 통해 임시저장을 할 수 있다.

git stash를 할 때에도 2가지 방법이 있다.

- git stash

git stash

git stash

위와 같이 git stash 만 하는 경우 변경사항이 무작위 이름으로 stack에 저장된다.

- git stash save ""

git stash save "title"

git stash save ""

위와 같이 git stash save "" 로 해당 변경사항에 이름이나 정보를 넣는 경우 git stash list로 확인해봤을 때 한눈에 뭐와 관련된 변경사항인지 쉽게 파악할 수 있다.

2. stash 에 있는 항목 불러오기

stash에 저장된 항목을 불러오기 위해서는 2가지 방법이 있다.

- 변경사항 적용 및 삭제하기

stash에 저장된 항목을 불러오려면 기본적으로 다음 명령어를 입력하면 된다.

git stash pop

하지만 위 명령어만 입력하게 되면 가장 최근에 stack에 추가된 변경사항을 불러오면서 동시에 삭제하게 된다.

위 stash list에서 가장 처음에 넣었던 변경사항을 가져오려면 콜론(:) 앞에 stash@{번호}를 git stash pop 뒤에 넣어주면 된다.

git stash pop

- 변경사항 적용만 하기

stash에 저장된 항목 불러오기만 하기

git stash apply

이 명령어도 pop과 마찬가지로 위 명령어만 입력 시 가장 최근의 변경사항을 적용만하게 된다.(삭제 X)

원하는 변경사항을 적용하려면 pop과 마찬가지로 stash@{번호}를 git stash apply 뒤에 넣어주면 된다.

git stash apply

3. 변경사항 폐기하기

stash에 저장된 항목을 폐기하려면 다음과 같이 명령어를 입력하면 된다.

git stash drop

이 명령어도 pop과 마찬가지로 위 명령어만 입력 시 가장 최근의 변경사항을 폐기하게 된다.

원하는 변경사항을 폐기하려면 pop과 마찬가지로 stash@{번호}를 git stash drop 뒤에 넣어주면 된다.

git stash drop

4. 변경사항 삭제하기

stash에 저장된 항목들 삭제하기

git stash clear

git stash clear

[Git] 과거 커밋 기록으로 이동하기 git checkout

wbnh09 — Sun, 7 Jul 2024 15:22:08 +0900

Git을 사용하면서 프로젝트를 진행하다보면 이전에 커밋했던 상태의 코드를 확인해보고 싶을 때가 있다.

1. 터미널에 git log를 통해 Commit Id를 확인하자

git log 확인

위에서부터 최신 커밋 순으로 나열된다. 커밋기록이 많은 경우 최신부터 일부 commit만 표시되고 터미널 하단에

:[커서 깜빡이는 중..]

위와 같이 표현될텐데, 더 이전의 기록을 보고싶다면 '엔터'를 치거나, 그만보고 싶으면 'q'를 누르면 터미널 명령어를 누를 수 있는 상태로 돌아오게 된다.

2. 원하는 시점의 commit id에서 앞 7자리를 복사하고 git checkout [7자리]

git checkout 7자리

그럼 IDE의 코드가 그 시점의 커밋 상태로 돌아간 것을 확인할 수 있다.

- Github를 사용하는 경우

Repository안에서 Code 탭에서 Commits를 클릭하면 그동안 커밋했던 기록들이 나오게 된다.

github Commit 기록들

여기서 우측에 있는 Commit Id를 복사해도 된다.

- Gitlab을 이용하는 경우

Repository -> Commits를 클릭하면 github와 마찬가지로 과거 Commit들이 나오게 된다.

gitlab Commit 기록들

Gitlab에서는 8자리로 나오긴 하는데 7자리든 8자리든 상관없는 것 같다.

3. 다시 최근 Commit으로 돌아오고 싶다면 git checkout -

git checkout -

그럼 최근 상태로 돌아오는 것을 확인해볼 수 있다.

[Git] gitignore 설정하기

wbnh09 — Mon, 1 Apr 2024 14:45:47 +0900

.gitignore는 프로젝트를 github에 올릴 때 .gitignore에 명시된 파일은 github에 적용되지 않도록 해준다.

API key나 Client ID와 같은 개인정보가 담긴 파일을 제외하고 github에 push해야하는 경우 적합하다.

그리고 각 OS 마다 프로젝트를 열 때 생성되는 파일이 달라 충돌이 일어날 수도 있기 때문에 gitignore를 통해서 그런 파일들은 무시해주는 것이 좋다.

.gitignore에 들어갈 파일 생성하기

그럼 gitignore에 들어가야하는 파일은 무엇일까? 아래 사이트에서 자신의 OS, 언어, 개발환경(IDE) 등을 입력하면 필요한 gitignore 파일들이 자동으로 생성된다.

https://www.toptal.com/developers/gitignore/

gitignore.io

Create useful .gitignore files for your project

www.toptal.com

협업을 할 때에는 MacOS를 쓰는 사람도 있고 Window를 쓰는 사람도 있다. 따라서 다음과 같이 키워드를 입력했다.

'생성' 버튼을 클릭한 후 생성된 텍스트를 IDE에서 최상단 .gitignore에 추가해주면 된다.

프로젝트 중간에 .gitignore 추가, 수정한 경우

프로젝트 중간에 이미 github에 올라가 있는 파일을 .gitignore에 추가하는 경우 해당 프로젝트의 터미널에서 다음과 같은 작업을 해줘야 한다.

git rm -r --cached .
git add .
git commit -m "커밋 메시지"

그러면 .gitignore에 추가한, 이미 github에 올라가 있는 파일이 git repository에서 삭제되면서 .gitignore이 성공적으로 적용될 것이다.

[Java] 이진탐색(Binary Search)

wbnh09 — Tue, 19 Mar 2024 20:04:18 +0900

이진탐색(Binary Search)를 하기 위해서는 배열이 정렬되어 있어야한다.

이진탐색은 배열을 계속해서 반으로 쪼개나아가면서 탐색하는 알고리즘이다.

배열 예시

위와 같은 배열이 있을 때 '43'원소의 index를 찾고자 하는 경우

배열의 양 끝의 index를 left와 right로 두고 반복문을 시작한다.

이 경우 mid의 index는 (left + right) / 2 가 된다.

mid에 해당하는 원소가 '43'이 아니므로 left를 (mid + 1)로 할당함으로써 기존 mid index를 포함한 왼쪽은 탐색하지 않는다.

그럼 위와 같이 left와 mid가 새롭게 할당된다.

새로운 mid에 해당하는 원소도 43이 아니므로 mid를 포함한 오른쪽은 탐색에서 제외하고 right를 (mid - 1)로 다시 할당해 준다.

그럼 위와 같이 right와 mid가 새롭게 할당된다.

여기서 mid는 (6 + 5) / 2 = 5이므로 mid는 5가 되고 arr[5]는 43이 아니므로 left를 (mid + 1)로 할당해준다.

그럼 위와 같이 되고 '43'의 index는 6이라는 것을 알 수 있게 된다.

위 과정을 코드로 구현하면 다음과 같다.

public class Main {
    public int solution(int M, int[] input) {
        int answer = 0;
        Arrays.sort(input);
        int leftIdx = 0, rightIdx = input.length - 1;

        while (leftIdx <= rightIdx) {
            int midIdx = (leftIdx + rightIdx) / 2;
            if (input[midIdx] == M) {
                answer = midIdx + 1;
                break;
            } else if (input[midIdx] > M) {
                rightIdx = midIdx - 1;
            } else {
                leftIdx = midIdx + 1;
            }
        }
        return answer;
    }

    public static void main(String[] args) {
        Main T = new Main();
        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        int M = sc.nextInt();
        int[] input = new int[N];
        for (int i = 0; i < N; i++) {
            input[i] = sc.nextInt();
        }
        System.out.println(T.solution(M, input));
    }
}

결과

[Java] Comparable을 이용한 객체 비교

wbnh09 — Sun, 17 Mar 2024 19:38:16 +0900

기본형 데이터의 경우 간단하게 Arrays.sort() 와 같은 메서드로 정렬이 가능하다.

하지만 특정 객체의 경우 기본형 타입과는 다르게 정렬 기준을 정의해야 하는 경우가 있다. 이때 Java의 Comparable을 이용할 수 있다.

Java의 Comparable은 interface이기 때문에 이를 상속받는 class에서는 Comparable interface에 있는 compareTo를 구현해야한다.

Comparable

위 사진에서 보이듯 compareTo는 비교 결과에 따라 int를 반환한다.

들어온 객체가 자신보다 크면: 음수 리턴
들어온 객체와 자신이 같으면: 0 리턴
들어온 객체보다 자신이 크면: 양수 리턴

이를 이용하여 x, y 좌표를 입력 받고 x 기준으로 오름차순으로 정렬하고 x가 같다면 y 기준으로 오름차순으로 정렬하는 코드는 다음과 같다.

class Point implements Comparable<Point> {
    public int x, y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public int compareTo(@NotNull Point o) {
        if (this.x == o.x) {
            return this.y - o.y;
        } else {
            return this.x - o.x;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Main T = new Main();
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        ArrayList<Point> input = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            input.add(new Point(x, y));
        }

        Collections.sort(input);

        for (Point point : input) {
            System.out.println(point.x + " " + point.y);
        }
    }
}

결과

내림차순이든 오름차순이든 compareTo 함수에서 음수가 리턴되도록 하면 된다.

오른차순의 경우: this - o
내림차순의 경우: o - this

[Java] 선택정렬 & 버블정렬 & 삽입정렬

wbnh09 — Fri, 15 Mar 2024 17:45:40 +0900

선택정렬

해당 위치에 들어갈 원소를 결정한다.

배열 예시

위와 같은 배열을 오름차순으로 정렬하고자 할 때 i의 index를 0에 고정하고 j의 index를 1부터 끝까지 순회하면서 가장 작은 값을 index 0에 배치한다.

그 다음 i의 index를 1에 고정하고 j의 index를 2부터 끝까지 순회하면서 가장 작은 값을 index 1에 배치한다. 위 과정을 반복하게 되면 배열은 결국 오름차순으로 정렬이 된다.

public class Main {
    public int[] solution(int[] input) {
        for (int i = 0; i < input.length - 1; i++) {
            int minIdx = i;
            for (int j = i + 1; j < input.length; j++) {
                if (input[minIdx] > input[j]) {
                    minIdx = j;
                }
            }
            int tmp = input[i];
            input[i] = input[minIdx];
            input[minIdx] = tmp;
        }
        return input;
    }

    public static void main(String[] args) {
        Main T = new Main();
        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        int[] input = new int[N];
        for (int i = 0; i < N; i++) {
            input[i] = sc.nextInt();
        }

        int[] result = T.solution(input);
        for (int i : result) {
            System.out.print(i + " ");
        }
    }
}

결과

내림차순의 경우 부등호 방향을 바꿔주면 된다.

버블정렬

버블정렬은 자기 자신의 옆에 있는 값과 비교하며 순서를 바꿔나가는 정렬 방식이다.

배열 예시

위와 같은 배열을 오름차순으로 정렬할 때 다음과 같이 자신의 옆에 있는 값과 비교하여 바꿔나가는 방식이다.

첫번째 반복

두 번째 반복

위와 같이 정렬되기 때문에 가장 뒤쪽의 index부터 정렬이 된다.

public class Main {
    public int[] solution(int[] input) {
        for (int i = 0; i < input.length - 1; i++) {
            for (int j = 0; j < input.length - i - 1; j++) {
                if (input[j] > input[j + 1]) {
                    int tmp = input[j];
                    input[j] = input[j + 1];
                    input[j + 1] = tmp;
                }
            }
        }
        return input;
    }

    public static void main(String[] args) {
        Main T = new Main();
        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        int[] input = new int[N];
        for (int i = 0; i < N; i++) {
            input[i] = sc.nextInt();
        }

        int[] result = T.solution(input);
        for (int i : result) {
            System.out.print(i + " ");
        }
    }
}

위와 같은 배열은 두번만에 정렬이 완료되었지만 내림차순으로 정렬되어 입력되었을 때는 다음과 같이 정렬될 수 있다.

내림차순으로 정렬하고자 할때에는 선택정렬과 마찬가지로 부등호 방향을 바꿔주면 된다.

삽입정렬

삽입정렬은 i의 index를 1부터 두고 j의 index를 i-1부터 0까지 순회하면서 i의 index에 해당하는 값을 적절한 자리에 삽입하는 정렬 방식이다.

배열 예시

위와 같은 배열에서 정렬을 해 나아가면 다음과 같다.

정렬 과정

public class Main {
    public int[] solution(int[] input) {
        for (int i = 1; i < input.length; i++) {
            int target = input[i], j = i - 1;
            while (j >= 0 && target < input[j]) {
                input[j + 1] = input[j];
                j--;
            }
            input[j + 1] = target;
        }
        // 아래와 같은 방식도 가능하다
//        for (int i = 1; i < input.length; i++) {
//            int tmp = input[i], j;
//            for (j = i - 1; j >= 0; j--) {
//                if (input[j] > tmp) {
//                    input[j + 1] = input[j];
//                } else {
//                    break;
//                }
//            }
//            input[j + 1] = tmp;
//        }
        return input;
    }

    public static void main(String[] args) {
        Main T = new Main();
        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        int[] input = new int[N];
        for (int i = 0; i < N; i++) {
            input[i] = sc.nextInt();
        }

        int[] result = T.solution(input);
        for (int i : result) {
            System.out.print(i + " ");
        }
    }
}

결과

[Java] BOJ 10799번: 쇠막대기(자바)

wbnh09 — Tue, 20 Feb 2024 16:58:45 +0900

문제 링크: https://www.acmicpc.net/problem/10799

10799번: 쇠막대기

여러 개의 쇠막대기를 레이저로 절단하려고 한다. 효율적인 작업을 위해서 쇠막대기를 아래에서 위로 겹쳐 놓고, 레이저를 위에서 수직으로 발사하여 쇠막대기들을 자른다. 쇠막대기와 레이저

www.acmicpc.net

문제)

여러 개의 쇠막대기를 레이저로 절단하려고 한다. 효율적인 작업을 위해서 쇠막대기를 아래에서 위로 겹쳐 놓고, 레이저를 위에서 수직으로 발사하여 쇠막대기들을 자른다. 쇠막대기와 레이저의 배치는 다음 조건을 만족한다.

쇠막대기는 자신보다 긴 쇠막대기 위에만 놓일 수 있다. 쇠막대기를 다른 쇠막대기 위에 놓는 경우 완전히 포함되도록 놓되, 끝점은 겹치지 않도록 놓는다.
각 쇠막대기를 자르는 레이저는 적어도 하나 존재한다.
레이저는 어떤 쇠막대기의 양 끝점과도 겹치지 않는다.

아래 그림은 위 조건을 만족하는 예를 보여준다. 수평으로 그려진 굵은 실선은 쇠막대기이고, 점은 레이저의 위치, 수직으로 그려진 점선 화살표는 레이저의 발사 방향이다.

BOJ 10799

이러한 레이저와 쇠막대기의 배치는 다음과 같이 괄호를 이용하여 왼쪽부터 순서대로 표현할 수 있다.

레이저는 여는 괄호와 닫는 괄호의 인접한 쌍 '( )'으로 표현된다. 또한, 모든 '( )'는 반드시 레이저를 표현한다.
쇠막대기의 왼쪽 끝은 여는 괄호 '('로, 오른쪽 끝은 닫힌 괄호 ')'로 표현된다.

위 예의 괄호 표현은 그림 위에 주어져 있다.

쇠막대기는 레이저에 의해 몇 개의 조각으로 잘려지는데, 위 예에서 가장 위에 있는 두 개의 쇠막대기는 각각 3개와 2개의 조각으로 잘려지고, 이와 같은 방식으로 주어진 쇠막대기들은 총 17개의 조각으로 잘려진다.

쇠막대기와 레이저의 배치를 나타내는 괄호 표현이 주어졌을 때, 잘려진 쇠막대기 조각의 총 개수를 구하는 프로그램을 작성하시오.

입력)

한 줄에 쇠막대기와 레이저의 배치를 나타내는 괄호 표현이 공백없이 주어진다. 괄호 문자의 개수는 최대 100,000이다.

출력)

잘려진 조각의 총 개수를 나타내는 정수를 한 줄에 출력한다.

입출력 예시)

BOJ 10799 입출력 예시

코드)

import java.util.Scanner;
import java.util.Stack;

public class Main {
    public int solution(String input) {
        int answer = 0, pastStackSize = 0;
        Stack<Character> stack = new Stack<>();
        for (char c : input.toCharArray()) {
            if (c == '(') {
                stack.push(c);
            } else {
                stack.pop();

                int stackSize = stack.size();
                if (pastStackSize > stackSize) {
                    answer += 1;
                } else {
                    answer += stackSize;
                }
                pastStackSize = stackSize;
            }
        }
        return answer;
    }

    public static void main(String[] args) {
        Main T = new Main();
        Scanner sc = new Scanner(System.in);

        String input = sc.next();
        System.out.println(T.solution(input));
    }
}

결과)

결과