ab0utcom 님의 블로그

[Rankk.org]Level3/42: Weak algorithm

ab0utcom — Fri, 10 Jul 2026 17:42:57 +0900

#include <stdio.h>

int floor_div2(int x)
{
    return (x >= 0) ? x / 2 : (x - 1) / 2;
}

int d2e(int c)
{
    return 102 - (c - 99) + 4 * floor_div2(c - 99);
}

int e2d(int x)
{
    for (int c = 0; c < 256; c++)
    {
        if (d2e(c) == x)
            return c;
    }

    return -1;
}


char str[] =
"739B9D9895939EA45447A1969B43868C843F89913F3B718B7B7E8D8A347E87318477752D816E6F7B6F6B267E7575662F";


int main()
{
    int len = sizeof(str) - 1;
    int count = len / 2;

    for (int i = 0; i < len; i += 2)
    {
        unsigned int num;
        sscanf(&str[i], "%2X", &num);

        int distance = count - 1 - i / 2;

        num -= distance;

        printf("%c", e2d(num));
    }

    return 0;
}

규칙만 약간의 노가다로 구했고, 일일이 쓰는건 진짜 하기 싫어서 자동화 프로그램을 작성했다.

a->64

b->63

c->66

d->65

e->68

f->67

g->6A

h->69

이런식으로 16진수 상에서 -1과 +3을 반복하면서 커진다. 이를 잘 다듬어서 d2e를 만들었고, 역으로 e2d를 만든다.

추가로

ab->6563

ac->6566

bc->6466

로 암호화 되는데, 마지막 문자까지 거리를 암호화문에서 빼고 복호화하면 된다.

이런 사고를 코드로 구현한거다. Level3에 복잡한 게 많은 것 같은데, 이건 그나마 쉬운 편인 것 같다.

[Rankk]Level2/5: Mastermind

ab0utcom — Wed, 8 Jul 2026 14:53:13 +0900

4자리 숫자야구를 180초동안 2번 성공해야 한다.

근데 6번 틀리면 초기화된다.

머리로 하면 아무리봐도 못할 것 같고, 페이지 코드나 쿠키 이런거 봐도 모르겠어서 코드를 짰다.

import itertools
from collections import Counter

def get_hints(guess, secret):
    """현재 추측값과 비밀값 간의 A(스트라이크)와 B(볼) 개수를 계산합니다."""
    A = sum(1 for g, s in zip(guess, secret) if g == s)
    g_remain = [g for g, s in zip(guess, secret) if g != s]
    s_remain = [s for g, s in zip(guess, secret) if g != s]
    
    g_cnt = Counter(g_remain)
    s_cnt = Counter(s_remain)
    B = sum(min(g_cnt[k], s_cnt[k]) for k in g_cnt)
    
    return A, B

def main():
    print("====================================================")
    print("   Rankk Mastermind Solver (넌스톱 무한 연타 버전)")
    print("====================================================")
    
    digits = "123456789"
    
    while True:
        pool = ["".join(p) for p in itertools.product(digits, repeat=4)]
        turn = 1
        
        print("\n" + "="*55)
        print("▶ 새로운 게임 세션 시작 (총 후보군: 6,561개)")
        print("="*55)
        
        while turn <= 6:
            if turn == 1:
                guess = "1122"
            else:
                if not pool:
                    print("\n❌ 데이터 오류: 조건에 맞는 숫자가 없습니다. 자동 리셋합니다.")
                    break
                guess = pool[0]
                
            print(f"\n[{turn} / 6 회차] 추천 입력값   [ {guess} ]")
            
            # 6회차 특수 분기: 입력 후 엔터만 치면 조건 없이 즉시 새 게임으로 이동
            if turn == 6:
                input("    마지막 6회차입니다. 사이트 입력 후 [Enter]를 누르면 다음 판이 바로 시작됩니다.")
                break
                
            print(f"  (현재 필터링되어 남은 정답 후보: {len(pool)}개)")
            
            # 1~5회차 정상 입력 프로세스
            try:
                A = int(input("  사이트 결과 'A' 개수 입력: "))
                B = int(input("  사이트 결과 'B' 개수 입력: "))
            except ValueError:
                print("  ⚠️ 숫자로만 정확히 입력해 주세요. 이번 회차를 다시 진행합니다.")
                continue
                
            # 1~5회차 중 정답을 맞춘 경우 (4A)
            if A == 4:
                print(f"\n  성공! 4A 정답입니다. 다음 게임으로 즉시 넘어갑니다.")
                break
                
            pool = [candidate for candidate in pool if get_hints(guess, candidate) == (A, B)]
            turn += 1

