NHEE 개발 TIL

Android CLI 설치 후, Cluade Code에 /android-cli skill 추가하기

남 희 — Fri, 5 Jun 2026 17:26:29 +0900

참고로 환경은 Mac with Apple Chip 입니다.

1. Android CLI 다운로드

https://developer.android.com/tools/agents/android-cli/download

위 링크에서 각 OS에 맞는 명령어 입력

아래 명령어는 Mac with Apple Chip, Local installation

curl -fsSL https://dl.google.com/android/cli/latest/darwin_arm64/install.sh | bash

2. Cluade skill 추가를 위해 아래 명령어 순서대로 실행

1. Android CLI 최신 업데이트

android update

2. init을 실행하여 android-cli 스킬을 설치

android init

순서대로 실행하면 Cluade Code에서 추가된 것을 확인 가능하다!

참고 자료:

https://developer.android.com/tools/agents/android-cli?hl=ko

[Google Play Store] 건강 선언 오류로 심사 제출이 불가할 때 해결 방법 (제출 서류가 없을 때 임시 해결책)

남 희 — Fri, 27 Mar 2026 18:26:24 +0900

다행히 10분 안에 해결할 수 있는 문제였다
유럽 경제 국가가 타겟으로 설정되어 있어 발생한 오류, 우선 임시 해결책으로 해당 국가를 제외하기로 하였다

현상

해결 방법

1. 테스트 및 출시 > 프로덕션 탭 클릭 후, 국가/지역 탭 클릭하여 ‘국가/지역 수정’ 누르기

2. 여기서 오류 발생 국가를 제거하고 저장한다

만약 유럽경제국가 때문에 에러가 발생했다면 아래 31개국을 제외시키면 된다.

그리스,
네덜란드, 노르웨이,
덴마크, 독일,
라트비아, 루마니아, 룩셈부르크, 리투아니아, 리히텐슈타인,
몰타,
벨기에, 불가리아,
스웨덴, 스페인, 슬로바키아, 슬로베니아,
아이슬란드, 아일랜드, 에스토니아, 북아일랜드(영국), 오스트리아, 이탈리아,
체코,
크로아티아, 키프로스,
포르투갈, 폴란드, 프랑스, 핀란드,
헝가리

3. 2번 내용을 저장하고 난 뒤 다시 제출해보면 오류가 사라진 것을 확인 가능하며 심사 제출 가능해진다!

국가 제외 건 때문에 혹시나 심사가 오래 걸리지 않을까 걱정했지만

오후 4시쯤 제출했는데, 당일에 심사 통과되어서 다음날 무리없이 배포할 수 있었다

글 다시 쓰기 시작

남 희 — Tue, 24 Feb 2026 12:32:33 +0900

습관을 만들기 위한 낮은 접근성 만들기

1. 접근이 쉬울 것

- 휴대폰에도 티스토리 접근 경로를 만들 것

2. 생각나는 대로 적을 것

- 정제하고 지우면 안 써지니 그냥 일단 생각나는 대로 적을 것, 이게 뭐야 싶은 글은 미래의 내가 알아서 정돈해 줄 거임

3. 적고 싶은 게 생겼다면 핵심 내용만 적어서 완결하는 것에 집중할 것

- 중요한 건 같은 이슈나 고민이 생긴 사람에게 정보를 전달하는 것

4. 적을 때 카테고리가 바로 분류되지 않는다면, 일단 카테고리 없음으로 넣을 것

- 내용이 쌓이면 제자리를 찾아가게 될 것

5. 글을 보지 않고 내 손으로 적어지는 내용만 적을 것

- 단순히 글, 문장을 복사하거나, 복사한 글로 요약하는 글을 쓰지 않을 것

공개로 적는 이유

1. 지금 위치에 있는 게 매일의 습관으로 이뤄졌다는 걸 알기 위해, 남겨야만 미래의 내가 올챙이 적을 알고, 알아야만 남에게 전달도 잘 할 수 있다

2. 모르고 하찮은 나를 있는 그대로 마주하기 위해, 성장하는 사람은 이를 잘 받아들인다

3. 같은 길을 걷는 사람들이 참고하고 확신을 얻을 수 있기를 바라는 마음에서 공개로 적어보고자 한다

99클럽 코테 스터디 40일차 TIL + 오늘의 학습 키워드

남 희 — Fri, 30 Aug 2024 18:38:23 +0900

