우유

직장을 다니면서 월급만 가지고는 부족하다고 생각하시는 분 들이 요즘 너무나도 많은게 현실인데요
가장 보편적이고 쉽게 접근 할 수 있는 쿠팡 파트너스 가입 방법 알려드리겠습니다!

가입 방법

쿠팡 파트너스 사이트에 접속합니다.

https://partners.coupang.com/

여기서, 개인과 사업자를 선택하는 기준은 다음과 같습니다.

- 개인 회원
: 개인회원은 실명 확인만으로 간단하게 가입이 가능합니다.
: 제세공과금 등을 수입에서 공제하고 지급하여 별도의 세금 처리 절차가 없습니다.

- 사업자
: 사업자일 경우 사업자등록증 사본을 제출해야 합니다.
: 제세공과금 등을 수입에서 공제하고 지급하지 않아 별도의 세금 처리 절차가 필요합니다.

따라서, 보통 개인 회원으로 선택합니다.

그 다음으로는 본인이 쿠팡 파트너스 활동을 진행 할 사이트 주소를 적습니다.
기입한 주소 이외에 사이트에서 활동할 경우 수익 합산이 불가할 수 있습니다.

그리고 나머지 정보들을 적어줍니다.

사이트 정보 기입 완료 후,
추천인 코드를 적는 칸이 있습니다.

추천인 코드를 기입하면 30일간 수익률이 1% 상승하여 4%의 수익률이 됩니다.
추천인 코드를 입력한 사람과 추천인 모두에게 적용되는 혜택입니다.
얼마 안된다고 생각하실수 있지만 누적되면 굉장히 큰 금액입니다.

혹시 추천인 코드가 없다면, 제 코드를 사용해 주시면 감사하겠습니다. :)
공란으로 두셔도 가입과는 무관합니다.

- 추천인 코드 

추천인까지 마치셨다면 다음을 클릭합니다.

이제, 단순 정보 기입만이 남았습니다.
본인의 이름, 주민번호, 연락처, 입금받을 계좌 정보를 기입합니다.

계좌 인증까지 마치셨다면 다음을 클릭합니다.

ㄷ. 계정 생성 완료

이제 계정 생성이 완료되었습니다.
간단하지만 긴 과정 거쳐오느라 고생하셨습니다.
이제, 사이트에서 광고가 가능합니다.
그리고 쿠팡 파트너스의 승인이 완료되면 수익을 창출할 수 있습니다.

4. 승인 절차

쿠파스 계정 승인 절차는 이와 같습니다.

1. 계정 생성 
2. 광고 시작
3. 최종 승인: 누적 판매 금액이 15만원 이상 발생하면 채널 검토 후 최종 승인이 이루어집니다.

하지만 최종 승인에 반려된 상태에서도 수익 집계는 정상적으로 진행됩니다.

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

코드 설명

정점, 간선이 주어진 입력 배열에서 인접리스트를 만들어서
BFS 로 가장 먼 거리를 구했다.DFS와 BFS는 많이 풀면 풀수록 다양한 개념들이 많이 나온다.
다 이해했다고 생각하지말고 계속 여러번 반복해서 풀어봐야겠다.

import java.util.*;

class Solution {
    
    static int[] visited;
    static ArrayList<ArrayList<Integer>> al;
    
    public int solution(int n, int[][] edge) {
        int answer = 0;
        
        al = new ArrayList<>();
        visited = new int[n + 1];
        
        // 정점이 6개까지 있으므로 0~6으로 선언해야되는거 주의
        for(int i = 0; i <= n; i++)
            al.add(new ArrayList<Integer>());
        
        for(int i = 0; i < edge.length; i++){
            al.get(edge[i][0]).add(edge[i][1]);
            al.get(edge[i][1]).add(edge[i][0]);
        }
        
        BFS(1);
        
        Arrays.sort(visited);
        
        int max = visited[n];
        
        for(int i = 0; i <= n; i++){
            if(max == visited[i])
                answer++;
        }
        
        return answer;
    }
    
    public static void BFS(int V){
        Queue<Integer> qu = new LinkedList<>();
        
        qu.add(1);
        visited[1] = 1;
        
        while(!qu.isEmpty()){
            int cur = qu.poll();
            
            for(int next : al.get(cur)) {
                
                if(visited[next] == 0){
                    visited[next] = visited[cur] + 1;
                    qu.add(next);
                }
            }
        }
    }
}

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

코드 설명

최솟값을 만들기 위해서는 가장 큰수와 작은수를 곱해주어야 하기 때문에
문자열 A와 문자열 B를 오름차순, 내림차순으로 각각 정렬해서
같은 인덱스끼리 곱해주려고 했으나,,
Arrays.sort 함수의 내림차순 정렬이 기억이 나지않아서
편법으로 저렇게 처리했다.

자바 Int 내림차순 정렬은 이렇게 활용하면 된다. 기억하자.. ★