if __name__ == "__main__":
    main()

현재 상황에서 추천 번호 조합을 만들어주고, 그걸 입력했을 때

Correct digit and correct position: A

Correct digit but wrong position: B로 간주하고 각각의 개수를 적으면 된다.

실패할 때도 있는데, 운이 좋으면 성공할 수 있다.

진행하다가 웃는 얼굴의 파라오 아이콘이 뜨면 1번 성공한거다. 그 상태에서 1번 더 성공하면 자동으로 클리어된다.

글로벌 버디 프로그램 8팀 vlog제출

ab0utcom — Thu, 4 Jun 2026 18:12:05 +0900

안녕하십니까 글로벌 버디 프로그램 8팀 vlog입니다.

메일로 내용을 쓰기엔 영상과 사진을 포함해서 한번에 못보내고 드라이브 링크 형식으로 공유가 되길래,

티스토리로 공유한 점 양해 바랍니다.

Hover over the text to see English!

처음 만난 저희는 밥부터 빠르게 먹어보자 생각했십니더

외국인들과 먹기에 좋을 적당한 느좋 메뉴를 고민하다가, 국룰 밥약 장소인
<율천회관>과 <일미리 금계 찜닭> 두 후보를 골랐습니다. φ(゜▽゜*)♪

Since it was our first time meeting, we thought it would be best to grab a meal together first and get comfortable with each other.

We wanted something with a nice atmosphere that would also be easy for international students to enjoy, so after some thought, we narrowed it down to two classic go-to spots for a meal gathering:
Yulcheon Hoegwan and Ilmiri Geumgye Jjimdak.φ(゜▽゜*)♪

엣큥~!

동아리하느라 늦어버려서, 7시 30분까지 가야하는 율천회관에 못간 것이와요.
그래서 찜닭 먹으러 갔습니다. `(*>﹏<*)′

제가 기숙사에 갔다 오는 동안, 같은 한국인 멤버 승혁 씨한테 간장맛에 순한맛으로 부탁드렸는데, 막상 가보니까 고추장에 보통맛인 겁니다~~

다행히 외국인 두 명이 「맵잘알」이었어서 그렇게 안 맵고 맛있다고 했습니다.
고추장맛 처음 먹어봤는데, 오히려 좋았습니다.

야르

Oopsie~!

We got held up with club activities and ended up running late, so we couldn't make it to Yulcheon Hoegwan before 7:30 PM.
As a result, we went for jjimdak instead. `(*>﹏<*)′

While I was making a quick trip back to the dorm, I asked Seunghyeok, another Korean member, to order the soy-sauce version with the mild spice level.
But when I finally got there, it turned out we somehow ended up with the gochujang version at the regular spice level~~

Fortunately, two of our international members were pretty good with spicy food, so they said it wasn't too spicy and actually tasted great.
It was my first time trying the gochujang version, and honestly, I ended up liking it even more.

Yarrr~(It is a korean SLANG when korean eat delicious food:D)

후식은 학교 안에 있는 벤치에서 진행했습니다. 제가 몇 주 전에 생일이었는데, 늦게나마 축하해준 친한 선배가 준 마카롱이 딱 이 날 배송되어서, 같이 먹고자 택배를 가지러 다녀온 것이었습니다!! (￣y▽￣)╭ Ohohoho.....

여러 얘기를 했는데, 아니 이 양반들이 술게임을 제대로 해본 적이 없다는 겁니다~~ 물론 한국인도 어려운 술게임이지만, 소프트의 꽃(≡ 술겜)을 안 해봤다니 '이건 못 참지' 하면서 몇 개 가르쳐드렸습니다.

이름을 외워서 해야 하는 어목조동 등 아이엠 그라운드류 게임은 힘들 것 같아서, 호빵찐빵대빵을 가르쳐 드렸습니다.

Dessert was enjoyed on a bench inside campus. My birthday was a few weeks ago, and a close senior who belatedly congratulated me had sent macarons, which happened to arrive that day—so I went to pick up the parcel so we could all share them!! (￣y▽￣)╭ Ohohoho.....

We ended up talking about all sorts of things, and I realized none of them had really tried Korean drinking games~~ Of course, even Koreans struggle with many of them, but I couldn’t let the “soft culture core” (i.e., drinking games) go unintroduced, so I taught them a few.

Games like “Eomok Jodong” or other name-memorization, “I’m Ground”-style games seemed a bit too difficult, so I started them off with “Hopang Jjinppang Daepang” instead.

활동 중간에 있던 승혁 씨 생일도 축하했습니다.

We also took a moment during the activity to celebrate Seunghyeok’s birthday.

