코드


import java.util.*;
//오름차순 기준
//삽입정렬은 i 크기만큼 배열만 정렬하고 i를 점점 증가시킨다.
//그래서 맨 처음은 인위적으로 0인덱스 자리를 비운다. i=1 
//1번 째 순회는 길이가 2인 배열 일부를 비교,
//n번 째 순회는 길이가 n+1인 배열 일부를 비교,
//최종으로는 입력받은 배열 전체를 비교하게 된다.
//핵심은 배열의 크기가 점점 커지면서 최종적으로 입력받은 배열 크기를 비교하게 되는데
//이때 이미 내 앞의 요소는 정렬이 되어있음을 보장한다.
//이 구조는 마치 정렬된 배열에 요소를 추가하는 것과 같다.
//이미 정렬이 되어 있는 배열에 새로운 요소를 추가하는데, 순서를 지키고 싶다고 생각해보자
//뒤에서 부터 비교하면서, 나보다 작은 수가 안나올 때까지 비교할 것이다.
//만약 나보다 작은 수가 나온다면, 비교를 멈추고 그 자리에 나를 넣을 것이다.
//따라서 새로운 요소가 가장 작은 수가 아니라면, 전체를 다 순회하지 않는다. 
class 삽입정렬 {
	public static void main(String[] args) {
		// 최대치를 높여가며 뒤부터 앞으로 정렬을 반복
		int[] arr = new Random().ints(10, 50, 100).toArray();
		for(int i = 1;i<arr.length;i++) {
			for(int j = i;j>0;j--) {
				//arr[j]가 기존 배열에 새로 추가할 요소라고 생각해보자.
				System.out.println("i 순회 중 = "+ i);
				if(arr[j]<arr[j-1] ) {
					System.out.println("arr["+j+"-1]="+arr[j-1]+" <==> arr["+j+"]="+arr[j]);
					for(int z=0;z<j-1;z++) System.out.print("    ");
					System.out.println("  *");
					System.out.println(Arrays.toString(arr));
					int tmp= arr[j];
					arr[j] = arr[j-1];
					arr[j-1] = tmp;
					System.out.println(Arrays.toString(arr));
					System.out.println("========================================");
				}else {
					//기존 배열은 정렬을 유지하고 있는 상태이다.
					//따라서, false가 나오면 그만 순회해도 되는 것이다.
					break;
				}
			}
		}
	}
}

결과

i 순회 중 = 1
arr[1-1]=65 <==> arr[1]=54
  *
