BLOG :||

class Solution {
    public int solution(String name) {
        int answer = 0;
        int nameLen = name.length();
        boolean[] changed = new boolean[nameLen];
        int tmp = 0;
        int trueCount = 0;
        for(int i = 0; i<nameLen;++i) {
            if(name.charAt(i) != 'A') {
                tmp = name.charAt(i)-'A';
                if(tmp < 13)
                    answer += tmp;
                else 
                    answer += (26-tmp);
                changed[i] = true;
                trueCount++;

            }
        }
        changed[0] = false;
        trueCount--;
        
        int min = nameLen;
        int minIndex = -1;
        //0,1,2,3
        //4-3-cursor = 1
        //4-2-cursor = 2
        //4-1-cursor = 3
        // 
        int cursor = 0;
        int distance = 0;
        while(trueCount > 0) {
            min = nameLen;
            minIndex = -1;
            
            for(int i = 0; i<nameLen;++i) {
                if(changed[i] == true) {
                    distance = (cursor > i) ? cursor-i:i-cursor;
                    if(cursor < i) {
                        distance = (nameLen-distance < distance) ? nameLen-distance : distance;
                    }
                    if(min > distance) {
                        min = distance;
                        minIndex = i;
                    }
                }
            }
            changed[minIndex] = false;
            answer += min;
            trueCount--;
            cursor = minIndex;
            
        }
        
        return answer;
    }
}

아 이게 어떻게 레벨2짜리 문제인건지..;;

예전에 문제를 풀었을 때는 글자를 바꾸고 한 칸 옮기고 글자를 바꾸고 한 칸 옮기는 식으로 했었는데 책을 본 효과인지는 모르겠지만.. 글자가 다른 경우를 미리 다 처리하고 나서 옮기는 것에 대해서만 고려할 수 있도록 코드를 짜보니 확실히 깔끔해졌다.

다만 테스트케이스 11에서 틀렸다고 나오는데 다른 사람들 질문 내용을 봐도 감이 안온다. 그리디 알고리즘이라고 할 때 가장 가까운 값으로 이동을 하는 것 외에 고려할게 없을텐데.. 문제가 약간 이상하다고 생각해서 여기까지 하고 넘긴다.

지금은 마땅히 생각나는 문제점을 못찾고 있으니 다음에 한 번 더 봐야겠다.

class Solution {
    public int solution(int n, int[] lost, int[] reserve) {
        int answer = 0;
        int[] clothes = new int[n];
        for(int l : lost) {
            clothes[l-1]--;
        }
        for(int r : reserve) {
            clothes[r-1]++;
        }
        
        for(int i = 0; i<clothes.length;++i) {
            if(clothes[i] >0 && i > 0 && clothes[i-1] == -1) {
                clothes[i-1]++;
                clothes[i]--;
                System.out.println(i+ " "+ (i-1));
            }
            else if(clothes[i] > 0 && i+1 <clothes.length && clothes[i+1] == -1) {
                clothes[i+1]++;
                clothes[i]--;
                System.out.println(i+ " "+ (i+1));
            }
            /*
            if(clothes[i] > 0 && i+1 <clothes.length) {
                clothes[i+1]++;
                clothes[i]--;
            }*/
            
        }
        for(int i : clothes) {
            System.out.print(i);
            if(i >= 0)
                answer++;
        }
        return answer;
    }
}

처음 풀 때 어디서 꼬였었는데 넘겼다가 오늘 다시 풀어봤다.

clothes[]를 초기화하면 기본적으로 다 0이 들어가 있으므로 0을 옷을 1장 보유한 상태로 가정한다.

도둑맞은걸 빼고 여분을 더해준 뒤해 알고리즘이 시작된다.

왼쪽에서 오른쪽으로 진행될 예정이기 때문에 왼쪽을 우선적으로 빌려주고 왼쪽이 옷을 가지고 있을 경우, 오른쪽에 빌려주는 형태로 진행이 된다.

여분을 계속 우측으로 넘기면 좋지 않을까 싶었지만 옷은 없는 사람한테만 직접 빌려줘야 하나보다.