같이 시험 공부 했습니다

미팅룸 쓰려고 했는데, 예약이 꽉 차버려서

디도 2층 솦콤에서 같이 공부했습니다.

We studied together for our exams.

We originally tried to use a meeting room, but all of the reservations were already fully booked.

So we ended up studying together at Software Complex on the 2nd floor of SKKU Samsung Library.

마지막은 저희 셋로그입니다. 부끄러움 이슈로 한 명을 제외하고, 3명의 영상을 공개하겠습니다.

Finally, here is our group vlog. Due to shyness issues, one person will be excluded, and I’ll be sharing videos of the remaining three of us.

비슷하게 일어났는데

I woke up around the same time.

쉬는 날이라고 시험 1주일 전에 8시까지 게임을 하는 한 명이 인상적이네요^^

(거의 다 잡았다고 했는데, 11시까지 한 건 비밀임미다)

o((>ω< ))o

One person was particularly impressive—playing games until 8 a.m. just one week before exams because it was a “day off” ^^

(He said he almost finished everything, but the fact that it went on until 11 a.m. is a secret.)

o((>ω< ))o

GBP_8.mp4

9.43MB

끝(Done!)

외국인들과 함께 이런 경험을 할 것이라고는 생각해본 적이 없었는데, 다들 친절하고 열심히 하는 열정을 볼 수 있었습니다.

뜻깊은 시간이었고, 다음에도 이런 기회가 있다면 꼭 참여해보고 싶네요

I had never imagined I would get to have an experience like this with international students, but everyone was kind and showed a lot of enthusiasm.

It was a truly meaningful time, and if I get another chance like this in the future, I’d definitely love to take part again.

후기:

Asiye: It was a good experience to meet new people from the department, share each others experiences and study together. Thank you to the department of software!

Enkhmaa: Thank you to my global buddies who added a shine to my day!!

[Computer Systems] Chapter.3_Practice Problem

ab0utcom — Tue, 28 Apr 2026 15:37:28 +0900

풀이를 시작하기 전에 내가 이해한 바를 적겠다. 레지스터에 저장하고, 메모리에서 참조하는 것을 가져오는 과정 등을 대충은 이해를 하다가 말로 표현이 가능할 정도로 감이 잡힌 바를 정리하겠다. 아는 사람에게는 당연한 얘기일 것이다.

※ 레지스터에는 항상 값으로 숫자를 저장한다. 레지스터의 주소 이런건 없다. 64비트인 rax레지스터에는 64개의 이진수를 저장하고, 이를 4개씩 끊어 16진수로 보기 쉽게 표현한다. 이때 예를 들면 %eax에는 0x12345678 이런숫자가 저장돼있다는 거다. 이 숫자는 어느 주소일수도 있고, 값일 수도 있다. 일단 숫자가 저장돼있는 것이다.

※ %rsi가 어떤 포인터 변수를 뜻한다고 하자.

void Access(long A, long *pA) {
	*pA = A;
}

mov %rdi, (%rsi)

처럼 어셈블리어가 표현될 것이다.

%rsi는 레지스터니까 값에 어떤 숫자가 저장된다. 실행 후에 그 숫자열은 변수 A의 주소를 뜻할 것이다.

만약 A가 0xFFFFFFFF($-2^{63}$)이고, 변수 A가 메모리에 저장된 주소가 0xAAAA라면

A를 뜻하는 레지스터 %rdi = 0xFFFFFFFF로 써진다.

pA를 뜻하는 레지스터 %rsi = 0xAAAA가 써지고, (%rsi)를 하면 %rsi가 가진 숫자 값을 주소로 간주하고, 그 주소의 값을 가져오기 때문에 0xFFFFFFFF가 써지는 것이다.

(%rsi) = memory[0xAAAA] = 0xFFFFFFFF

즉 레지스터에는 그냥 숫자만 있고, 어셈블리어로 소괄호 ()를 씌워주면, 그 숫자를 주소로 간주해서 Memeory 그 주소의 값을 가져오는 것이다. 그냥 레지스터 Value 자체는 단순 숫자열이기 때문에 주소로서 의미를 가지는지, 값으로서 의미를 가지는지는 모른다.

Sol)

Operand	Value
%rax	0x100
0x104	0xAB
$0x108	0x108
(%rax)	0xFF
4(%rax)	0xAB
9(%rax, %rdx)	0x11
260(%rcx, %rdx)	0x13
0xFC(, %rcx, 4)	0xFF
(%rax, %rdx, 4)	0x11

1. %rax 레지스터는 0x100이 저장돼있다. 즉 %rax의 Value는 0x100이다.

