[프로그래머스] '최댓값 만들기 (1)' - Java

<문제 제시>

<문제설명>
정수 배열 numbers가 매개변수로 주어집니다.
numbers의 원소 중 두 개를 곱해 만들 수 있는 최댓값을 
return하도록 solution 함수를 완성해주세요.

<예시 입출력>

---

<문제 해결 과정>

Try 1)

int answer = 0;

// 첫번째 최대값을 구하는 반복문
int max = Integer.MIN_VALUE;
for(int i = 0; i < numbers.length; i++) {
    if(max < numbers[i]) max = numbers[i];
}

// 두번째로 큰 최대값을 구하는 반복문
int max2 = Integer.MIN_VALUE;
for(int i = 0; i < numbers.length; i++) {
    if(max2 < numbers[i] && max != numbers[i]) max2 = numbers[i];
}

answer = max * max2;

return answer;

모든 테스트케이스에서 통과하지 못하였다.

Integer.MIN_VALUE;를 통해 max 변수를 초기화하고 numbers배열에서 max값을 찾고자 하였으나 

두번째로 큰 값을 찾을때 첫번째로 찾았던 최대값을 제외하는 로직에서 문제가 발생한 것 같았다.

정수배열에서 음수의 경우가 두번 나올때를 고려하지 않은 것 같았다.

음수를 따로 검사하여 진행해봐야할 것 같았다.

Try 2)

int answer = 0;
        
// 첫번째 최대값을 구하는 반복문
int max = Integer.MIN_VALUE;
// 배열의 음수찾는 로직 추가
int minus = 0;
for(int i = 0; i < numbers.length; i++) {
    if(max < numbers[i]) max = numbers[i];
    if(numbers[i] < 0) minus = numbers[i];
}

// 두번째로 큰 최대값을 구하는 반복문
int max2 = Integer.MIN_VALUE;
// 배열의 음수찾는 로직 추가
int minus2 = 0;
for(int i = 0; i < numbers.length; i++) {
    if(max2 < numbers[i] && max != numbers[i]) max2 = numbers[i];
    if(numbers[i] < 0 && numbers[i] != minus) minus2 = numbers[i];
}

int compare1 = minus * minus2;
int compare2 = max * max2;

// 삼항연산자로 마이너스 값끼리 곱한 값과 기존 max를 구하는 로직의 크기 비교 후 반환
answer = compare1 >  compare2 ? compare1 : compare2;

return answer;

Try 1)에서의 문제점을 개선 후

음수인 값을 포함하는 배열일 경우 처리하는 로직을 달리하고자 하였으나 

음수 개수가 여러개일 경우의 처리는 고려하지 못한 것 같다.

Try 3)

int answer = 0;
        
List<Integer> minus_list = new ArrayList<>();

// 첫번째 최대값을 구하는 반복문
int max = Integer.MIN_VALUE;

int k = 0;
for(int i = 0; i < numbers.length; i++) {
    if(max < numbers[i]) max = numbers[i];

    // 배열의 음수찾는 로직 추가
    if(numbers[i] < 0) {
        minus_list.add(k, i);
        k++;
    }
}

// 내림차순 정렬
Collections.sort(minus_list, Collections.reverseOrder());

// 두번째로 큰 최대값을 구하는 반복문
int max2 = Integer.MIN_VALUE;

for(int i = 0; i < numbers.length; i++) {
    if(max2 < numbers[i] && max != numbers[i]) max2 = numbers[i];
}

int compare1 = max * max2;
int compare2 = minus_list.get(0) * minus_list.get(1);

// 삼항연산자로 마이너스 값끼리 곱한 값과 기존 max를 구하는 로직의 크기 비교 후 반환
answer = (compare1 > compare2) ? compare1 : compare2;

return answer;

리스트로 복수의 음수의 값들을 넣고 내림차순 정렬하여 큰값과 두번째로 큰 값을 불러온 후 

비교군으로 만들어 answer에 넣고자 하였다.

하지만 프로그래머스 상에서 Collections가 작동되지 않는 것 같았고, 

리스트를 for반복문을 통해 큰값, 작은 값을 다시 뽑아내보기로 하였다.

다시생각해보니 음수를 구하고자 코드를 작성해놓은 결과로 일반적인 테스트케이스에서는

리스트의 get(0), get(1) 등의 코드를 불러오지 못한다는 것을 인지하였다.

Try 4)

int answer = 0;
        
List<Integer> minus_list = new ArrayList<>();
int compare2 = 0;

// 첫번째 최대값을 구하는 반복문
int max = Integer.MIN_VALUE;

int k = 0;
for(int i = 0; i < numbers.length; i++) {
    if(max < numbers[i]) max = numbers[i];

    // 배열의 음수찾는 로직 추가
    if(numbers[i] < 0) {
        minus_list.add(k, numbers[i]);
        k++;
    }
}

// 배열에 움수가 있을 경우 처리되는 부분 - 없으면 생략
if(minus_list.size() > 0) {
    // 음수끼리 곱할때는 음수로 작은 값일수록 곱해졌을때 큰값이 나오므로 min값을 구한다.
    int minus_min = minus_list.get(0);
    // 리스트의 최대값과 두번째로 큰 값을 구하는 반복문
    for(int i = 0; i < minus_list.size(); i++) {
        if(minus_min > minus_list.get(i)) minus_min = minus_list.get(i);
    }


    int minus_min2 = minus_list.get(0) + 1;
    for(int i = 0; i < minus_list.size(); i++) {
        if(minus_min2 > minus_list.get(i) && minus_min != minus_list.get(i)) {
            minus_min2 = minus_list.get(i);
        }
    }
    compare2 = minus_min * minus_min2;
}