import java.util.*;
class Solution {
    public String solution(String number, int k) {
        String text = "0";
        int len = number.length();
        k = number.length()-k;
        Stack<String> s = new Stack<>();//stack을 어떻게 유추하나
        s.push(number.substring(0,1));
        for(int i = 1; i<len;++i) {
            while(s.size() > 0 &&Integer.parseInt(s.peek()) < Integer.parseInt(number.substring(i,i+1)) && s.size()-1+len-i >= k) {
                s.pop();
            }
            if(s.size() < k)//pop조건에서 제외되어도 사이즈에 따라 예외처리는 해야 한다.
                s.push(number.substring(i,i+1));
        }
        String t = "";
        while(s.size() > 0) {
            t= s.pop()+t;
        }
        while(true) {
            if(t.charAt(0) == '0')
                t = t.substring(1, t.length());
            else
                break;
        }
        return t;
    }
/*
    public String solution(String number, int k) {
        String text = "0";
        int val = -1;
        int max = getRemoveNumT(0,k,number, val);
        
        return Integer.toString(max);
    }
    public int getRemoveNumT(int originI, int k, String number, int max) {
        String tmp = "";
        for(int i = originI; i<number.length()-k+1;++i) {
            if(i == 0)
                tmp = number.substring(i+1, number.length());
            else {
                tmp = number.substring(0, i)+number.substring(i+1, number.length());
            }
            if(k == 1) {
            	if(max < Integer.parseInt(tmp))
            		max = Integer.parseInt(tmp);
            }
            else {
            	int t = getRemoveNumT(i, k-1, tmp, max);
            	if(t > max)
            		max = t;
            }
        }
		return max;
    }
*/
}

처음에 재귀로 했다가 효율성 테스트에서 시간 초과가 떴었다.

뭐가 문제일까 하면서 다른 사람이 질문한 내용을 봤는데 stack을 쓰면 좋다고 하는 글을 보고...

고민해보고 풀어보니까 감탄이 나오더라.

제외해야 되는 글자 수에 걸리지 않는 한에서

peek()보다 현재 값이 크면 값을 pop()하고 push()를 한다.

코딩테스트에서 문제만 푸는건 요새는 다들 하니까 이런 효율성을 찾으려고 해야 한다..

import java.util.*;
class Solution {
    public int solution(int[] people, int limit) {
        int answer = 0;
        if(people.length == 1)
            return 1;
        Arrays.sort(people);
        List<Integer> list = new ArrayList<>();
        for(int i = 0; i<people.length;++i)
            list.add(people[i]);
        int len = 0;
        int big = 0;
        while(list.size() > 0) {
            len = list.size();
            big = list.get(len-1);
            if(list.size() >1 && big+list.get(0) <= limit) {
                list.remove(list.size()-1);
                list.remove(0);
            }
            else {
                list.remove(list.size()-1);
            }
            answer++;
        }
        
        return answer;
    }
}

인원을 무게 순으로 정렬한다.

가장 무게가 나가는 사람이 가장 가벼운 사람을 태우지 못하면 배 하나 들고 나간다.

태울 수 있으면 태운다. 끝이다.

지금 생각해보니 저걸 list로 하지말고 deque를 쓰는게 좋았을텐데..

deque나 set이나 회사에서 잘 안쓰는 자료구조는 까먹을 때가 많아서 문제다.

import java.util.*;
class route implements Comparable<route>{
    int a;
    int b;
    int c;
    public route(int a, int b, int c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }
    @Override
    public int compareTo(route r) {
        if(a < r.a)
            return -1;
        else if(a > r.a)
            return 1;
        else {
            if(c < r.c)
                return -1;
            else if(c > r.c)
                return 1;
            else 
                return 0;
        }
    }
}

class Solution {
    public int solution(int[][] routes) {
        int answer = 0;
        List<route> list = new ArrayList<>();
        for(int i = 0; i<routes.length;++i) {
            list.add(new route(routes[i][0],i, 0));
            list.add(new route(routes[i][1],i, 1));
        }
        
        Collections.sort(list);
        //Queue<route> stack = new LinkedList<>();
        //int min = list.get(0).a;
        //int max = list.get(list.size()-1).a;
        //stack.add(list.get(0));
        int minC = -30001;
        for(int i = 0; i<list.size();++i) {
            route t = list.get(i);
            if(t.c == 1) {
                if(minC < routes[t.b][0]) {
                    answer++;
                    minC = t.a;
                }
            }
        }
        // c             d
        //-20 1 0, -18 3 0, -14 2 0, -13 3 1, -5 4 0, -5 2 1, -3 4 1, 15 1 1
        
        //들어온 뒤에 처음 나가는 것이 있을 경우 카메라를 놓는다.
        //나간 것이 존재하고 이후에 값이 들어올 경우, 
        return answer;
    }
}