2. 0x104는 16진수 104로 생각할 수 있지만, Immediate형은 앞에 $기호를 붙여야 한다. 단순 0x104는 주소를 뜻하는 것이고, 그 주소의 값은 0xAB이다.

3. Immediate $0x108은 그 자체로 숫자인 16진수 $108_{16}$이다.

4. (%rax)는 %rax에 저장된 숫자열을 주소로 간주하고, 그 주소에 있는 Value를 가져온다. %rax에 저장된 0x100을 주소로 간주해, 메모리 주소에서 찾아온다 ==> memory[0x100] = 0xFF

5. 4(%rax)는 %rax에 저장된 주소가 가르키는((%rax)를 뜻함) 위치에서 4B 뒤에 위치(주소)의 값을 뜻한다. 즉 0x100에서 4bit 뒤인 0x104 주소가 가르키는 값인 0xAB이다.

다시 말하면 4(%rax)는 %rax가 가진 자체 Value에 4를 더한 숫자를 주소로 간주해, Memory의 그 주소에서 값을 가져온다.

6. 9(%rax, %rdx)는 "%rax가 가진 값 + %rdx가 가진 값 + 9"를 주소로 간주하고, Memory에서 해당 값을 가져온다. 즉 (0x100 + 0x3 + 0x9) = (0x10($12_{10}$)) = (0x10C)이고, 0x10C 주소가 가르키는 값인 0x11을 뜻하는 것이다.

7. 6번이랑 똑같이 하면 된다.

(260 + %rcx + %rdx) = (0x104 + 0x1 + 0x3) = ($264_{10}$) = (0x108) = 0x13

이다.

8. 이것도 똑같다.

(0xFC + %rcx * 4) = (0xFC + 0x1 * 4) = (0xFC + 0x4) = (0x100) = 0xFF

9. (%rax, %rdx, 4) = (0x100 + 0x3 * 4) = (0x100 + 0xC) = (0x10C) = 0x11

Sol)

1. l

2. w

3. b

4. b

5. q

6. w

설명은 생략한다

Sol)

1. x86-64에서는 주소 계산에 64bit 레지스터만 사용 가능하다. 즉 (%ebx)로 쓰면 안되고 (%rbx)라고 써야 한다.

2. movl은 32bit 데이터를 옮기는 건데, %rax는 64bit 레지스터다. %eax로 고치거나, movq로 고쳐야 한다.

3. Memory에서 Memory로 직접 데이터 이동은 불가능하다. 반드시 레지스터를 거쳐야 한다

movw (%rax), %bx
movw %bx, 4(%rsp)

4. %sl이라는 레지스터는 없다. %rsi의 1바이트 범위를 말하는거면 %sil이다.

5. Immediate에 값을 넣을 수는 없다. 즉 mov의 dest는 Imm.이 아닌 Reg.나 Mem.만 가능하다.

6. 작은 크기의 레지스터 값을 큰 레지스터에 넣을 때는 남은 비트를 어떻게 extension할것인지 명시해야 한다.

즉 signed extension을 하고 싶으면 movslq로 하고

zero extension을 하고 싶으면 movl을 하고 dest를 %rdx가 아닌 %edx라고 해야 한다.(movzlq는 없다!!)

7. %si는 2byte 범위의 레지스터다. 즉 명령어를 movw로 바꾸거나

%si가 아닌 %sil이라고 써야 한다.

Sol)

※확장이동인 movs, movz의 dest는 항상 Reg.이다. 즉 Mem.에는 한번에 확장하면서 옮길 수 없다.

2. char형은 signed고, 더 큰 자료형인 int형에 넣는 과정이므로

movsbl (%rdi), %eax
movl %eax, (%rsi)

3. 2번과 동일

4. unsigned char이므로 zero extension

movzbq (%rdi), %rax
movq %rax, (%rsi)

한편 아래처럼 쓸 수도 있다.

movzbl (%rdi), %eax		// 32비트 연산의 특성으로 상위 4B가 자동으로 0이 됨
movq %rax, (%rsi)		// 이미 0으로 채워진 %rax 전체를 저장

이게 명령어 바이트 크기가 더 작아서, 속도가 빠르다.

5. int에서 더 작은 char로 이동하는 과정은 알아서 truncated된다.

movl (%rdi), %eax
movb %al, (%rsi)

이때 첫번째 줄에서 "movb (%rdi), %al"로 대신 쓰면 안되나 생각할 수 있다.

안되는 건 아니고, 결과는 같다. 하지만 여러 이유로 인해 Sol처럼 작성한다.