// 두번째로 큰 최대값을 구하는 반복문
int max2 = Integer.MIN_VALUE;

for(int i = 0; i < numbers.length; i++) {
    if(max2 < numbers[i] && max != numbers[i]) max2 = numbers[i];
}

int compare1 = max * max2;

// 삼항연산자로 마이너스 값끼리 곱한 값과 기존 max를 구하는 로직의 크기 비교 후 반환
// 만약 배열에 음수가 존재하지 않으면 초기 설정값 그대로 0으로 비교되므로 무조건 compare1이 반환됨
answer = (compare1 > compare2) ? compare1 : compare2;

return answer;

배열에 음수가 있을 경우를 조건문에 넣어 일반적인 경우에서는 음수처리로직이 작동되지 않도록 하였다.

하지만 이번에도 테스트케이스 4번을 통과하지 못하였다. 추후 리팩토링이 필요할 것 같았다.

Solution 1)

        int[] copy_arr = new int[numbers.length];
        
        int count = 0;
        
        for(int test : numbers) {
        	if(test < 0) {
        		// 음수 개수 카운트를 세어 하나이면 연산하지 않아도되고,
        		// 둘이상이면 연산을 해야함
        		count++;
        	}
        	
        }
        
        // 배열요소가 모두 양수일 경우
        if(0 <= count && count <= 1) {
        	System.out.println("count가 " + count + "회 이므로, \n일반 numbers = " + Arrays.toString(numbers) + "를 정렬합니다.");
        	Arrays.sort(numbers);
        	System.out.println("정렬결과 = " + Arrays.toString(numbers));
        	
        	answer = numbers[numbers.length - 1] * numbers[numbers.length - 2];
        }
        
        // 음수 요소가 있을경우 처리 로직
        else if(2 <= count) {
        	
        	// 절대값 처리 후 copy 배열에 넣어줌
        	for(int i = 0; i < numbers.length; i++) {
        		copy_arr[i] = Math.abs(numbers[i]);
        	}
        	
        	System.out.println("count가 " + count + "회 이므로, \n음수포함 numbers = " + Arrays.toString(numbers) + "를 정렬합니다.");
        	Arrays.sort(copy_arr);
        	System.out.println("정렬결과 = " + Arrays.toString(copy_arr));
        	
        	answer = copy_arr[copy_arr.length - 1] * copy_arr[copy_arr.length - 2];
        	
        }
        return answer;
    }

Arrays.sort를 활용하여, count로 음수요소의 개수를 세고, 2개이상일 경우에만 예외적으로 처리할 로직을 

새로 작성하였다.

---

<전체코드>

public class make_max {
	
	public static int solution(int[] numbers) {
        int answer = 0;
        int[] copy_arr = new int[numbers.length];
        
        int count = 0;
        
        for(int test : numbers) {
        	if(test < 0) {
        		// 음수 개수 카운트를 세어 하나이면 연산하지 않아도되고,
        		// 둘이상이면 연산을 해야함
        		count++;
        	}
        	
        }
        
        // 배열요소가 모두 양수일 경우
        if(0 <= count && count <= 1) {
        	System.out.println("count가 " + count + "회 이므로, \n일반 numbers = " + Arrays.toString(numbers) + "를 정렬합니다.");
        	Arrays.sort(numbers);
        	System.out.println("정렬결과 = " + Arrays.toString(numbers));
        	
        	answer = numbers[numbers.length - 1] * numbers[numbers.length - 2];
        }
        
        // 음수 요소가 있을경우 처리 로직
        else if(2 <= count) {
        	
        	// 절대값 처리 후 copy 배열에 넣어줌
        	for(int i = 0; i < numbers.length; i++) {
        		copy_arr[i] = Math.abs(numbers[i]);
        	}
        	
        	System.out.println("count가 " + count + "회 이므로, \n음수포함 numbers = " + Arrays.toString(numbers) + "를 정렬합니다.");
        	Arrays.sort(copy_arr);
        	System.out.println("정렬결과 = " + Arrays.toString(copy_arr));
        	
        	answer = copy_arr[copy_arr.length - 1] * copy_arr[copy_arr.length - 2];
        	
        }
        return answer;
    }
	
	public static void main(String[] args) {
		//int[] numbers = {1,2,3,4,5};
		//int[] numbers = {0, 31, 24, 10, 1, 9};
		int[] numbers = {-9, 1, -3, -2, -8, 7};
		
		System.out.println(solution(numbers));
	}

}

---

근래 풀었던 알고리즘 중 가장 많은 시도를하고 힘들었던 문제였던 것 같다. 문제는 간단했지만, 음수가 있을 수도 있다는 조건 하에 효과적으로 처리할 코드를 작성하는 것이 주요했다.

다시말해 배열 중 원소 두개를 곱해 만들 수 있는 최대값 구하기가

음수 두개이상 있을 경우에도 예외처리, 음수가 한개만 있을때에도 예외처리해주어야했기때문에 번거로웠던 것 같다.

---

문제링크)
https://school.programmers.co.kr/learn/courses/30/lessons/120847

프로그래머스