취업한 이후로 블로그 쓰고 싶지 않았는데.. 계속 했어야 했다.

스터디 책에서 그리디 알고리즘이 나왔으므로 관련 문제를 올려본다.

키 포인트는 카메라를 두는 조건을 명확히 설정을 하고 이에 맞춰 코딩을 해야 한다.

일단 차량이 들어오고 나가는 각 시점을 시간 순으로 정렬을 해야겠다 싶어서 이를 따로 쪼개 list에 넣고 정렬을 했다.

차량 진출시점의 최소값이 -30000이었기 때문에 우선 카메라 위치의 min 값으로 -30001을 잡았고

for문을 돌리면서 list 내의 객체가 out일 때(c==1) 마지막 카메라의 위치가 차가 진입한 시점보다 이전이면 나갈때 카메라를 하나 세워주는 식으로 진행했다. 차량의 inout을 시간순으로 정렬했기 때문에 마지막 카메라 위치만 알면 되니까 값을 따로 기억하지는 않고 마지막 카메라 위치만 체크해서 풀면 꽤 간단했다.

그리디 알고리즘이 다 그런건 아니지만 이 챕터에서 보여준 예제들의 특징은 뭉터기로 잘라내는 법을 찾아내는 것.

import java.util.*;
public class main {
    public static void main(String[] args) {

        Solution s = new Solution();
        System.out.println("GridExample01: "+s.GridExample01(1260));
        System.out.println("GridExample01Guide: "+s.GridExample01Guide(1260));

        System.out.println("GridExample02_01: "+s.GridExample02_01(new int[]{5,8,3}, new int[]{2,4,5,4,6}));
        System.out.println("GridExample02_02: "+s.GridExample02_02(new int[]{5,8,3}, new int[]{2,4,5,4,6}));
        System.out.println("GridExample02Guide: "+s.GridExample02Guide(new int[]{5,8,3}, new int[]{2,4,5,4,6}));
        //02_01과 유사. 한번씩 덧셈을 하지 않고 뭉터기로 덧셈을 할 수 있는 조건을 찾아내는 것이 단축의 핵심
        System.out.println("GridExample02Guide02: "+s.GridExample02Guide(new int[]{5,8,3}, new int[]{2,4,5,4,6}));

        //03은 가이드와 직접 작성했던 것과 유사해서 가이드 생략
        System.out.println("GridExample03 val1: "+s.GridExample03(new int[][]{{3,1,2},{4,1,4}, {2,2,2}}));
        System.out.println("GridExample03 val2: "+s.GridExample03(new int[][]{{7,4,1,8},{3,3,3,4}}));


        System.out.println("GridExample04: "+s.GridExample04(25,5));
        //1씩 빼지 않고 나머지 차를 그대로 빼는 것이 핵심. k > n일 경우 빠지는 것도 중요.
        System.out.println("GridExample04Guide: "+s.GridExample04(25,5));
    }
}
class Solution {
    public int GridExample01(int n) {
        int n500 = n / 500;
        int n100 = (n%500) / 100;
        int n50 = (n%100) / 50;
        int n10 = (n%50) / 10;
        return n500+n100+n50+n10;
    }
    public int GridExample01Guide(int n) {
        int[] coin = new int[]{500,100,50,10};
        int count = 0;
        for(int c : coin) {
            count += n/c;
            n %= c;
        }
        return count;
    }
    public int GridExample02_01(int[] valid, int [] num) {
        Arrays.sort(num);
        int n = valid[0];
        int m = valid[1];
        int k = valid[2];
        int answer = 0;
        //수정부
        int p = 0;
        int first = num[num.length-1];
        int second = num[num.length-2];

        if(k > m)
            return m * first;

        if(k+1 <= m) {
            p = m/(k+1);
            m %= (k+1);
        }
        answer += p * (first * k + second);
        answer += m*first;
        return answer;
    }
    public int GridExample02_02(int[] valid, int [] num) {
        Arrays.sort(num);
        int n = valid[0];
        int m = valid[1];
        int k = valid[2];
        int answer = 0;
        int t = k;
        int i = num.length-1;
        while(m > 0) {
            if(t > 0) {
                answer += num[i];
                t--;
            }
            else {
                t = k;
                answer += num[i-1];
            }
            m--;
        }

        return answer;
    }
    public int GridExample02Guide(int[] valid, int [] num) {
        Arrays.sort(num);
        int answer = 0;
        int m = valid[1];
        int k = valid[2];
        int first = num[num.length-1];
        int second = num[num.length-2];
        while(true) {
            for(int t =0; t<k;t++) {
                if(m == 0)
                    break;
                answer += first;
                m--;
            }
            if(m == 0) {
                break;
            }
            answer += second;
            m--;
        }

        return answer;
    }
    public int GridExample02Guide02(int[] valid, int [] num) {
        Arrays.sort(num);
        int answer=0;
        int m = valid[1];
        int k = valid[2];
        int first = num[num.length-1];
        int second = num[num.length-2];

        int count = m / (k+1) * k;
        count += m % (k+1);
        answer += count * first;
        answer += (m-count) * second;
        return answer;
    }
    public int GridExample03(int[][] cards) {
        int answer = -1;
        for(int[] row : cards)
            Arrays.sort(row);
        for(int i = 0; i<cards.length;++i) {
            if(cards[i][0] > answer)
                answer = cards[i][0];
        }
        return answer;
    }
    public int GridExample04(int n, int k) {
        int answer = 0;

        while(n != 1) {
            if(n % k == 0) {
                n/=k;
                answer++;
            }
            else {
                n--;
                answer++;
            }
        }

        return answer;
    }
    public int GridExample04Guide(int n, int k) {
        int answer = 0;

        int target;
        while(true) {
            target = (n/k)*k;
            answer += (n - target);
            if(n < k) {
                break;
            }
            answer += 1;
            n /= k;
        }
        answer += (n-1);
        return answer;
    }
}