- 1: x86-64는 little endian이라서 0x0000012C를 저장할 때 2C 01 00 00 순서로 저장되고, movb를 하면 2C를 전달한다. 이때 big endian이면 00을 전달한다.

- 2: %al만 업데이트하면 나중에 %rax또는 %eax를 읽으려 할 때 cpu내부 최적화된 파이프라인을 방해하여 하드웨어적 비효율이 일어난다.

- 3: "movb (%rdi), %al"을 분석할 때 %rdi 주소에 char형 데이터가 있다고 착각할 수 있다.

6. 5번과 동일

7. signed형인 char형을 더 큰 자료형인 short에 저장하므로 signed extension한다.

movsbw (%rdi), %ax
movw %ax, (%rsi)

Sol)

void decode1(long *xp, long *yp, long *zp) {
	long temp = *xp;
    *xp = *yp;
    *yp = *zp;
    *zp = temp;
}

Sol)

1. q+9

2. q+p

3. q+3p

4. 2+p+7q

5. 0xE + 3q

6. 6+p+7q

※ 뭘 의도한 문제인지는 알겠는데, 저 어셈블리어는 오류다. Scale자리에 3, 7이 올 수 없다. 오직 1, 2, 4, 8, ... 인 2ⁿ꼴만 올 수 있다.

이것도 마찬가지다. 첫번째 줄은 어찌어찌 10y라고 해도, 세번째 줄에서 세번째 요소를 scale로 쓰는건지가 헷갈려서 그냥 풀지 않았다

Sol)

1. (%rax)는 %rax값을 주소로 간주하고, 주소가 가르키는 값에 데이터를 읽는 것이다

%rax의 Value가 0x100이므로, addq ~~의 dest. = 0x100이다.

0x100의 Value는 0xFF였는데 여기에 %rcx = 0x1을 더하면 Value = 0x100이다.

2. 마찬가지로 dest는 %rax+8 = 0x108을 주소로 가지는 곳이다. dest. = 0x108

0x108에는 0xAB가 있는데, 여기에서 %rdx = 0x3을 빼면 Value = 0xA8이다

3. %rax+%rdx*8 = 0x100 + 0x3 * $8_{10}$ = 0x100 + 0x18 = 0x118이므로 Dest. = 0x118

0x118의 값인 0x11에 8을 곱해서 저장하므로 Value = 0x88

4. 16(%rax) = *($16_{10}$+%rax) = *(0x110)이다. Dest. = 0x110

0x110에는 0x13이 있는데 여기에서 incq하면 0x14가 된다.

5. %rcx를 decq하면 Dest. = %rcx이고

Value = 0x0이다.

6. Dest. = %rax

Value = 0xFD

Sol)

salq $4, %rax

sarq $4, %ecx

이때 아래줄에서 어차피 4비트 뺄꺼니까 상위 비트는 안가져오려고 movl을 썼다는 것만 유의하면 된다

오류 투성이다. short형인데 접미사를 w가 아닌 q를 쓰고 있고, movq instruction의 dest로 %rbx가 아닌 %bax로 오타를 냈다.

Sol)

short arith3(short x, short y, short z)
{
	short p1 = y | z;
	short p2 = p1 >> 9;
	short p3 = ~p2;
	short p4 = p3 - y;
	return p4;
}

답지에 p4 = y-p3라고 써있는데, 오류로 판단된다.

Sol)

A. %rcx 레지스터를 전부 0으로 바꿔준다.

B. movq $0, %rcx로 대체할 수 있다. (movl $0, %ecx도 된다. 이게 더 빠르기도 하다)

C. 명령어 바이트 수는 안배웠는데, xorq %rcx, %rcx는 3B고, movq $0, %rcx는 7B이상이라고 한다.

Sol)

uremdiv:
	movq %rdx, %r8
    movq %rdi, %rax
    xorl %edx, %edx
    divq %rsi
    movq %rax, (%r8)
    movq %rdx, (%rcx)
    ret

uremdiv는 remdiv와 다르게 %rax의 부호대호 확장하는 cqto가 필요없고, 그냥 %rdx를 0으로 채워주면 된다. 앞 연습문제에서 배운대로 %rdx를 0으로 채워야 하는데, 이 레지스터를 써야 하므로 저장된 unsigned long *xp 정보를 %r8에 복사하고 작업한다.

일단 문제에서 a가 %rdx에 있다고 하는데, %rdi에 있음이 맞아보인다.

Sol)

A. data_t : int

COMP : <

B. data_t : short

COMP : >=

C. data_t : unsigned char

COMP : <=

D. data_t : long, unsigned long, ptr

COMP : !=