Integer[] arr3 = Arrays.stream(arr).boxed().toArray(Integer[]::new);
Arrays.sort(arr3, Collections.reverseOrder());

import java.util.*;

class Solution {
    public int solution(int[] A, int[] B) {
        int answer = 0;

        Arrays.sort(A);
        Arrays.sort(B);

        for (int i = 0; i < A.length; i++) {
            answer += A[i] * B[B.length - i - 1];
        }

        return answer;
    }
}

오늘 방문한 곳은
을지로 3가역에 위치한
부타이제2막!

골목길에 위치해서 찾기 좀 어려울수도 있습니당

점심시간에는 웨이팅이 있는 편이기때문에
일찍 가야되요!

매장이 좁아서
일행이 같이 오지않으면
입장을 시켜주지 않아 기다려야되는 단점이 있어요ㅠㅠ

메인메뉴는 마제소바!
목살차슈는 기본으로 추가가 되있지않기 때문에
따로 추가를 해주어야 된다고 해요!

처음 이렇게 나오는데
노른자랑 같이 비벼서 먺으면
핵존맛탱!!

밥까지 비벼먹을수있어용

히레카츠와 후토마키도 정말 맛있어요ㅠ
어느정도 웨이팅이 있긴하지만
기다려볼만한 맛

완전 강추강추!!


영업시간
월-토
11:00 - 21:00
14:30 - 17:30 브레이크타임
14:00, 20:30 라스트오더

서울 중구 충무로5길 6-1 1층

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

코드 설명

1. 문자열을 split 함수로 분리
2. String 배열을 Integer 형 배열로 바꿔서 ArrayList에 추가
3. Collections.sort 함수를 활용해서 오름차순으로 정렬
4. ArrayList에서 첫번째 인덱스(최소값) , 마지막 인덱스(최대값)을 꺼내 StringBuilder에 append

import java.util.*;

class Solution {
    public String solution(String s) {
        ArrayList<Integer> al = new ArrayList<>();
        StringBuilder sb = new StringBuilder();
        
        String arr[] = s.split(" ");
        
        for(int i = 0; i < arr.length; i++){
            al.add(Integer.parseInt(arr[i]));
        }
        
        Collections.sort(al);
        
        sb = sb.append(al.get(0) + " ");
        sb = sb.append(al.get(al.size()-1));
        
        return sb.toString();
    }
}

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

코드 설명

끝말잇기 규칙을 체크해야 되는 로직을 구현해야한다.
1. 마지막 사람이 말한 단어에서 마지막 문자와 현재 사람이 말한 단어의 첫번째 문자가 일치하는지 (startsWith 함수,
마지막 단어를 순서대로 꺼내기 위해서 Stack을 활용)
2. 현재 말한 사람의 단어가 이전에 중복된 적이 있는지 (HashMap)
각각의 조건을 체크해 준 후 이상이 없으면 stack과 map에 각각 push, put 해주었고,
조건이 거짓 판별이 나면 몇번 째 사람인지와 몇바퀴 돌았는지 체크해서 각각 answer 배열에 넣어주었다.

import java.util.*;
class Solution {
    public int[] solution(int n, String[] words) {
        int[] answer = new int[2];

        HashMap<String, Integer> map = new HashMap<>();
        Stack<String> stack = new Stack<>();

        for (int i = 0; i < words.length; i++) {

            if (!stack.isEmpty()) {
                String last_word = stack.peek();
                if (words[i].startsWith(last_word.substring(last_word.length() - 1, last_word.length())) 
                        && !map.containsKey(words[i])) {
                    stack.push(words[i]);
                    map.put(words[i], i % n);
                } else {
                    answer[0] = i % n + 1;
                    answer[1] = i / n + 1;
                    break;
                }
            } else {
                stack.push(words[i]);
                map.put(words[i], i % n);
            }
        }
        
        return answer;
    }
}

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

코드 설명

Stack 을 활용할 수 있는 문제였다.
stack이 비어있는 것을 체크하고
')' 가 들어올때 '(' 가 없으면 break를 걸어
false 를 return 했다.

import java.util.*;

class Solution {
    boolean solution(String s) {
        boolean answer = true;

        Stack<Character> stack = new Stack<>();
        
        for(int i = 0; i < s.length(); i++){
            char ch = s.charAt(i);
            
            if(ch == '(') {
                stack.push('(');
            }
            else if(ch == ')'){
                if(!stack.isEmpty()){
                    if(stack.peek() == '('){
                        stack.pop();
                    }
                }
                else {
                    answer = false;
                    break;
                }                
            }
        }
        
        if(!stack.isEmpty())
            answer = false;
        
        return answer;
    }
}

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

코드 설명

문자열에서 첫번째 문자는 항상 대문자
두번째 문자는 항상 소문자
마지막은 공백 추가
이 로직 대로 StringBuilder 에 append 해주었고,