Map<String, Object> lstParam = new HashMap<String, Object>();

Map<String, Object> mapParam;
List<Map<String, Object>> dsBuildList;
List<Map<String, Object>> dsObjList;
List<Map<String, Object>> dsBuildMrtggList;
List<Map<String, Object>> dsPldgList;
List<Map<String, Object>> dsClauseList;
List<Map<String, Object>> dsLoanList;

lstParam.put("mapParam",mapParam);
lstParam.put("dsBuildList",dsBuildList);
lstParam.put("dsObjList",dsObjList);
lstParam.put("dsBuildMrtggList",dsBuildMrtggList);
lstParam.put("dsPldgList",dsPldgList);
lstParam.put("dsClauseList",dsClauseList);
lstParam.put("dsLoanList",dsLoanList);

일반적으로 Mybatis에 Parameter를 넣을 때, 보통 Map<String, Object>, List<Map<String, Object>>와 같은 형태로 집어 넣은 상태를 많이 봤었다.

복수의 List와 Map이 섞인 형태의 Parameter가 필요한 경우가 생길 수 있다.

한 번 Database를 건드릴 때, 일반적으로 하나의 테이블을 각각 Dao를 통해서 건드리게 되는 것이 일반적이지만 insert 도중, 에러가 발생하면 전체 롤백이 필요할 수 있기 때문이다.

다른 방법도 있겠지만 일단 앞에서 개발한 사람 것에 맞추는 것이 일반적이니까...