Sol)

A. data_t : long

TEST : >=

B. data_t : short, unsigned short

TEST : ==

C. data_t : unsigned char

TEST : > 또는 !=

D. data_t : int

TEST : <=

Sol)

A. 4003fc

[Computer Systems] Chapter.2_Homework problems

ab0utcom — Fri, 3 Apr 2026 16:48:08 +0900

2.55

Compile and run the sample code that uses show_bytes (file show-bytes.c) on different machines to which you have access. Determine the byte orderings used by these machines.

Sol) show-byte.c는

#include <stdio.h>

typedef unsigned char *byte_pointer;

void show_bytes(byte_pointer start, size_t len) {
    int i;
    for (i = 0; i < len; i++)
    printf("%.2x", start[i]);
    printf("\n");
}

void show_int (int x) {
    show_bytes((byte_pointer) &x, sizeof(int));
}

를 이용하면 된다.

간단한

int main()
{
    test_show_bytes(12345);			// 39300000
}

main을 통해 실행해보면 39300000이 나온다.

12345는 16진수로 0x0000003039이다.

그리고 출력 결과가 39 30 00 00 (편의를 위해 띄어쓰자)이므로

내 실행 환경은 little endian으로 작동함을 알 수 있다.

2.57

Write procedures show_short, show_long, and show_double that print the byte representations of C objects of types short, long, and double, respectively. Try these out on several machines.

Sol)

void show_short(short x) {
    show_bytes((byte_pointer) &x, sizeof(short));
}

void show_long(long x) {
    show_bytes((byte_pointer) &x, sizeof(long));
}

void show_double(double x) {
    show_bytes((byte_pointer) &x, sizeof(double));
}

일단 다음처럼 함수를 작성해볼 수 있고, 이어서 예시 main을 통해 검증해보면

int main()
{
    show_short(127);        // 7f00
    show_long(127);         // 7f00000000000000
    show_double(127.0);     // 0000000000c05f40
}

로 쓸 수 있겠다.

short 127은 Bits = $0000 \;0000 \;0111 \;1111_{2}$이므로 $00\;7F_{16}$이고, 이를 little endian으로 표현하니 $7f \; 00$이 나온다.

long 127은 Bits = $00\;00\;00\;00\;00\;00\;00\;7F_{16}$이고, little endian으로 표현하면 $7f \;00\;00\;00\;00\;00\;00\;00$이다.

double 127.0은 $1.111\;1110\;0000\;... \times 2^{6}$이고, double형의 bias = $2^{11-1}-1 = 1023$이므로 비트 구성은

sign bit = 0

exp bit = $6+1023 = 1029_{10} = 10000000101_{2}$

significand bit = $1111\;1100\;000 ...$이므로

$127.0_{10} = 0100\;0000\;0101\;1111\;1100\;0000\;..._{2}=40\;5F\;C0\;00\;00\;00\;00\;00_{16}$이므로

little edian으로 저장되면 $0x00\;00\;00\;00\;00\;c0\;5f\;40$이다.

2.58

Write a procedure is_little_endian that will return 1 when compiled and run on a little-endian machine, and will return 0 when compiled and run on a bigendian machine. This program should run on any machine, regardless of its word size.

Sol)

int is_little() {
    short val = 0x007F;
    unsigned char *p_val = (unsigned char *) &val;
    
    return (p_val[0]==0x7F);     //0x7F00 이면 little, 0x007F이면 big endian
}

2.59

Write a C expression that will yield a word consisting of the least significant byte of x and the remaining bytes of y. For operands x = 0x89ABCDEF and y = 0x76543210, this would give 0x765432EF.

Sol)

int main()
{
    unsigned int x = 0x89ABCDEF;
    unsigned int y = 0x76543210;
    
    unsigned int ans = (x&0xFF) | (y&~0xFF);
    printf("%x", ans);				// 765432ef
}

비트마스킹으로 풀 수 있다.

2.60

Suppose we number the bytes in a w-bit word from 0 (least significant) to w/8 − 1 (most significant). Write code for the following C function, which will return an unsigned value in which byte i of argument x has been replaced by byte b: unsigned replace_byte (unsigned x, int i, unsigned char b);

Here are some examples showing how the function should work: replace_byte(0x12345678, 2, 0xAB) --> 0x12AB5678 replace_byte(0x12345678, 0, 0xAB) --> 0x123456AB

Sol)

unsigned replace_byte(unsigned x, int i, unsigned char b) {
    unsigned mask = 0xFF << (8*i);
    unsigned ans = (x & ~mask) | (b << (8*i));
    return ans;
}