☑️ Leetcode: 62. Unique Paths

https://leetcode.com/problems/unique-paths/description/

☑️ Code (DP)

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];

        // 1. init the base cases
        for (int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }
        for (int i = 0; i < n; i++) {
            dp[0][i] = 1;
        }

        // 2. fill the DP table
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }

        return dp[m - 1][n - 1];
    }
}

99클럽 코테 스터디 39일차 TIL + 오늘의 학습 키워드

남 희 — Fri, 30 Aug 2024 10:51:21 +0900

☑️ 문제: 광물 캐기

https://school.programmers.co.kr/learn/courses/30/lessons/172927

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

☑️ 풀이

import java.util.*;

class Solution {
    int[][] energy = {
        { 1, 1, 1 },
        { 5, 1, 1 },
        { 25, 5, 1 }        
    };
    Map<String, Integer> mineralMap = new HashMap<>();
    
    int answer;
    
    public int solution(int[] picks, String[] minerals) {        
        // 1. init
        mineralMap.put("diamond", 0);
        mineralMap.put("iron", 1);
        mineralMap.put("stone", 2);        
            
        answer = Integer.MAX_VALUE;
        int totalPicks = 0;
        for (int i = 0; i < picks.length; i++) {
            totalPicks += picks[i];
        }
        
        // 2. dfs
        int[] usedPicks = new int[totalPicks];
        dfs(picks, minerals, usedPicks, totalPicks, 0);
        
        return answer;
    }
    
    void dfs(int[] picks, String[] minerals, int[] usedPicks, int totalPicks, int count) {
        if (count == totalPicks) {
            answer = Math.min(getTotalEnergy(minerals, usedPicks), answer);
        }
        
        for (int i = 0; i < picks.length; i++) {
            if (picks[i] > 0) {
                usedPicks[count] = i;
                picks[i]--;
                dfs(picks, minerals, usedPicks, totalPicks, count + 1);
                picks[i]++;
            }
        }
    }
    
    int getTotalEnergy(String[] minerals, int[] usedPicks) {
        int totalEnergy = 0;
        int usedPickIndex = 0;
        for (int i = 0; i < minerals.length; i += 5) {
            if (usedPickIndex >= usedPicks.length) {
                break;
            }
            
            for (int j = i; j < i + 5; j++) {
                if (j >= minerals.length) {
                    break;
                }
                int mineralIndex = mineralMap.get(minerals[j]);
                totalEnergy += energy[usedPicks[usedPickIndex]][mineralIndex];
            }
            usedPickIndex++;
        }
        return totalEnergy;
    }
}

99클럽 코테 스터디 38일차 TIL + 오늘의 학습 키워드

남 희 — Thu, 29 Aug 2024 10:56:19 +0900

☑️ 문제: 디펜스 게임

https://school.programmers.co.kr/learn/courses/30/lessons/142085

프로그래머스

programmers.co.kr

☑️ Code

import java.util.PriorityQueue;
import java.util.Collections;

class Solution {

    public int solution(int n, int k, int[] enemy) {
        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());

        int answer = 0;
        for (int e : enemy) {
            pq.offer(e);
            answer++;
            n -= e;
            if (n < 0) {
                if(k==0){
                    return answer - 1;
                }
                n = n + pq.poll();
                k--;
            }
        }

        return enemy.length;
    }
}

99클럽 코테 스터디 37일차 TIL + 오늘의 학습 키워드

남 희 — Wed, 28 Aug 2024 10:54:59 +0900

☑️ 문제: 부등호

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

☑️ Code

import java.util.*;

public class Main {
    static int N;
    static char[] operators;
    static boolean[] used = new boolean[10];
    static ArrayList<Long> results = new ArrayList<>();

    public static void main(String args[]) {
        input();
        backtracking(0, 0);
        
        Collections.sort(results);
        System.out.println(results.get(results.size() - 1));
        System.out.println(results.get(0));
    }
    
    static void backtracking(int depth, long num) {
        if (depth == N + 1) {
            results.add(num);
            return;
        }
        
        for (int i = 0; i <= 9; i++) {
            if (!used[i]) {
                used[i] = true;
                backtracking(depth + 1, num * 10 + i);
                used[i] = false;
            }
        }
    }
    
    static boolean check(char a, char b, char op) {
        if (op == '<') {
            return a < b;
        }
        if (op == '>') {
            return a > b;
        }
        return false;
    }
    