일단 Object가 최상위 Class 형태니까 위와 같이 하면 List든 Map이든 다 들어간다.

	<insert id="savePreLink" parameterType="java.util.Map">
             DECLARE
                 v_frid	         VARCHAR2(10);  -- 등록자
                 v_chng_val 	 VARCHAR2(10); -- 변경구분						
             BEGIN		    
                 v_frid	         := #{mapParam.FRID};
                 v_chng_val		 := #{mapParam.CHNG_TYPE};
                 
		    BEGIN
                        <foreach item="item" index="key" collection="dsBuildMrtggList" separator="">
                        v_row_03 := v_row_03 + 1;
                        INSERT INTO IF_BEN_HYU_CALC_SECT
                        (
                          SECTCD_NO
                        , SECTCD
                        , SECTMODYN
                        )
                        VALUES
                        (
                          v_row_03
                        , CASE 
                           WHEN #{item.MRTGG_CD} = 'T405' THEN '12'
                           WHEN #{item.MRTGG_CD} = 'U989' THEN '01'
                           WHEN #{item.MRTGG_CD} = 'W990' THEN '01'
                           WHEN #{item.MRTGG_CD} = 'T152' THEN '05'
                           WHEN #{item.MRTGG_CD} = 'T050' THEN '12'
                          END
                        , #{item.NOW_ROWTYPE}
                        );
                        </foreach>
		    END;
            
  ....
		    COMMIT;
		
		    EXCEPTION 
		        WHEN OTHERS THEN
		        	ROLLBACK;
		            RAISE_APPLICATION_ERROR(-20000, 'ERROR - '|| v_step);
		
		END;

	</insert>

코드를 다 올려선 안되기에 일부 삭제가 되었지만 위와 같이 Map에서 Map을 꺼내거나 foreach를 이용하여 List를 사용하는 식으로 사용할 수 있다.

처음엔 이런 내용이 검색해도 안보여서 뭔가 했는데 사실 이렇게 쓰면 안좋아서 쓰는 사람이 없어서 관련 내용이 없었던 것 같다.

this.fnDatasetEsbCall = function (dsData, dsEsbCall)
{
	dsEsbCall.copyData(dsData);
	dsEsbCall.clearData();
	for(var i = 0; i<dsData.rowcount;++i)
	{	
		if(true) {
			
			if(dsData.getColumn(i, "BF_ROWTYPE") == "BF")//"BF" 기존 DB에 존재하던 값을 의미
			{
				if(dsData.getRowType(i) == 4)//값이 변경된 경우. U(업데이트) 처리
				{
					dsEsbCall.addRow();
					dsEsbCall.copyRow(dsEsbCall.rowcount-1, dsData, i);
					dsEsbCall.setColumn(dsEsbCall.rowcount-1, "NOW_ROWTYPE", "U");
					dsEsbCall.setColumn(dsEsbCall.rowcount-1, "BF_ROWTYPE", dsData.getColumn(i, "BF_ROWTYPE"));
				}
				else//기존 값
				{
					dsEsbCall.addRow();
					dsEsbCall.copyRow(dsEsbCall.rowcount-1, dsData, i);
					dsEsbCall.setColumn(dsEsbCall.rowcount-1, "NOW_ROWTYPE", "N");
					dsEsbCall.setColumn(dsEsbCall.rowcount-1, "BF_ROWTYPE", dsData.getColumn(i, "BF_ROWTYPE"));
				}
			}
			else//신규 입력값
			{
				dsEsbCall.addRow();
				dsEsbCall.copyRow(dsEsbCall.rowcount-1, dsData, i);
				dsEsbCall.setColumn(dsEsbCall.rowcount-1, "NOW_ROWTYPE", "I");		
				dsEsbCall.setColumn(dsEsbCall.rowcount-1, "BF_ROWTYPE", dsData.getColumn(i, "BF_ROWTYPE"));
			}
		}
	}
	var delArr = dsData.getDeletedRowset();
	
	//삭제된 행 확인 후,  EsbCall에 추가.
	for(var i = 0; i<dsData.getDeletedRowset().length;++i)
	{
		var delRow = delArr[i];

		if(delRow.includes("BF"))
		{
			dsEsbCall.addRow();
			for(var j = 0; j<dsData.colcount;++j)
			{
				dsEsbCall.setColumn(dsEsbCall.rowcount-1, j, delRow[j]);
			}
			dsEsbCall.setColumn(dsEsbCall.rowcount-1, "NOW_ROWTYPE", "D");
		}
	}
	if(this.dsObjList==dsData) {

		var colArray = new Array("SPOP_1_VAL","SPOP_2_VAL","SPOP_3_VAL","SPOP_4_VAL","SPOP_5_VAL");

		for(var i = 0; i<dsEsbCall.rowcount; ++i) {
			
			var tFront = "BUILD_SN == '"+dsEsbCall.getColumn(i, "BUILD_SN")+"' && PURPS_SN == '"+dsEsbCall.getColumn(i, "PURPS_SN")+"'";
			
			//dsClauseList dataset의 복수의 값을 dsObjList에 넣기위한 조치
			var txt = new Array(tFront + " && SPOP_CD == 'T191'", "BGITDTARIFCAT1" 
							  , tFront + " && SPOP_CD =='T117'", "VGITDTARIFCAT3,GITDTARIFCAT5,GITDTARIFCAT4,GITDTARIFCAT6"
						      , tFront + " && (SPOP_CD == 'T750' || SPOP_CD =='T722')", "GITDTARIF7,GITDTARIF6,BGITDTARIFCAT6"
				         	  , tFront + " && (SPOP_CD == 'T855' || SPOP_CD =='T856')", "GITDTARIFCAT3"
					          , tFront + " && SPOP_CD == 'T559'", "ELAGDDCTAMT"
					          , tFront + " && SPOP_CD == 'T490'", "GITDTARIFCAT16,GITDTARIFCAT17,GITDTARIFCAT18,GITDTARIFCAT19,GITDTARIFCAT15"
					          , tFront + " && SPOP_CD == 'T406'", "RGITDTARIFCAT1"
					          , tFront + " && SPOP_CD == 'T594'", "GITDTARIFCAT10"
					          , tFront + " && SPOP_CD == 'T655'", "GITDTARIFCAT26,GITDTARIFCAT27,GITDTARIFCAT28,GITDTARIFCAT29"
					          );
			for(var j = 0; j<txt.length;j+=2) {
				var t = this.dsClauseList.findRowExpr(txt[j]);
	
				if(t != -1) {
					var insertArr = txt[j+1].split(","); 
					for(k = 0;k<insertArr.length;++k) {
						dsEsbCall.setColumn(i, insertArr[k], this.dsClauseList.getColumn(t2, colArray[k]));
					}
				}			
			}
		}
	}
}