[C++] 프로그래머스 코딩테스 연습_탐욕법_체육복

ab0utcom — Fri, 13 Feb 2026 12:48:03 +0900

최종코드:

#include <string>
#include <vector>
#include <set>
#include <algorithm>    // set_difference

using namespace std;

int solution(int n, vector<int> lost, vector<int> reserve) {
    // 중복 제거, 정렬, 탐색 속도 향상을 위해 set으로 변경
    set<int> s_lost(lost.begin(), lost.end());
    set<int> s_reserve(reserve.begin(), reserve.end());
    
    // 각 set에서 중복 제거
    for (auto it=s_reserve.begin(); it!=s_reserve.end(); ) {
        if (s_lost.count(*it)) {
            s_lost.erase(*it);
            it = s_reserve.erase(it);
        }
        else
            ++it;
    }
    
    vector<bool> ablePE(n+2, true);
    for (int i : s_lost)
        ablePE[i] = false;
    
    // 양도 가능한 체육복 수만큼 answer증가
    int answer = n-s_lost.size();
    for (int i : s_reserve) {
        if (ablePE[i-1] == false) {
            ablePE[i-1] = true;
            answer++;
            continue;
        }
        else if (ablePE[i+1] == false) {
            ablePE[i+1] = true;
            answer++;
        }
    }
        
    return answer;
}

교집합을 빼기 위해 set의 차집합을 이용하려했으나, 생각보다 코드가 안이쁜 관계로 직접 반복자를 이용해 빼줬다.

그리디답게 reverse를 돌면서 채울 수 있으면 채웠다. 상식적으로 작은 숫자부터 채워야 최대로 채울 수 있을 것 같으니 말이다.

[C++] 프로그래머스 코딩테스트 입문_등수 매기기

ab0utcom — Wed, 11 Feb 2026 13:50:56 +0900

최종코드:

#include <string>
#include <vector>

using namespace std;

struct element {
    int sum;
    int index;
};

// 원하는 comp를 통해 정렬
template <typename T, typename Compare>
void Qsort(vector<T>& arr, int start, int end, Compare comp) {
    if (start >= end) return;
    
    T pivot = arr[(start+end)/2];
    
    int l = start, r = end;
    while (l <= r) {
        while (l <= end && comp(arr[l], pivot)) l++;
        while (r >= start && comp(pivot, arr[r])) r--;

        if (l <= r) {
            swap(arr[l], arr[r]);
            l++; r--;
        }
    }

    if (start < r) Qsort(arr, start, r, comp);
    if (l < end) Qsort(arr, l, end, comp);
}

// 자연수 원소만 가지는 내림차순 벡터의 순위 매기는 함수
vector<int> ranker(const vector<element>& arr) {
    if (arr.empty()) return {};
    
    vector<int> ranks;
    ranks.reserve(arr.size());
    
    int current_rank = 1;
    for (int i = 0; i < arr.size(); ++i) {
        // 이전 원소와 값이 다를 때만 현재 인덱스 기반으로 순위 갱신
        if (i > 0 && arr[i].sum != arr[i - 1].sum) {
            current_rank = i + 1;
        }
        ranks.emplace_back(current_rank);
    }
    return ranks;
}

vector<int> solution(vector<vector<int>> score) {
    vector<int> answer(score.size());
    
    vector<element> rankedElements;
    for (int i=0; i<score.size(); i++) {
        rankedElements.emplace_back( element{score[i][0]+score[i][1], i+1} );
    }
    
    // 성적의 합 기준 내림차순 정렬
    Qsort(rankedElements, 0, rankedElements.size()-1, [](const element& a, const element& b) {
        return a.sum > b.sum;
    });
    
    vector<int> computedRanks = ranker(rankedElements);
    
    for (int i=0; i<rankedElements.size(); i++) {
        answer[rankedElements[i].index-1] = computedRanks[i];
    }
    
    return answer;
}

element형 벡터를 element.sum을 기준으로 정렬하는 퀵정렬을 구현했다.

평균을 비교하려면 실수형을 고려해야 하는데, 어차피 성적 ≤ 100이므로 합해도 int형 범위이기 때문에

합을 기준으로 비교했다.

정렬된 배열 [200, 190, 190, 150, 150, 70, 40]의 순위 [1, 2, 2, 4, 4, 6, 7]를 매겨주는 함수 ranker를 통해 답을 구했다.

[C++] 프로그래머스 코딩테스트 입문_문자열 밀기

ab0utcom — Tue, 10 Feb 2026 16:41:22 +0900

최종코드:

#include <string>
#include <vector>

using namespace std;