    static void input() {
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        operators = new char[N];
        for (int i = 0; i < N; i++) {
            operators[i] = sc.next().charAt(0);
        }        
    }
}

99클럽 코테 스터디 36일차 TIL + 오늘의 학습 키워드

남 희 — Tue, 27 Aug 2024 00:05:14 +0900

☑️ 문제: 전력망을 둘로 나누기

https://school.programmers.co.kr/learn/courses/30/lessons/86971

프로그래머스

programmers.co.kr

☑️ Code

오늘은 설계는 어렵지 않았어서, 다른 사람 풀이를 보면서 코드를 다듬고 좋은 건 참고하는 것에 집중했다.
(확실히 DFS가 코드가 짧아져서 가독성이 좋아지는 것 같다.)

class Solution {
    int min;
    boolean[][] connect;
    boolean[] visited;
    
    public int solution(int n, int[][] wires) { 
        // 1. init
        min = n;
        connect = new boolean[n + 1][n + 1];
        visited = new boolean[n + 1];
        for (int[] wire : wires) {
            int w1 = wire[0];
            int w2 = wire[1];
            connect[w1][w2] = connect[w2][w1] = true;
        }
        
        // 2. search
        dfs(1, n);
        
        return min;
    }
    
    int dfs(int v, int n) {
        visited[v] = true;
        int child = 1;
        for (int w = 1; w <= n; w++) {
            if (!visited[w] && connect[v][w]) {
                visited[w] = true;
                child += dfs(w, n);
            }
        }
        min = Math.min(min, Math.abs(child - (n - child)));
        return child;
    }
}

99클럽 코테 스터디 35일차 TIL + 오늘의 학습 키워드

남 희 — Sun, 25 Aug 2024 22:20:17 +0900

☑️ 문제: 게임 맵 최단거리

https://school.programmers.co.kr/learn/courses/30/lessons/1844

프로그래머스

programmers.co.kr

☑️ Code: BFS 풀이

import java.util.*;

class Solution {
    public int solution(int[][] maps) {                
        // 0. init data  
        int n = maps.length;
        int m = maps[0].length; 
        Queue<Integer> queue = new LinkedList<>();
        int[][] dist = new int[n][m];

        // 1. push first point
        int x = 0, y = 0;
        queue.offer(x);
        queue.offer(y);
        dist[y][x] = 1;
        
        // 2. bfs
        int answer = -1;
        int nx, ny;
        int[] dx = { 0, 0, 1, -1 };
        int[] dy = { 1, -1, 0, 0 };
        while (!queue.isEmpty()) {
            x = queue.poll();
            y = queue.poll();
            if (x == m - 1 && y == n - 1) {
                answer = dist[y][x];
                break;
            }
            
            for (int i = 0; i < 4; i++) {
                nx = x + dx[i];
                ny = y + dy[i];
                if (!isOutBound(nx, ny, n, m) && maps[ny][nx] == 1 && dist[ny][nx] == 0) {
                    queue.offer(nx);
                    queue.offer(ny);
                    dist[ny][nx] = dist[y][x] + 1;
                }
            }
        }
        
        return answer;
    }
    
    boolean isOutBound(int x, int y, int n, int m) {
        return y < 0 || y >= n || x < 0 || x >= m;
    }
}

99클럽 코테 스터디 34일차 TIL + 오늘의 학습 키워드

남 희 — Sat, 24 Aug 2024 21:41:52 +0900

☑️ 문제: 타겟 넘버

https://school.programmers.co.kr/learn/courses/30/lessons/43165

프로그래머스

programmers.co.kr

☑️ Code: 재귀를 사용

class Solution {
    int answer = 0;
    
    public int solution(int[] numbers, int target) {
        recursiveSum(0, 0, numbers, target);
        return answer;
    }
    
    void recursiveSum(int index, int sum, int[] numbers, int target) {
        if (index == numbers.length) {
            if (sum == target) {
                answer++;
            }
            return;
        }
        
        // 현재 index의 숫자를 더하기
        sum += numbers[index];
        recursiveSum(index + 1, sum, numbers, target);
        sum -= numbers[index];

        // 현재 index의 숫자를 빼기
        sum -= numbers[index];
        recursiveSum(index + 1, sum, numbers, target);
        sum += numbers[index];
    }
}