회계를 정통이 아닌 책으로 배우다

지금 개발 하는 분야가 돈인만큼 회계 공부를 시작했다. 물론 나중에 기회가 생기면 자격증도 따고 조금더 상세하고 공부하긴 하겠지만 지금은 가볍게 책을 읽어나가면서 회계에서쓰는 단어나 조금 익숙해지는게 필요할것 같다.


첫번째 보고 있는 책
- 이것이 실전 회계다. ( chapter1 읽고있는데 3번정도 보고 다른책으로 넘어가야겠다. )

clean code 1장, 2장

책을 읽고 개인적으로 내용을 정리합니다.

요약

서문
- 과거의 프로그래밍과 현재의 프로그래밍이 크게 차이점이 없다.

1장
- 시간이 없다고 코드 리팩토링을 나중으로 미루면 안된다.
- 좋은 구조가 아니면 계속 반복해서 소프트웨어를 출시하게 되는 경우 개발자도 많이 필요하고 업무 효율도 계속 줄어듬

2장
- 범하기 쉬운 실수1
  - 중요하지도 않고, 긴급하지도 않은 것을 중요하고, 긴급함으로 격상시키는 일
- 좋은 아키텍쳐를 위해 투쟁하라
- 아키텍쳐를 후순위로 두지 마라
  - 개발하는데 더 시간이 많이 걸릴수도 있다.

요즘 읽고 있는 책 ( 미래를 바꾼 아홉 가지 알고리즘 )

미래를 바꾼 아홉가지 알고리즘

2년전에 한번 도서관에서 빌렸었는데 다시 빌렸다.
대여기간이 11월 18일까지인데 지금 챕터 2개를 읽었음.
- 오류 정정 코드
  - 반복 기법
  - redundant 기법
  - checkSum 기법

- 데이터 압축
  - 비손실 압축
    - 여기서는 공짜 점심이라고 표현한다.
    - hamming code , zip등 압축전과 압축후가 동일
  - 손실압축
    - JPEG가 대표적인 예
    - 압축을 하고 복구를 하게 되면 전과 후가 다름



18일전까지 꾸준히 읽어야 겠다.

palindrome

• DP가 약하기도하고 공부도 하고 내용도 복습할겸 정리합니다.
• 기본에서 true 와 false말고 숫자로 표현하면 응용이 가능하다.
• 참고 링크 https://www.geeksforgeeks.org/longest-palindrome-substring-set-1/

dp 문제를 푸는 나름대로의 방법

• DP 에서 row와 column에 어떤값을 정확하게 넣어야 할지가 분명하게 서지 않을때 그림을 그리는것은 도움이 된다.

문제

• 여러개의 특정 포지션에서 해당 substring이 palindrome인지 체크 하는 로직을 만드세요
• left = 시작 지점 right = 끝 지점
• ex) str = “abad”

풀이

• T = true, F = false로 간주한다.
• table[left][right]에 대한 값을 담을 수 있는 table을 만들고 값을 채워나간다.
• left == right 같을때는 T 로 셋팅
• left != right
  • left +1 <= right-1 ( size가 3이상인 경우)
    • str[left] == str[right] && table[left+1][right-1] 인경우 table[left][right] T 셋팅
  • left +1 > right-1 ( size 가 2인경우 )
    • str[left] == str[right] 인 경우 table[left][right] T 셋팅

사이즈가 1인경우

사이즈가 2이고 left = 0, right =1 인경우

사이즈가 3이고 left = 0 right =2 인경우

코드

String s = "abac";
boolean[][] table = new boolean[s.length()][s.length()];
for(int i=0; i<s.length(); i++){
    table[i][i] = true;
}
for(int size=2; size<s.length(); size++){
    for(int left=0; left<s.length(); left++){
        int right= left+size-1;
        if(right >= s.length()){
            continue;
        }
        if( size == 2){
            table[left][right] = s.charAt(left) == s.charAt(right);
        }else{
            table[left][right] = s.charAt(left) == s.charAt(right) && table[left+1][right-1];
        }
    }
}