시간을 생각보다 소비했던건 테스트케이스 8번에서 "3people unFollowed me " 이런식으로
입력값 s 문자열에도 마지막 공백이 추가되어서 이런 경우를 따로 if문 처리해서 따로 sb.append(" ")
처리를 해주어야 했다.

class Solution {
    public String solution(String s) {
        String[] arr = s.split(" ");
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if (arr[i].length() == 0) {
                sb.append(" ");
            } else {
                sb = sb.append(arr[i].substring(0, 1).toUpperCase());
                sb = sb.append(arr[i].substring(1, arr[i].length()).toLowerCase());
                sb = sb.append(" ");
            }
        }

        sb.delete(sb.length() - 1, sb.length());

        if (s.substring(s.length() - 1, s.length()).equals(" ")) {
            sb.append(" ");
        }
        
        return sb.toString();
    }
}

코드 설명

문제 포인트는
1. 3개의 벽을 세울 수 있는 모든 경우의 수를 구해서 새롭게 복사한 COPY_MAP을 각각 만드는 것
여기서 세울 수 있는 경우의 수가 엄청 많은데 이를 하나하나 다 BFS를 돌려봐야 한다.
2. 1번에서 새운 MAP 에서 BFS 돌려서 안전거리의 영역을 카운트해서 그 안전거리의 최대값을 출력

DFS와 BFS 를 동시에 연습할수 있는 아주 좋은 문제였다.
 

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

public class Main {

    static int N, M;
    static int[][] map;
    static int[] dy = {1, 0, -1, 0};
    static int[] dx = {0, 1, 0, -1};
    static int ans = Integer.MIN_VALUE;

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

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

        map = new int[N][M];

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

        DFS(0);

        System.out.println(ans);
    }

    public static void DFS(int cnt) {
        if (cnt == 3) {
            BFS();
            return;
        }

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (map[i][j] == 0) {
                    map[i][j] = 1;
                    DFS(cnt + 1);
                    map[i][j] = 0;
                }
            }
        }
    }

    public static void BFS() {
        // 벽을 새로 새울떄마다 배열 초기화
        int[][] copy_map = new int[N][M];

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                copy_map[i][j] = map[i][j];
            }
        }
        Queue<Node> qu = new LinkedList<>();

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (copy_map[i][j] == 2) {
                    qu.add(new Node(i, j));
                }
            }
        }

        while (!qu.isEmpty()) {
            Node curNode = qu.poll();

            for (int i = 0; i < 4; i++) {
                int ny = curNode.y + dy[i];
                int nx = curNode.x + dx[i];

                if (ny < 0 || nx < 0 || N <= ny || M <= nx) continue;

                if (copy_map[ny][nx] == 0) {
                    copy_map[ny][nx] = 2;
                    qu.add(new Node(ny, nx));
                }


            }

        }
        int cnt = 0;

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (copy_map[i][j] == 0) {
                    cnt++;
                }
            }
        }
        ans = Math.max(cnt, ans);
    }


    public static class Node {
        int y;
        int x;

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

}

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

코드 설명

테트리스의 모양처럼 생긴 블록들이 알고보면 DFS의 방향대로 탐색할때의 모양이라는 것을 알아낼 수 있었다.
DFS를 visited배열을 true 해주면서 depth가 4일때까지 돌리고 빠져나오면서 visited 배열을 false 해주는 백트래킹 방식으로 구현하였다.

여기서 핵심인 부분은 'ㅏ,ㅗ,ㅜ,ㅓ' 에 대한 블록을 어떻게 처리해줄까였는데
나는 cnt == 2 일때 arr[ny][nx] 의 값을 더해준 뒤 다른 ny,nx가 아닌 다른 방향으로 DFS를 한번 더 돌려서
sum 값을 계산하였다.

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

public class Main {

    static int N, M;
    static int[][] arr;
    static boolean[][] visited;
    static int[] dy = {1, -1, 0, 0};
    static int[] dx = {0, 0, 1, -1};
    static int ans = Integer.MIN_VALUE;

    public static void main(String[] agrs) throws IOException {
        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 int[N][M];
        visited = new boolean[N][M];

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

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                visited[i][j] = true;
                DFS(i, j, 0, 0);
                visited[i][j] = false;
            }
        }
        System.out.println(ans);
    }

    public static void DFS(int y, int x, int sum, int cnt) {
        if (cnt == 4) {
            ans = Math.max(sum, ans);
            return;
        }

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

            if (ny < 0 || nx < 0 || N <= ny || M <= nx)
                continue;

            if (visited[ny][nx])
                continue;

            if (cnt == 2) {
                visited[ny][nx] = true;
                DFS(y, x, sum + arr[ny][nx], cnt + 1);
                visited[ny][nx] = false;
            }

            visited[ny][nx] = true;
            DFS(ny, nx, sum + arr[ny][nx], cnt + 1);
            visited[ny][nx] = false;
        }

    }
}