[65, 54, 50, 81, 51, 65, 90, 61, 86, 62]
[54, 65, 50, 81, 51, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 2
arr[2-1]=65 <==> arr[2]=50
      *
[54, 65, 50, 81, 51, 65, 90, 61, 86, 62]
[54, 50, 65, 81, 51, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 2
arr[1-1]=54 <==> arr[1]=50
  *
[54, 50, 65, 81, 51, 65, 90, 61, 86, 62]
[50, 54, 65, 81, 51, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 3
i 순회 중 = 4
arr[4-1]=81 <==> arr[4]=51
              *
[50, 54, 65, 81, 51, 65, 90, 61, 86, 62]
[50, 54, 65, 51, 81, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 4
arr[3-1]=65 <==> arr[3]=51
          *
[50, 54, 65, 51, 81, 65, 90, 61, 86, 62]
[50, 54, 51, 65, 81, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 4
arr[2-1]=54 <==> arr[2]=51
      *
[50, 54, 51, 65, 81, 65, 90, 61, 86, 62]
[50, 51, 54, 65, 81, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 4
i 순회 중 = 5
arr[5-1]=81 <==> arr[5]=65
                  *
[50, 51, 54, 65, 81, 65, 90, 61, 86, 62]
[50, 51, 54, 65, 65, 81, 90, 61, 86, 62]
========================================
i 순회 중 = 5
i 순회 중 = 6
i 순회 중 = 7
arr[7-1]=90 <==> arr[7]=61
                          *
[50, 51, 54, 65, 65, 81, 90, 61, 86, 62]
[50, 51, 54, 65, 65, 81, 61, 90, 86, 62]
========================================
i 순회 중 = 7
arr[6-1]=81 <==> arr[6]=61
                      *
[50, 51, 54, 65, 65, 81, 61, 90, 86, 62]
[50, 51, 54, 65, 65, 61, 81, 90, 86, 62]
========================================
i 순회 중 = 7
arr[5-1]=65 <==> arr[5]=61
                  *
[50, 51, 54, 65, 65, 61, 81, 90, 86, 62]
[50, 51, 54, 65, 61, 65, 81, 90, 86, 62]
========================================
i 순회 중 = 7
arr[4-1]=65 <==> arr[4]=61
              *
[50, 51, 54, 65, 61, 65, 81, 90, 86, 62]
[50, 51, 54, 61, 65, 65, 81, 90, 86, 62]
========================================
i 순회 중 = 7
i 순회 중 = 8
arr[8-1]=90 <==> arr[8]=86
                              *
[50, 51, 54, 61, 65, 65, 81, 90, 86, 62]
[50, 51, 54, 61, 65, 65, 81, 86, 90, 62]
========================================
i 순회 중 = 8
i 순회 중 = 9
arr[9-1]=90 <==> arr[9]=62
                                  *
[50, 51, 54, 61, 65, 65, 81, 86, 90, 62]
[50, 51, 54, 61, 65, 65, 81, 86, 62, 90]
========================================
i 순회 중 = 9
arr[8-1]=86 <==> arr[8]=62
                              *
[50, 51, 54, 61, 65, 65, 81, 86, 62, 90]
[50, 51, 54, 61, 65, 65, 81, 62, 86, 90]
========================================
i 순회 중 = 9
arr[7-1]=81 <==> arr[7]=62
                          *
[50, 51, 54, 61, 65, 65, 81, 62, 86, 90]
[50, 51, 54, 61, 65, 65, 62, 81, 86, 90]
========================================
i 순회 중 = 9
arr[6-1]=65 <==> arr[6]=62
                      *
[50, 51, 54, 61, 65, 65, 62, 81, 86, 90]
[50, 51, 54, 61, 65, 62, 65, 81, 86, 90]
========================================
i 순회 중 = 9
arr[5-1]=65 <==> arr[5]=62
                  *
[50, 51, 54, 61, 65, 62, 65, 81, 86, 90]
[50, 51, 54, 61, 62, 65, 65, 81, 86, 90]
========================================
i 순회 중 = 9

 

'자료구조&알고리즘 > 자바(Java) 알고리즘 문제풀이 : 코딩테스트 대비' 카테고리의 다른 글

LRU(Least Recently Used)  (0) 2022.12.06
버블정렬  (0) 2022.12.04
선택정렬  (0) 2022.12.02
후위연산  (0) 2022.12.01
모든 아나그램 찾기  (0) 2022.11.30

코드


import java.util.*;
//오름차순 기준
//선택정렬은 앞자리부터 작은 수를 채워간다.
//즉, 1번째 순회 시 맨 앞자리에 가장 작은 수가 오고
//그 다음은 2 번째 순회 시 그 다음 자리에 그 다음으로 작은 수가 온다.
class 선택정렬 {	
	public static void main(String[] args){
		int[] arr = new Random().ints(10, 50, 101)
		            .toArray();
		// i의 역할은 인덱스로 순회하면서 가장 작은 수를 채운다.
		for(int i=0;i<arr.length-1;i++) {
			//j 역할은 i 마다 반복하면서 arr[i]보다 작은 수를 검사해 자리를 바꿔치기한다.
			System.out.println("i 순회 중 = "+ i);
			for(int j=i+1;j<arr.length;j++) {
				if(arr[i]>arr[j]) {
					System.out.println("arr["+i+"]"+arr[i]+" <==> arr["+j+"]="+arr[j]);
					for(int z=0;z<j;z++)System.out.print("    ");
					System.out.println("  *");
					System.out.println(Arrays.toString(arr));
					
					int tmp = arr[i];
					arr[i] = arr[j];
					arr[j] = tmp;
					
					System.out.println(Arrays.toString(arr));
					System.out.println("========================================");
				}
			}
		}
		System.out.println("\n"+Arrays.toString(arr));
	}
}

결과

i 순회 중 = 0
arr[0]83 <==> arr[1]=66
      *
[83, 66, 100, 60, 78, 90, 56, 67, 91, 76]
[66, 83, 100, 60, 78, 90, 56, 67, 91, 76]
========================================
arr[0]66 <==> arr[3]=60
              *
[66, 83, 100, 60, 78, 90, 56, 67, 91, 76]
[60, 83, 100, 66, 78, 90, 56, 67, 91, 76]
========================================
arr[0]60 <==> arr[6]=56
                          *
[60, 83, 100, 66, 78, 90, 56, 67, 91, 76]
[56, 83, 100, 66, 78, 90, 60, 67, 91, 76]
========================================
i 순회 중 = 1
arr[1]83 <==> arr[3]=66
              *
[56, 83, 100, 66, 78, 90, 60, 67, 91, 76]
[56, 66, 100, 83, 78, 90, 60, 67, 91, 76]
========================================
arr[1]66 <==> arr[6]=60
                          *
[56, 66, 100, 83, 78, 90, 60, 67, 91, 76]
[56, 60, 100, 83, 78, 90, 66, 67, 91, 76]
========================================
i 순회 중 = 2
arr[2]100 <==> arr[3]=83
              *
[56, 60, 100, 83, 78, 90, 66, 67, 91, 76]
[56, 60, 83, 100, 78, 90, 66, 67, 91, 76]
========================================
arr[2]83 <==> arr[4]=78
                  *
[56, 60, 83, 100, 78, 90, 66, 67, 91, 76]
[56, 60, 78, 100, 83, 90, 66, 67, 91, 76]
========================================
arr[2]78 <==> arr[6]=66
                          *
[56, 60, 78, 100, 83, 90, 66, 67, 91, 76]
[56, 60, 66, 100, 83, 90, 78, 67, 91, 76]
========================================
i 순회 중 = 3
arr[3]100 <==> arr[4]=83
                  *
[56, 60, 66, 100, 83, 90, 78, 67, 91, 76]
[56, 60, 66, 83, 100, 90, 78, 67, 91, 76]
========================================
arr[3]83 <==> arr[6]=78
                          *
[56, 60, 66, 83, 100, 90, 78, 67, 91, 76]
[56, 60, 66, 78, 100, 90, 83, 67, 91, 76]
========================================
arr[3]78 <==> arr[7]=67
                              *
[56, 60, 66, 78, 100, 90, 83, 67, 91, 76]
[56, 60, 66, 67, 100, 90, 83, 78, 91, 76]
========================================
i 순회 중 = 4
arr[4]100 <==> arr[5]=90
                      *
[56, 60, 66, 67, 100, 90, 83, 78, 91, 76]
[56, 60, 66, 67, 90, 100, 83, 78, 91, 76]
========================================
arr[4]90 <==> arr[6]=83
                          *
[56, 60, 66, 67, 90, 100, 83, 78, 91, 76]
[56, 60, 66, 67, 83, 100, 90, 78, 91, 76]
========================================
arr[4]83 <==> arr[7]=78
                              *
[56, 60, 66, 67, 83, 100, 90, 78, 91, 76]
[56, 60, 66, 67, 78, 100, 90, 83, 91, 76]
========================================
arr[4]78 <==> arr[9]=76
                                      *
[56, 60, 66, 67, 78, 100, 90, 83, 91, 76]
[56, 60, 66, 67, 76, 100, 90, 83, 91, 78]
========================================
i 순회 중 = 5
arr[5]100 <==> arr[6]=90
                          *
[56, 60, 66, 67, 76, 100, 90, 83, 91, 78]
[56, 60, 66, 67, 76, 90, 100, 83, 91, 78]
========================================
arr[5]90 <==> arr[7]=83
                              *
[56, 60, 66, 67, 76, 90, 100, 83, 91, 78]
[56, 60, 66, 67, 76, 83, 100, 90, 91, 78]
========================================
arr[5]83 <==> arr[9]=78
                                      *
[56, 60, 66, 67, 76, 83, 100, 90, 91, 78]
[56, 60, 66, 67, 76, 78, 100, 90, 91, 83]
========================================
i 순회 중 = 6
arr[6]100 <==> arr[7]=90
                              *
[56, 60, 66, 67, 76, 78, 100, 90, 91, 83]
[56, 60, 66, 67, 76, 78, 90, 100, 91, 83]
========================================
arr[6]90 <==> arr[9]=83
                                      *
[56, 60, 66, 67, 76, 78, 90, 100, 91, 83]
[56, 60, 66, 67, 76, 78, 83, 100, 91, 90]
========================================
i 순회 중 = 7
arr[7]100 <==> arr[8]=91
                                  *
[56, 60, 66, 67, 76, 78, 83, 100, 91, 90]
[56, 60, 66, 67, 76, 78, 83, 91, 100, 90]
========================================
arr[7]91 <==> arr[9]=90
                                      *
[56, 60, 66, 67, 76, 78, 83, 91, 100, 90]
[56, 60, 66, 67, 76, 78, 83, 90, 100, 91]
========================================
i 순회 중 = 8
arr[8]100 <==> arr[9]=91
                                      *
[56, 60, 66, 67, 76, 78, 83, 90, 100, 91]
[56, 60, 66, 67, 76, 78, 83, 90, 91, 100]
========================================

[56, 60, 66, 67, 76, 78, 83, 90, 91, 100]

 

 

'자료구조&알고리즘 > 자바(Java) 알고리즘 문제풀이 : 코딩테스트 대비' 카테고리의 다른 글

버블정렬  (0) 2022.12.04
삽입정렬  (0) 2022.12.03
후위연산  (0) 2022.12.01
모든 아나그램 찾기  (0) 2022.11.30
K번째 큰 수  (0) 2022.11.27

코드

import java.util.*;
//후위연산
class 후위연산_ {	
	public static void main(String[] args){
		String str = "573*+5-323*++";
		int answer=0;
		Stack<Integer> stack = new Stack<Integer>();
		
		for(char cha : str.toCharArray()) {
			int lt = 0;
			int rt = 0;
			if(!Character.isDigit(cha)) {
//			if(cha =='+'||cha =='-'||cha =='/'||cha =='*') {
				rt = stack.pop();
				lt = stack.pop();
				answer = cha=='+'? Integer.sum(lt, rt) 
						:cha=='-'? Math.subtractExact(lt, rt)
						:cha=='/'? Math.floorDiv(lt, rt) 
								 : Math.multiplyExact(lt, rt);
				stack.push(answer);
			}else {
				System.out.println("char:"+cha + " char아스키:"+ Integer.valueOf(cha));
				stack.push(cha-'0');
				// char형 숫자에 '0'을 빼면 우리가 생각하는 숫자(int)가 된다.
				// -48도 가능하다.
			}
		}
		System.out.println("char: 0 char아스키:"+ Integer.valueOf('0'));
		System.out.println(answer);
	}
}

결과

char:5 char아스키:53
char:7 char아스키:55
char:3 char아스키:51
char:5 char아스키:53
char:3 char아스키:51
char:2 char아스키:50
char:3 char아스키:51
char: 0 char아스키:48
30

 

'자료구조&알고리즘 > 자바(Java) 알고리즘 문제풀이 : 코딩테스트 대비' 카테고리의 다른 글

삽입정렬  (0) 2022.12.03
선택정렬  (0) 2022.12.02
모든 아나그램 찾기  (0) 2022.11.30
K번째 큰 수  (0) 2022.11.27
연속된 자연수의 합  (0) 2022.11.25

코드


import java.util.HashMap;
import java.util.Random;
class 모든아나그램찾기 {	
	public static void main(String[] args){
		String a = init(300); // 검사 대상
		String b = init(3); // 어나그램
		
		int answer=0;
		HashMap<Character, Integer> inputMap = new HashMap<Character, Integer>();
		HashMap<Character, Integer> map = new HashMap<Character, Integer>();
		
		//초기화
		for(int i=0;i<b.length()-1;i++) {
			char tmp1 = a.charAt(i);
			char tmp2 = b.charAt(i);
			inputMap.put(tmp1, inputMap.getOrDefault(tmp1, 0)+1 );
			map.put(tmp2, map.getOrDefault(tmp2, 0)+1 );
		}
		map.put(b.charAt(b.length()-1), map.getOrDefault(b.charAt(b.length()-1), 0)+1 );
		
		for(int lt=0, rt=b.length()-1 ;rt<a.length();rt++) {
			char tmp = a.charAt(rt);
			//1. 추가
			inputMap.put(tmp, inputMap.getOrDefault(tmp, 0)+1);
			
			//2. 검증 
			/* 메서드 안쓰고 할 시
			boolean flag= true;
			for(Character cha : map.keySet()) {
				//키 검증
				if(!inputMap.containsKey(cha)) {
					flag=false;
					break;
				}
				//개수 검증
				if(!(inputMap.get(cha) == map.get(cha))) {
					flag=false;
					break;
				}
				
			}
			if(flag) {
				System.out.println("일치 : " + lt +", " +rt);
				answer++;
			}
			*/
			if(inputMap.equals(map)) {
				System.out.println("일치 : " + lt +", " +rt);
				answer++;
			}
			
			//3. 삭제&수정&추가
			tmp = a.charAt(lt);
			inputMap.put(tmp, inputMap.get(tmp)-1 );
			
			if(inputMap.get(tmp)==0 ) {
				inputMap.remove(tmp);
			}
			lt++;
		}
		int count = 1;
		
		for(int i=0; i<a.length();i++) {
			if(count==1) System.out.printf("%3s %s\n",0,a.substring(i, i+10));
			if(count%10==0) {
				if( i+10-1<a.length() ) {
					System.out.printf("%3s %s" , ""+count,a.substring(i+1, i+1+10) );
					System.out.println();
				}
			}
			count++;
			
		}
		System.out.println("탐색문자 : "+b);
		System.out.println("갯수 : " +answer);
		
	}

	static String init(int size) {
		int[] array = new Random().ints(size, 65, 70).map(n -> {
			if ((int) (Math.random() * 10) % 2 == 0) {
				n += 32;
			}
			return n;
		}).toArray();
		StringBuilder sb = new StringBuilder();
		for (int num : array) {
			sb.append((char) num);
		}
		return sb.toString();
	}
}

결과

일치 : 50, 52
일치 : 116, 118
일치 : 297, 299
  0 cDEDeeDaCd
 10 dbBDCEECEc
 20 EdEBEbcEda
 30 bDAeebEEbe
 40 ABcaAeEabe
 50 ebdDBcBadd
 60 aDeECccBdD
 70 EBDdCBdEDa
 80 EAcbCCCcba
 90 DEbACcECda
100 aCABAdBCea
110 abeCCCedbB
120 BEDEEddcaa
130 DccEaEaaCD
140 eabAeBeabE
150 dBCEcDdAAE
160 CDeEdCdDdC
170 EDcDbEaAae
180 acBDCDeCDC
190 EACDDDAAaB
200 aeAAeAbcee
210 cDeEeBccde
220 AeDdCEBcEa
230 AdDeDeACAD
240 bebbcaeeBE
250 baCCCDCcbb
260 EaEcCeadad
270 BcaeCcBeCb
280 cdaCdaAaDb
290 BEDEdDaebd
탐색문자 : ebd
갯수 : 3

 

'자료구조&알고리즘 > 자바(Java) 알고리즘 문제풀이 : 코딩테스트 대비' 카테고리의 다른 글

선택정렬  (0) 2022.12.02
후위연산  (0) 2022.12.01
K번째 큰 수  (0) 2022.11.27
연속된 자연수의 합  (0) 2022.11.25
연속부분수열  (0) 2022.11.23

코드


import java.util.*;
class K번째큰수_ {	
	public static void main(String[] args){
		int[] arr = new Random().ints(100, 1, 101)
		            .toArray();
		
		int k = 4; //번째 큰수
		int n = arr.length;
		int count =0;
		
		// 역순 정렬을 위해 직접 Comparator 구현
		TreeSet<Integer> set = new TreeSet<>((a,b)->Integer.compare(b, a));
		
		for(int i = 0;i<n;i++) {
			for(int j=i+1;j<n;j++) {
				for(int z=j+1;z<n;z++) {
					set.add(arr[i]+arr[j]+arr[z]);
					count++;
				}
			}
		}
		//사이즈를 넘어선 k는 예외발생
		if(set.size()<k) {
			System.out.println("-1 not found");
		}
		int cnt = 1;
		int sum = 0;
		
		for(Iterator<Integer> it = set.iterator();it.hasNext() ;cnt++) {
			sum = it.next();
			System.out.print(sum+",");
			if(cnt==k) {
				System.out.println("\n"+k+"번째 큰 수 : "+ sum);;
				break;
			}
		}
		System.out.println("경우의 수 : " +count);
	}
}

결과

292,291,290,289,
4번째 큰 수 : 289
경우의 수 : 161700

List를 써서 해도 되지만, 해시가 더 빠르다.

'자료구조&알고리즘 > 자바(Java) 알고리즘 문제풀이 : 코딩테스트 대비' 카테고리의 다른 글

후위연산  (0) 2022.12.01
모든 아나그램 찾기  (0) 2022.11.30
연속된 자연수의 합  (0) 2022.11.25
연속부분수열  (0) 2022.11.23
교집합  (0) 2022.11.20

코드

import java.util.*;
import java.util.stream.IntStream;
// n 값이 될 수 있는 연속된 자연 수 합 구하기
class 연속된자연수합 {

	public static void main(String[] args) {
		int n = 1000;
		int answer = 0, sum = 0;
		int m = n / 2 + 1; //2개 이상의 연속된 자연수의 합은 절반 정도만 필요
		int[] arr = IntStream.rangeClosed(1, m).toArray();
		
		//rt를 담당하는 외부 반복문
		for (int rt = 0,lt = 0; rt < m; rt++ ) {
			sum+= arr[rt];
			//lt를 담당하는 내부 반복문
			//n보다 sum이 크거나 같을때.
			while(n<=sum) {
				//sum이 n과 같다.
				if(sum==n) {
					prettyPrint(arr, lt, rt);
					answer++;
					sum-=arr[lt++];
				//sum이 n보다 크다.
				}else {
					sum-=arr[lt++];
				}
			}
		}
		System.out.println(answer);
	}
	static void prettyPrint(int[] arr, int lt, int rt) {
		System.out.print("[lt="+lt+" rt="+(rt)+"]");
		Arrays.stream(arr, lt, rt+1).forEach(n->System.out.print(n+","));
		System.out.println();
	}
}

결과

[lt=27 rt=51]28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,
[lt=54 rt=69]55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,
[lt=197 rt=201]198,199,200,201,202,
3

여기서 while은 특정 조건에만 반복한다. 따라서 시간복잡도는 이중반복문과는 다르다.

'자료구조&알고리즘 > 자바(Java) 알고리즘 문제풀이 : 코딩테스트 대비' 카테고리의 다른 글

모든 아나그램 찾기  (0) 2022.11.30
K번째 큰 수  (0) 2022.11.27
연속부분수열  (0) 2022.11.23
교집합  (0) 2022.11.20
두배열합치기  (0) 2022.11.17

코드

import java.util.*;

// n개 == arr.length , 연속된 arr 배열 수 합이 m인 경우가 몇회인가?
class 연속부분수열 {

	public static void main(String[] args) {
		int 배열크기 = 50;
		int 합계 = 30;
		int[] arr = new Random().ints(배열크기, 1, 11).toArray();//1~10
		int answer = 0;
		System.out.println(Arrays.toString(arr));
		//핵심은 값을 증감 후 같을 수 있으니 검증로직을 한 번 더 태우는 것이다.
		for (int rt = 0, sum = 0, lt = 0; rt < arr.length;) {
			if (sum <= 합계) {
				if (sum == 합계) {
					prettyPrint(arr, lt, rt);
					answer++;
					sum -= arr[lt++];
				}
				
				sum += arr[rt++];
				
				if (sum == 합계) {
					prettyPrint(arr, lt, rt);
					answer++;
					sum -= arr[lt++];
				}
			} else {
				sum -= arr[lt++];
			}
		}
		System.out.println("총 카운트 = "+answer);
	}
	static void prettyPrint(int[] arr, int lt, int rt) {
		System.out.print("[lt="+lt+" rt="+(rt-1)+"]");
		Arrays.stream(arr, lt, rt).forEach(n->System.out.print(n+","));
		System.out.println();
	}
	
}

결과

[2, 9, 1, 3, 6, 4, 7, 4, 10, 4, 9, 10, 4, 6, 5, 2, 2, 5, 6, 3, 5, 10, 1, 8, 5, 9, 3, 8, 1, 5, 8, 6, 8, 2, 10, 8, 6, 8, 6, 1, 1, 7, 6, 5, 7, 7, 7, 9, 1, 3]
[lt=1 rt=6]9,1,3,6,4,7,
[lt=12 rt=18]4,6,5,2,2,5,6,
[lt=17 rt=22]5,6,3,5,10,1,
[lt=28 rt=33]1,5,8,6,8,2,
[lt=35 rt=40]8,6,8,6,1,1,
[lt=44 rt=47]7,7,7,9,
총 카운트 = 6

 

'자료구조&알고리즘 > 자바(Java) 알고리즘 문제풀이 : 코딩테스트 대비' 카테고리의 다른 글

K번째 큰 수  (0) 2022.11.27
연속된 자연수의 합  (0) 2022.11.25
교집합  (0) 2022.11.20
두배열합치기  (0) 2022.11.17
중복문자제거  (0) 2022.11.14

코드

import java.util.*;
class 교집합_ {	

	public static void main(String[] args){
		ArrayList<Integer> answer = new ArrayList<>();
		ArrayList<Integer> answer2 = new ArrayList<>();
		int [] a = new Random().ints(20, 0, 100).sorted().toArray();
		int [] b = new Random().ints(20, 0, 100).sorted().toArray();
		
		int p1=0,p2=0,count1=0,count2=0;
		while(p1<a.length&&p2<b.length) {
			if(a[p1]==b[p2]) {
				answer.add(a[p1]);
				p1++;
				p2++;
			}else if(a[p1]<b[p2]) {
				p1++;
			}else {
				p2++;
			}
			count1++;
		}
		
		
		for(int i=0;i<a.length;i++) {
			for(int j=0;j<b.length;j++) {
				count2++;
				if(a[i]==b[j]) {
					answer2.add(a[i]);
					break;
				}
			}
		}
		
		System.out.println(Arrays.toString(a));
		System.out.println(Arrays.toString(b));
		
		System.out.println(answer);
		System.out.println(answer2);
		
		System.out.println(count1);
		System.out.println(count2);
		
	}
}

결과

[1, 7, 10, 10, 13, 22, 26, 31, 32, 34, 44, 48, 57, 57, 66, 69, 79, 82, 88, 92]
[2, 6, 8, 19, 31, 33, 35, 40, 49, 59, 60, 60, 61, 63, 65, 73, 78, 88, 90, 99]
[31, 88]
[31, 88]
37
383

 


반복 횟수 차이가 극명하다....

 
 

가져오기 java.util.*;
교집합_ {

공개 정적 무효 메인(문자열[] 인수){
ArrayList<정수> 답변 = 새로운 ArrayList<>();
ArrayList<정수> answer2 = 새로운 ArrayList<>();
int [] a = 새로운 Random().ints(20, 0, 100).sorted().toArray();
int [] b = 새로운 Random().ints(20, 0, 100).sorted().toArray();

정수 p1=0,p2=0,count1=0,count2=0;
동안(p1<a.length&&p2<b.length) {
if(a[p1]==b[p2]) {
답변.add(a[p1]);
p1++;
p2++;
} else if(a[p1]<b[p2]) {
p1++;
}또 다른 {
p2++;
}
카운트1++;
}


for(int i=0;i<a.length;i++) {
for(int j=0;j<b.length;j++) {
카운트2++;
if(a[i]==b[j]) {
answer2.add(a[i]);
부서지다;
}
}
}

System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));

System.out.println(답변);
System.out.println(답변2);

System.out.println(count1);
System.out.println(count2);

}
}

 

'자료구조&알고리즘 > 자바(Java) 알고리즘 문제풀이 : 코딩테스트 대비' 카테고리의 다른 글

연속된 자연수의 합  (0) 2022.11.25
연속부분수열  (0) 2022.11.23
두배열합치기  (0) 2022.11.17
중복문자제거  (0) 2022.11.14
격자판 최대합  (0) 2022.11.12

코드

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.stream.IntStream;

public class 두배열합치기_ {
	public static void main(String[] args) {
		
		int[] is1 = new Random().ints((int)(Math.random()*5000), Integer.MIN_VALUE, Integer.MAX_VALUE)
					.toArray();
		int[] is2 = new Random().ints((int)(Math.random()*5000), Integer.MIN_VALUE, Integer.MAX_VALUE)
					.toArray();
		
		int[] copyOf1 = Arrays.copyOf(is1, is1.length);
		int[] copyOf2 = Arrays.copyOf(is2, is2.length);
		
		
		StopWatch sw = new StopWatch();
		
		ArrayList<Integer> list1 = new ArrayList<Integer>();
		int p1=0,p2=0;
		
		sw.start();
		Arrays.sort(is1);
		Arrays.sort(is2);
		
		while(p1<is1.length && p2<is2.length) {
			if(is1[p1]<is2[p2] ) {
				list1.add(is1[p1++]);
			}else {
				list1.add(is2[p2++]);
			}
		}
		while(p1<is1.length) {
			list1.add(is1[p1++]);
		}
		while(p2<is2.length) {
			list1.add(is2[p2++]);
		}
		sw.stop();
		System.out.println("소요시간 : " + sw.time());
		
		sw.start();
		
		IntStream.concat(IntStream.of(copyOf1), IntStream.of(copyOf2))
		         .sorted()
		         .toArray();
		sw.stop();
		
		System.out.println("소요시간 : " + sw.time());
		
	}
}

class StopWatch{
	long startTime;
	long endTime;
	
	
	public long start() {
		return this.startTime = System.nanoTime();
	}
	
	public long stop() {
		return this.endTime = System.nanoTime();
	}
	
	public long time() {
		if(startTime == 0 && endTime == 0) {
			return -1;
		}
		return endTime - startTime;
	}
	
}

결과

소요시간 : 1521800
소요시간 : 1803400

1번째는 두포인터를 사용한 배열합치기(문제의도) , 2 번째는 궁금해서 해봤다.

 

두배열을 합친 결과를 정렬해야한다고 가정하고, 

소요시간이 엎치락 뒤치락한다...

 

데이터 건 수가 많으면 앞도적으로 스트림이 빠르다.

'자료구조&알고리즘 > 자바(Java) 알고리즘 문제풀이 : 코딩테스트 대비' 카테고리의 다른 글

연속부분수열  (0) 2022.11.23
교집합  (0) 2022.11.20
중복문자제거  (0) 2022.11.14
격자판 최대합  (0) 2022.11.12
숫자뒤집기  (0) 2022.11.10

코드

import java.util.Arrays;

public class 중복문자제거_ {
    public static void main(String[] args) {
        String value = "112233112ㅁㄴㅇㅁㄴㅇ2334551123";
        String answer = "";
        
        int len = value.length();
        for(int i = 0 ; i<len ;i++) {
            //indexOf 는 가장 앞에 존재하는 문자를 반환한다.
            //charAt 은 특정 위치 char를 반환한다. 
            //따라서 아래 조건문은 첫 번째 존재하는 문자와 인덱스 위치만 참이된다.
            if(value.indexOf( value.charAt(i)) == i )  {
                answer += value.charAt(i);
            }
        }
        System.out.println(answer);
        
        Character[] array = value.chars()
                                 .distinct()
                                 .mapToObj(num->((char)num))
                                 .toArray(Character[]::new);
        System.out.println(Arrays.toString(array));
        
    }
}

결과

123ㅁㄴㅇ45
[1, 2, 3, ㅁ, ㄴ, ㅇ, 4, 5]

중복 문자 제거는 indexOf 메서드 동작방식에 의존한다.

indexOf()는 주어진 문자에 해당하는 가장 첫 번째 위치 인덱스를 리턴한다.

즉, 대상이 첫 번째 위치로 특정되어 있다. 

이를 활용해 반환된 인덱스와 배열을 순회하는 인덱스가 같으면 중복을 제거할 수 있다.

 

 

'자료구조&알고리즘 > 자바(Java) 알고리즘 문제풀이 : 코딩테스트 대비' 카테고리의 다른 글

교집합  (0) 2022.11.20
두배열합치기  (0) 2022.11.17
격자판 최대합  (0) 2022.11.12
숫자뒤집기  (0) 2022.11.10
봉우리  (0) 2022.11.09

+ Recent posts