Async Await 사용할때 3가지만 알면 모든게 해결됨

1. async function은 promise 를 리턴함
2. promise는 then이나  await 로 기다림
3. await는 async 안에서만 사용한다.

575. distribute candies

https://leetcode.com/problems/distribute-candies/

• 처음 생각해낸 방법은
  두개의 priority qeue 를 생성해서 하나는 asc, 하는 desc 로 생성
  sister 가 asc에서 한개씩 빼고, brother가 desc에서 큰 순으로 하나씩 빼다보면 최대 개수가 나올것 같다고 생각이 들었음.

• 코딩하기 귀찮아서 다른 방법 생각해보니 유니크한 사탕의 종류의 개수에 따라서 간단히 풀수 있었음.

• O(N)

• 종류개수 > length/2 return length/2, else 종류개수

Runtime: 14 ms, faster than 96.34% of Java online submissions for Distribute Candies.

class Solution {
    public int distributeCandies(int[] candies) {
        int [] map = new int[200001];
        int kinds = 0;
        for(int i=0; i<candies.length; i++){
            if(map[candies[i]+100000] == 0){
                kinds ++;
            }
            map[candies[i]+100000]++;
        }
        int maxLen = candies.length/2 ;
        return kinds <= maxLen ? kinds : maxLen;
    }
}

53. Maximum Subarray

https://leetcode.com/problems/maximum-subarray/

Runtime: 1 ms, faster than 85.87% of Java online submissions for Maximum Subarray.

O(N) 코드

class Solution {
    public int maxSubArray(int[] nums) {
        
        int max = nums[0];
        int pre = nums[0];
        for(int i=1; i<nums.length; i++){
            if(pre >0){
                pre += nums[i];
                max = Math.max(pre, max);
            }else{
                pre = nums[i];
                max = Math.max(pre, max);
            }
        }
        return max;
    }
}

Divide and Conquer

2ms

• ide 사용하고 debugging하는데 시간이 오래 걸림
• 2개또는 1개로 자른다.
• 데이터를 머지할때 3가지 데이터를 구한다
  • leftMost = 왼쪽 0번째 인덱스 부터 시작해서 가장 큰 sum을 구한다.
  • rightMost = 오른쪽 0번째 인덱스부터 왼쪽으로 가장 큰 sum을 구한다.
  • full 은 머지한전체 sum, leftMost와 rightMost를 구하기 위해서 필요함.

public class Solution {

    int max =0;
    int[] nums ;
    public int maxSubArray(int[] nums) {
        max = nums[0];
        this.nums = nums;
        divideAndConquer(0, nums.length-1);

        return max;
    }

    public Data divideAndConquer(int start, int end){
        Data data = new Data();
        if(start == end){
            data.full = nums[start];
            data.leftMost = nums[start];
            data.rightMost = nums[start];
            max = Math.max(max ,data.full);
            return data;
        }else if (start == end-1){
            data.full = nums[start] + nums[end];
            data.leftMost = Math.max(nums[start], nums[start] + nums[end]);
            data.rightMost = Math.max(nums[end], nums[start] + nums[end]);
            max = Math.max(max ,data.leftMost);
            max = Math.max(max ,data.rightMost);
            return data;
        }
        int mid = (end-start)/2 + start;
        // left
        Data left = divideAndConquer(start, mid);

        // right
        Data right = divideAndConquer(mid+1 ,end);
            
        if(left.rightMost >0 || right.leftMost >0){
            max = Math.max((Math.max(left.rightMost, 0) + Math.max(right.leftMost, 0)), max);
        }
        
        data.leftMost = Math.max(left.leftMost, left.full + right.leftMost);
        data.rightMost = Math.max(right.rightMost, right.full + left.rightMost);
        data.full = right.full + left.full;
        max = Math.max(max, data.leftMost);
        max = Math.max(max, data.rightMost);
        max = Math.max(max, data.full);
        return data;
    }

  
}

class Data {
    int leftMost;
    int full;
    int rightMost;
}