Nexacro에서는 getRowType(n)을 통해 특정 row의 CRUD 상태를 알 수 있다.

그런데 어쩌다보니 이런걸 만들어야 할 필요가 생겼다. 기존 dataset에 deletedRowset을 추가하는 것도 방법이었지만 원본 dataset을 보존해야 할 필요가 있었기에 간략하게 만들었다. 실제 업무와 관련된 부분을 다 지웠더니 좀 너무 이상하게 보일 수 있다. BF가 없어도 되는데 왜 있어야 하느니..

특정 dataset에서 타 dataset의 column에 값을 넣어야 하는데 column명이 서로 다르고 임의로 맞춰넣어야 하기에 

Array로 조건을 묶어서 수정하기 쉽게 진행을 해보았다. 변경이 필요할 경우 한줄씩 바꾸면 되기 때문에 효율적이라 생각했다.

this.fnCompsEnable = function(oForm, bEnable, sExcept)
{
	var oComps = oForm.components;
	//if(bEnable) return;
	
	for (var i = 0; i < oComps.length; i++) {	
		if (oComps[i].readonly || sExcept.indexOf(oComps[i].name) > -1) {
			continue;
		}
		
		if (oComps[i] instanceof nexacro.Edit ||
			oComps[i] instanceof nexacro.MaskEdit ||
		    oComps[i] instanceof nexacro.Combo ||
			oComps[i] instanceof nexacro.Calendar) 
		{
			oComps[i].set_readonly(!bEnable);
			
			if (bEnable) continue;
			
			oComps[i].set_border("1px solid #9c9c9c");
			oComps[i].set_autoselect(true);
		}
		
		if (oComps[i] instanceof nexacro.CheckBox ||
		    oComps[i] instanceof nexacro.Radio) 
		{
			oComps[i].set_readonly(!bEnable);
		}
		
		if (oComps[i] instanceof nexacro.Button) 
		{
			oComps[i].set_enable(bEnable);
		}		
		
		if (oComps[i] instanceof nexacro.Div) 
		{
			this.fnCompsEnable(oComps[i].form, bEnable, sExcept);
		}
	}
}

var sExcept = "btnNext_01, btnDetail"; 
this.fnCompsEnable(this, false, sExcept); sExcept에 적힌 component name과 동일한 경우에는 bEnable의 반대값을 적용해주는 형태이다. 

무수히 많은 component enable을 여러 줄을 쓰지 않고 sExcept에 string 형태로 전달만 하면된다는 것이 장점이다.