// 오른쪽으로 n번 밀린 문자열 구하기
string pushString(string msg, int n) {
    if (msg.empty()) return msg;
    if (n==0) return msg;
    
    int L = msg.size();
    n %= L;     // n>L인 경우 방어
    
    string front = msg.substr(0, L-n);
    string back = msg.substr(L-n);
    return back + front;
}

int solution(string A, string B) {
    int answer = -1;
    
    for (int i=0; i<A.size(); i++) {
        // A의 첫문자가 발견되는 위치에서만 확인
        if (A.front() != B[i]) continue;
        
        // 발견했을 때 : 밀어야 하는 수 리턴
        if (pushString(A, i) == B) return i;
    }
    // 발견 못했을 때
    return -1;
}

for문을 돌면서 그때그때 밀어보고 확인하기보다는, 그러한 후보들 중에서만 작동하는 것으로 성능을 높였다.

[C++] 프로그래머스 코딩테스트 입문_다항식 더하기

ab0utcom — Tue, 10 Feb 2026 15:14:52 +0900

최종 코드:

#include <string>
#include <vector>
#include <sstream>

using namespace std;

// 항의 계수를 리턴하는 함수(상수형이면 그대로)
int returnCoef(string term) {
    if (term.back() == 'x') {
        if (term == "x")
            return 1;
        return stoi(term.substr(0, term.size()-1));
    }
    return stoi(term);
}

string solution(string polynomial) {
    istringstream iss(polynomial);
    
    // 문자열에서 항을 파싱
    vector<string> terms;
    string term;
    while (iss >> term) {
        if (term == "+") continue;        
        terms.emplace_back(term);
    }
    
    int coef_X = 0;
    int constant = 0;
    
    // 각 차수별 항의 계수 구하기
    for (string term : terms) {
        if (term.back()=='x')
            coef_X += returnCoef(term);
        else
            constant += returnCoef(term);
    }
    
    ostringstream oss;
    // 1차항 처리
    if (coef_X != 0) {
        if (coef_X != 1)            // 계수 1이면 생략
            oss << coef_X << "x";
        else
            oss << "x";
    }
    
    // 상수항 처리
    if (constant != 0) {
        if (coef_X != 0)            // 1차항이 있을 때만 앞에 '+' 추가
            oss << " + ";
        oss << constant;
    }
    
    return oss.str();
}

sstream으로 파싱하는 게 역시 좋은 것 같다. 편해 아주

혹시나 모든 항이 0이면 결과는 "0"이 되어야 할 것이다. 하지만 문제 조건에 모든 수는 양수이고 +만 기호만 있다고 명시하고 있으므로 처리하지 않았다.

[C++] 프로그래머스 코딩테스트 입문_특이한 정렬

ab0utcom — Tue, 10 Feb 2026 14:36:24 +0900

최종코드:

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

vector<int> solution(vector<int> numlist, int n) {
    sort(numlist.begin(), numlist.end(), [n](int a, int b) {
        int squareA = (a-n)*(a-n);
        int squareB = (b-n)*(b-n);
        
        if (squareA != squareB)
            return squareA < squareB;      // 1순위: 차이 제곱 오름차순
        return a > b;                      // 2순위: 차이가 양수인(기준보다 큰) 수가 앞
    });
    
    return numlist;
}

원래는 이렇게 구현했다.

#include <string>
#include <vector>
#include <algorithm>

struct element {
    int gap;
    int square;
    int value;
};

using namespace std;

vector<int> solution(vector<int> numlist, int n) {
    vector<int> answer;
    
    // gap_arr라는 struct 배열에 기준 n과의 차이, 차이², 원래 값을 묶어서 추가
    vector<element> gap_arr;
    for (int i : numlist) {
        int diff = i - n;
        gap_arr.push_back({diff, diff * diff, i});
    }
    
    // element배열을 gap² 오름차순으로 정렬(만약 같으면 gap>0인 element부터)
    sort(gap_arr.begin(), gap_arr.end(), [](const element& a, const element& b) {
        if (a.square != b.square)
            return a.square < b.square;
        
        return a.value > b.value;
    });
    
    // element 순서대로 value를 모으기
    for (const element& e : gap_arr) {
        answer.push_back(e.value);
    }
    
    
    return answer;
}

gap의 절대값을 기준으로 정렬해야 하는데, 사실 제곱해도 결과는 같으니 제곱으로 구현했다.

하지만 구현하고나니 struct에 제곱을 저장하지 말고, 그냥 sort 내에서 제곱끼리 비교하는 게 낫지 않나 생각했고, 그냥 저장하지말고 아싸리 한번에 구현하는 것으로 향상시켰다.