개발 다이어리

코드

import java.util.*;
// 핵심은 중복 점수 등수가 왜 문제가 없는
class 등수구하기_ {	
		
	public static void main(String[] args){
		int[] scoreArr = new Random().ints(15, 0, 101)
				                     .toArray();
		
		final int LENGTH = scoreArr.length;
		int[] answer = new int[LENGTH];
		int rank = 1;
		
		for(int i=0;i<LENGTH;i++) {
			for(int j=0;j<LENGTH ;j++) {
				//나와 나를 비교하면 참이 안될 것 == 나와 동점은 참이 안될 것
				//결과적으로 동점은 같은 등수를 가지게 된다.
				if(scoreArr[i]<scoreArr[j]) {
					rank++;
				}
			}
			answer[i] = rank;
			rank = 1;
		}
		System.out.println(Arrays.toString(scoreArr));
		System.out.println(Arrays.toString(answer));
		
	}
}

결과

[49, 78, 82, 27, 25, 89, 19, 90, 13, 3, 64, 12, 62, 31, 94]
[8, 5, 4, 10, 11, 3, 12, 2, 13, 15, 6, 14, 7, 9, 1]

코드

public class 단어뒤집기 {
	public static void main(String[] args) {
		String word = "가나다라마바사";
		int lt = 0;
		int rt = word.length()-1;
		char[] cs = word.toCharArray();
		char[] cs2 = word.toCharArray();
		char tmp = ' ';
		
		//방법 1
		while(lt<rt) {
			tmp = cs[lt];     
			cs[lt] = cs[rt];  
			cs[rt] = tmp;     
			lt++;
			rt--;
		}
		
		//방법 2
		int len = cs2.length;
		for(int i=0; i<len/2;i++) {
			tmp = cs2[i];
			cs2[i] = cs2[len-i-1];
			cs2[len-i-1] = tmp;
		}
		
		System.out.println(String.valueOf(cs));
		System.out.println(String.valueOf(cs2));
		
	}
}

결과

사바마라다나가
사바마라다나가

자리 옮기기

개인적으로 "방법 2"로만 했었는데,  "방법1"이 더 가독성이 좋아보인다. 구조도 이해하기 쉽다.

코드

//1 가위   2 바위   3 보
public class 가위바위보 {
	//메인 컨셉 , 한쪽으로 이기는 경우의 수만 나열한다.
	//그러면 나머지는 반대 쪽이 이기는 것이다.
	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();
		int[] a= {1,1,2,3,2,3};
		int[] b= {3,2,1,1,2,3};
		        //A,B,A,B,D,D
		for(int i=0;i<a.length;i++) {
			//비김
			if(a[i]==b[i]) sb.append("D");
			//A가 이기는 경우의 수 전부 나열
			else if(a[i]==1 && b[i]==3 ) sb.append("A");
			else if(a[i]==2 && b[i]==1 ) sb.append("A");
			else if(a[i]==3 && b[i]==2 ) sb.append("A");
			//이외는 B가 이긴 것
			else sb.append("B"); 
		}
		System.out.println(sb);
	}
}

여기서 핵심은 가위바위보가 아니라,  한 쪽에 치우진 경우의 수를 정의하고 그 외 경우는 그와 반대로 처리한다는 이 구조이다.

코드

import java.util.Arrays;
import java.util.Random;

// 저장소를 두고 나보다 큰 값이 존재할 때 마다 갱신해준다.
public class 큰수출력하기 {
	static int count1 = 0;
	public static void main(String[] args) {
		int count2 = 0;
		//사용한 스트림은 닫힌다.
		
		int[] array = new Random().ints(100000000, 1, 500000000).toArray();
		
		long start = System.nanoTime();
		int maxInt = Arrays.stream(array)//.parallel()
				           .reduce(Integer.MIN_VALUE, (a, b) -> {
				     	      	if(a<b) {
				     	      		System.out.println(a+"   "+b);
				     	      		큰수출력하기.count1++;
				     	      		return b;
				     	      	}else {
				     	      		return a;
				     	      	}
				           	});
		long time1 = System.nanoTime()-start;
		System.out.println("스트림 소요시간 : " + time1);
		System.out.println("=====================");
		
		start = System.nanoTime();
 		int tmp = Integer.MIN_VALUE;
		for(int i=0;i<array.length;i++) {
			if(tmp<array[i]) {
				System.out.println(tmp+"  "+array[i]);
				count2++;
				tmp=array[i];
			}
		}
		long time2 = System.nanoTime()-start;
		System.out.println("반복문 소요시간 : " + time2);
		System.out.println("=====================");
		System.out.println("큰 수1 : "+ maxInt);
		System.out.println("큰 수2 : "+ tmp);
		System.out.println("몇 번 바뀜1? : " + 큰수출력하기.count1);
		System.out.println("몇 번 바뀜2? : " + count2);
		
		System.out.println(time1<time2?"스트림 승":"반복문 승");
		
	}
}

결과

-2147483648   476580811
476580811   493765607
493765607   496102572
496102572   498071274
498071274   498579226
498579226   498581580
498581580   499974453
499974453   499982837
499982837   499988721
499988721   499992574
499992574   499997941
499997941   499999160
499999160   499999594
499999594   499999715
499999715   499999907
499999907   499999999
스트림 소요시간 : 183235800
=====================
-2147483648  476580811
476580811  493765607
493765607  496102572
496102572  498071274
498071274  498579226
498579226  498581580
498581580  499974453
499974453  499982837
499982837  499988721
499988721  499992574
499992574  499997941
499997941  499999160
499999160  499999594
499999594  499999715
499999715  499999907
499999907  499999999
반복문 소요시간 : 168843400
=====================
큰 수1 : 499999999
큰 수2 : 499999999
몇 번 바뀜1? : 16
몇 번 바뀜2? : 16
반복문 승

499999779   499999931
499999599   499999629
499999931   499999977
499999814   499999977
499999969   499999977
499999683   499999883
499999961   499999973
499999629   499999916
499999916   499999977
499999983   499999998
스트림 소요시간 : 60819700
=====================
-2147483648  199357576
199357576  398610478
398610478  413062510
413062510  446294614
446294614  464418743
464418743  482929931
482929931  498455214
498455214  499114240
499114240  499685673
499685673  499953566
499953566  499986697
499986697  499989576
499989576  499991638
499991638  499994863
499994863  499995096
499995096  499998840
499998840  499999009
499999009  499999140
499999140  499999772
499999772  499999817
499999817  499999847
499999847  499999983
499999983  499999990
499999990  499999998
반복문 소요시간 : 139373100
=====================
큰 수1 : 499999998
큰 수2 : 499999998
몇 번 바뀜1? : 920
몇 번 바뀜2? : 24
스트림 승

.parallel() 주석을 풀었을 시 결과

스트림과 일반 반복문 차이와 스트림에서 단일과 병렬쓰레드 차이를 보여주고 있다.