[코딩테스트] 자주 쓰는 기초 문법

배열 조작

		String str = "123";
		// 첫번째 문자를 숫자로 변환
		int a = str.charAt(0) - '0';

int Array를 List로

int[] array = { 3, 2, 1 };
// array 정렬
Arrays.sort(array);

// array -> list
ArrayList<Integer> list = new ArrayList<>();

for (int i : array) {
	list.add(i);
}

// list 정렬
Collections.sort(list);

Integer List를 Array로

int[] array1 = list.stream().mapToInt(Integer::intValue).toArray();
System.out.println(Arrays.toString(array1));

배열 요소값의 위치 변경

		int[] A = new int[] { 3, 8, 9, 7, 6 };
		int K = 3;
 		int[] result = new int[A.length];
 
		// 모든 배열 값 요소에 대해서
		for(int i=0;i< A.length;i++) {
 			int index = i;
	 
 			// K만큼 인덱스 위치 이동
			for(int j=0;j< K;j++) {
				index ++;
				
				// 이동할 위치가 인덱스+1이면 0번 인덱스로 이동
				if (index == A.length)
					index = 0;
			}	
 			result[index] = A[i];

 			System.out.println(Arrays.toString(result));
		}

List에 대해 여러 케이스로 배열의 각 값을 조작하고 싶을 때(탐색 요소가 적을 때 완전탐색. List 를 임시로 매번 복제)

for (int i = 0; i <= list.size() - k; i++) {
	// 일단 복사해서 조작
	ArrayList<Integer> temp = new ArrayList<>(list);
	// i의 위치부터 k-1 인덱스를 지움
	for (int j = k - 1 + i; j >= i; j--) {
		temp.remove(j);
	}
	sum(temp);
}

배열의 최대값과 최소값 차

# min은 전역변수로 사용하는 것이 편함
int min = Integer.MAX_VALUE;

private void sum(ArrayList<Integer> list) {
	int sum = 0;

	// 배열 정렬 후 size-1은 최대값, 0번은 최소값
	Collections.sort(list);
	sum = list.get(list.size() - 1) - list.get(0);

	if (sum < min) {
		min = sum;
	}
}

문자열 조작

문자열을 숫자로

 

숫자를 문자로 문자를 숫자로 변환

		// 숫자와 문자간 스트링 조작
		String S = "1234";
		char[] num = S.toCharArray();

		// 각 자리수를 0~9로 변경한 숫자 케이스 출력 
		for (int i = 0; i < num.length; i++) {
			// original char keep
			char temp = num[i];

			// change number
			for (int j = 0; j < 10; j++) {
				// 숫자를 문자로
				num[i] = (char) (j + '0');
				System.out.println(Integer.parseInt(String.valueOf(num)));
			}
			// restore
			num[i] = temp;
		}

HashMap 활용한 그룹별 건수 조회시 getOrDefault 함수가 유용

// 테스트 데이터
HashSet<String> set = new HashSet<>();
set.add("AC");
set.add("AB");
set.add("BC");

// 그룹핑 카운트 중 최대값
int max = 0;

// 그룹핑 카운트
HashMap<Character, Integer> map = new HashMap<>();
for (String s : set) {
    int cnt = map.getOrDefault(s.charAt(0), 0) + 1;
    map.put(s.charAt(0), cnt);
    if (cnt > max) {
        max = cnt;
    }    
}		     
System.out.println(max);

문자열 1차원 배열을 2차원 배열로 변경

String[] maps = {"...","ACC","BBC"};
char[][] arrayMap = new char[maps.length][maps[0].length()];

// 스트링 배열을 map으로 만들기
for (int i = 0; i < maps.length; i++) {
    for (int j = 0; j < maps[i].length(); j++) {
    	// i 의 문자열의 j번째 문자
        arrayMap[i][j] = maps[i].charAt(j);
        System.out.print(maps[i].charAt(j));
    }
    System.out.println();
}

좌표 이동(2차원 공간에서의 방향 벡터)

		// 위치 변환    (우, 위, 좌, 아래)
		String[] moveTypes = {"R", "U", "L", "D"};
		int[] dx = {0, -1, 0, 1};
		int[] dy = {1, 0, -1, 0};
		
		// 현재 위치
		int[] current = {2,2};
		int[] next = new int[2];
		
		for(int i=0; i < moveTypes.length; i++) {
			next[0] = current[0] + dx[i];
			next[1] = current[1] + dy[i];
			// 위치 이동
			current = next;
			System.out.println("current [" + Arrays.toString(current) + "]");
		}

진법 변환

• 원리는 나머지 값을 역순으로 조합

// 10진법 숫자를 진법 문자열로 변환
public static String transform(int number, int jin) {
	// 값을 더해주기 위한 빈 문자열 선언
    String result = "";
    
    while (number > 0 ) {
    	// 문자열의 앞에 number를 진법으로 나눴을 때의 나머지를 더해준다.
    	result = (number % jin) + result;
    	// 다음 턴을 위해 nubmer를 진법으로 나눠준다.
    	number /= jin;
    }
    return result;
}

재귀함수

• 종료조건을 반드시 명시

	public static void main(String[] args) {
		dfs(new ArrayList<>(list), new ArrayList<>()); 
	}
 
	private static void dfs(ArrayList<Integer> list, ArrayList<Integer> temp) {
		// 변경전 리스트의 배열값이 모두 변경후 리스트로 옮겨지면 종료
		if (list.size() == 0) {
			System.out.println(temp);
			// 원하는 작업 수행
			//sum(sort);
			return;
		}

		// 모든 경우의 수를 만들기 위해 위치별로 하나씩 빼서 뒤로 이동
		for (int i = 0; i < list.size(); i++) {
			
			// 변경전 리스트
			ArrayList<Integer> tempA = new ArrayList<>(list);
			// 변경후 리스트
			ArrayList<Integer> tempB = new ArrayList<>(temp);
			
			tempB.add(tempA.get(i));
			tempA.remove(i);

			// 배열의 맨앞값을 뒤로 옮겨서 재귀호출
			dfs(tempA, tempB);
		}
	}