프로그래머스 - 369 게임
•
나의 풀이 - 에러 발생
class Solution {
public int solution(int order) {
int answer = 0;
String strOrder = String.valueOf(order);
for (int i = 0; i < strOrder.length(); i++) {
if ((strOrder.charAt(i) - '0') % 3 == 0) {
answer++;
}
}
return answer;
}
}
Java
복사
class Solution {
public int solution(int order) {
int answer = 0;
String strOrder = String.valueOf(order);
for (int i = 0; i < strOrder.length(); i++) {
if ((Character.getNumericValue(strOrder.charAt(i))) % 3 == 0) {
answer++;
}
}
return answer;
}
}
Java
복사
•
정답 풀이
class Solution {
public int solution(int order) {
int answer = 0;
String strOrder = String.valueOf(order);
for (int i = 0; i < strOrder.length(); i++) {
if ((Character.getNumericValue(strOrder.charAt(i))) == 3) {
answer++;
} else if ((Character.getNumericValue(strOrder.charAt(i))) == 6) {
answer++;
} else if ((Character.getNumericValue(strOrder.charAt(i))) == 9) {
answer++;
}
}
return answer;
}
}
Java
복사
백준 2309 - 일곱 난쟁이
•
나의 풀이 1차 - 틀렸습니다
package week4.backjoon;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
// 2309번 - 일곱 난쟁이
public class Backjoon2309 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int[] arr = new int[9];
for (int i = 0; i < arr.length; i++) {
arr[i] = Integer.parseInt(br.readLine());
}
Arrays.sort(arr);
int sum = 0;
int idx = 0;
int result_sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
result_sum = sum - 100; // 100이 나오도록 하는 수를 확인
int start_idx = 0; // 시작 인덱스
int end_idx = 1; // 끝 인덱스
int fake_dwart1 = 0; // 가짜 난쟁이 1
int fake_dwart2 = 0; // 가짜 난쟁이 2
while (true) {
if (arr[start_idx] + arr[end_idx] == result_sum) { // 비교
fake_dwart1 = arr[start_idx];
fake_dwart2 = arr[end_idx];
break;
} else {
if (end_idx == arr.length - 1) { // 끝 인덱스에 도달하면, 시작 인덱스 증가 + 끝 인덱스를 (시작 인덱스 + 1)
start_idx++;
end_idx = start_idx + 1;
} else {
end_idx++;
}
}
}
for (int i = 0; i <= arr.length - 2; i++) {
if (arr[i] == fake_dwart1 || arr[i] == fake_dwart2) { // 가짜 난쟁이 요소들은 제외하고 배열에 담기
continue;
}
System.out.println(arr[i]);
}
}
}
Java
복사
•
정답 풀이
package week4.backjoon;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
// 2309번 - 일곱 난쟁이
public class Backjoon2309 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int[] arr = new int[9];
for (int i = 0; i < arr.length; i++) {
arr[i] = Integer.parseInt(br.readLine());
}
Arrays.sort(arr);
int sum = 0;
int idx = 0;
int result_sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
result_sum = sum - 100; // 100이 나오도록 하는 수를 확인
int start_idx = 0; // 시작 인덱스
int end_idx = 1; // 끝 인덱스
int fake_dwart1 = 0; // 가짜 난쟁이 1
int fake_dwart2 = 0; // 가짜 난쟁이 2
while (true) {
if (arr[start_idx] + arr[end_idx] == result_sum) { // 비교
fake_dwart1 = arr[start_idx];
fake_dwart2 = arr[end_idx];
break;
} else {
if (end_idx == arr.length - 1) { // 끝 인덱스에 도달하면, 시작 인덱스 증가 + 끝 인덱스를 (시작 인덱스 + 1)
start_idx++;
end_idx = start_idx + 1;
} else {
end_idx++;
}
}
}
for (int i = 0; i < arr.length; i++) { // 배열의 길이만큼 수정
if (arr[i] == fake_dwart1 || arr[i] == fake_dwart2) { // 가짜 난쟁이 요소들은 제외하고 배열에 담기
continue;
}
System.out.println(arr[i]);
}
}
}
Java
복사
진료순서 정하기
•
풀이방법 고려
•
정답 풀이
package week4.programmers;
import java.util.Arrays;
public class DiagnosisOrder {
public int[] solution(int[] emergency) {
int[] answer = new int[emergency.length];
for (int i = 0; i < emergency.length; i++) {
int count = 1;
for (int j = 0; j < emergency.length; j++) {
if (emergency[i] >= emergency[j]) {
continue;
} else {
count++;
}
}
answer[i] = count;
}
return answer;
}
public static void main(String[] args) {
DiagnosisOrder T = new DiagnosisOrder();
int[] arr = new int[]{3, 76, 24};
System.out.println(Arrays.toString(T.solution(arr)));
}
}
Java
복사
•
다른 풀이
import java.util.*;
class Solution {
public int[] solution(int[] emergency) {
Map<Integer, Integer> map = new HashMap<>();
int[] emergencySort = Arrays.copyOfRange(emergency, 0, emergency.length);
Arrays.sort(emergencySort);
int size = emergency.length;
for(int i = 0; i < emergencySort.length; i++){
int e = emergencySort[i];
map.put(e, size - i);
}
for(int i = 0; i<emergency.length; i++){
emergency[i] = map.get(emergency[i]);
}
return emergency;
}
}
Java
복사
이중 for문을 사용하면 시간복잡도가 O(N^2)가 된다. 그러나 HashMap을 사용할 경우 시간복잡도는 O(NlogN) or O(n)수준으로 개선이 가능하다.
•
HashMap은 해시 테이블을 사용하기 때문에 원소를 찾는 과정이 훨씬 빠르다. 이중 for문을 통한 선형탐색보다 빠르다.
•
HashMap을 사용하면 값을 키로, 해당 값의 인덱스를 값으로 매핑시키는 것이 가능하다.
따라서, HashMap을 사용하여 원소의 값을 키로 하고, 해당 값의 인덱스를 값으로 매핑하는 방식으로 알고리즘을 개선하면 성능을 향상시킬 수 있다. 이렇게 하면 이중 반복문을 사용하는 것보다 훨씬 효율적인 코드를 구현할 수 있다.
프로그래머스 - 모의고사
•
나의 풀이 - 1차
import java.util.ArrayList;
import java.util.Collections;
class Solution {
public ArrayList<Integer> solution(int[] answers) {
int[] mathOne = {1, 2, 3, 4, 5};
int[] mathTwo = {2, 1, 2, 3, 2, 4, 2, 5};
int[] mathThree = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};
int mathOneCount = 0;
int mathTwoCount = 0;
int mathThreeCount = 0;
int start = 0; // 정답 배열 시작 인덱스
int mathOneStart = 0; // 1번 수포자 정답 배열 시작 인덱스
int mathTwoStart = 0; // 2번 수포자 정답 배열 시작 인덱스
int mathThreeStart = 0; // 3번 수포자 정답 배열 시작 인덱스
while (start < answers.length) {
if (mathOneStart == mathOne.length) {
mathOneStart = 0;
}
if (answers[start] == mathOne[mathOneStart]) {
mathOneCount++;
}
mathOneStart++;
if (mathTwoStart == mathTwo.length) {
mathTwoStart = 0;
}
if (answers[start] == mathTwo[mathTwoStart]) {
mathTwoCount++;
}
mathTwoStart++;
if (mathThreeStart == mathThree.length) {
mathThreeStart = 0;
}
if (answers[start] == mathThree[mathThreeStart]) {
mathThreeCount++;
}
mathThreeStart++;
start++;
}
ArrayList<Integer> list = new ArrayList();
if (mathOneCount != 0) {
list.add(1);
}
if (mathTwoCount != 0) {
list.add(2);
}
if (mathThreeCount != 0) {
list.add(3);
}
Collections.sort(list);
return list;
}
}
Java
복사
•
정답 풀이
package week4.programmers;
import java.util.ArrayList;
public class MockExam {
public int[] solution(int[] answers) {
int[] mathOne = {1, 2, 3, 4, 5};
int[] mathTwo = {2, 1, 2, 3, 2, 4, 2, 5};
int[] mathThree = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};
int[] count = {0, 0, 0}; // count 배열 선언
for (int i = 0; i < answers.length; i++) {
if (answers[i] == mathOne[i % 5]) { // 5개 기준 반복
count[0]++;
}
if (answers[i] == mathTwo[i % 8]) { // 8개 기준 반복
count[1]++;
}
if (answers[i] == mathThree[i % 10]) { // 10개 기준 반복
count[2]++;
}
}
int max = Math.max(Math.max(count[0], count[1]), count[2]); // 카운트 배열 요소 중에 최댓값 찾기
ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < count.length; i++) {
if (max == count[i]) { // count 배열 요소의 값과 최댓값이 같으면 list에 인덱스값을 추가
list.add(i); // i값을 추가, count 배열 값을 추가하는 것이 아님
}
}
int[] answer = new int[list.size()]; // list 사이즈 크기의 배열 선언
for (int i = 0; i < list.size(); i++) {
answer[i] = list.get(i) + 1; // 정답결과 출력을 위해 불러온 값에 1을 더해서 배열에 추가
}
return answer;
}
public static void main(String[] args) {
MockExam T = new MockExam();
System.out.println(T.solution(new int[]{1, 3, 2, 4, 2}));
}
}
Java
복사
달팽이
•
풀이과정
n = 3
arr[1][1] = 1; 1번째 => arr[arr.length / 2][arr.length / 2] = arr[1][1]
arr[0][1] = 2; 2번째 => 위 (-1, 0)
arr[0][2] = 3; 3번째 => 오른쪽 (0, 1)
arr[1][2] = 4; 4번째 => 아래 (1, 0)
arr[2][2] = 5; 5번째 => 아래 (1, 0)
arr[2][1] = 6; 6번째 => 왼쪽 (0, -1)
arr[2][0] = 7; 7번째 => 왼쪽 (0, -1)
arr[1][0] = 8; 8번째 => 위 (-1 ,0)
arr[0][0] = 9; 9번째 => 위 (-1, 0)
n = 5
arr[2][2] = 1; 1번째 => arr[arr.length / 2][arr.length / 2] = arr[1][1]
arr[1][2] = 2; 2번째 => 위 (-1, 0)
arr[1][3] = 3; 3번째 => 오른쪽 (0, 1)
arr[2][3] = 4; 4번째 => 아래 (1, 0)
arr[3][3] = 5; 5번째 => 아래 (1, 0)
arr[3][2] = 6; 6번째 => 왼쪽 (0, -1)
arr[3][1] = 7; 7번째 => 왼쪽 (0, -1)
arr[2][1] = 8; 8번째 => 위 (-1 ,0) 위쪽 3번
arr[1][1] = 9; 9번째 => 위 (-1, 0)
arr[0][1] = 10; 10번째 => 위 (-1, 0)
arr[0][2] = 11; 11번째 => 오른쪽 (0, 1) 오른쪽 3번
arr[0][3] = 12; 12번째 => 오른쪽 (0, 1)
arr[0][4] = 13; 13번째 => 오른쪽 (0, 1)
arr[1][4] = 14; 14번째 => 아래 (1, 0) 아래 4번
arr[2][4] = 15; 15번째 => 아래 (1, 0)
arr[3][4] = 16; 16번째 => 아래 (1, 0)
arr[4][4] = 17; 17번째 => 아래 (1, 0)
arr[4][3] = 18; 18번째 => 왼쪽 (0, -1) 왼쪽 4번
arr[4][2] = 19; 19번째 => 왼쪽 (0, -1)
arr[4][1] = 20; 20번째 => 왼쪽 (0, -1)
arr[4][0] = 21; 21번째 => 왼쪽 (0, -1)
arr[3][0] = 22; 22번째 => 위쪽 (-1, 0) 위쪽 4번
arr[2][0] = 23; 23번째 => 위쪽 (-1, 0)
arr[1][0] = 24; 24번째 => 위쪽 (-1, 0)
arr[0][0] = 25; 25번째 => 위쪽 (-1, 0)
Java
복사
package week4.backjoon;
import java.io.*;
// 달팽이
public class Backjoon1913 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int N = Integer.parseInt(br.readLine()); // N 입력
int targetNumber = Integer.parseInt(br.readLine()); // targetNumber 입력
int[][] arr = new int[N][N]; // 2차원 배열 생성
int row = N / 2; // 시작 행
int col = N / 2; // 시작 열
int limit = 1; // 이동 횟수
int value = 1; // 초기값
while (true) {
for (int i = 0; i < limit; i++) { // 5번째: 시작점(2, 0) 에 값을 넣어준 다음 위로 이동하여 남은 행에 값들을 증가시켜 넣어준다.
arr[row--][col] = value++; // 1번째: 시작점(1, 1) 에 값을 넣어준 다음 위로 이동하기 위해 행의 숫자를 감소시켜준다.
}
if (value - 1 == N * N) { // 처음 value가 1이었으므로 1을 빼준 값이 배열의 길이와 같으면(끝점에 도달했으면) 반복문을 빠져나간다.
break;
}
for (int i = 0; i < limit; i++) { // 2번째: 시작점(0, 1) 0행 1열의 값을 2로 증가시켜 준 다음 열의 숫자를 증가시켜주고 다음 턴으로 넘어간다.
arr[row][col++] = value++;
}
limit++; // 아래로 2번 이동시켜주기 위해 limit 값을 중가시켜준다.
for (int i = 0; i < limit; i++) { // 3번째: 시작점(0, 2) 0행 2열의 값을 3으로 증가시킨 다음 행을 2차례 이동함과 동시에 값을 증가시켜준다. (3, 4)
arr[row++][col] = value++;
}
for (int i = 0; i < limit; i++) {
arr[row][col--] = value++; // 4번째 시작점(2, 2)를 5로 바꿔준 다음 행을 감소시켜 (2, 1)의 값을 6으로 만들어준다.
}
limit++; // 나머지 3개 행의 값을 넣어주기 위해 반복횟수를 증가시켜준다. N이 5, 7일 때도 이와 같은 방식이 적용된다.
}
StringBuilder sb = new StringBuilder();
int trow = 0;
int tcol = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (targetNumber == arr[i][j]) {
trow = i + 1; // 행 + 1
tcol = j + 1; // 열 + 1
}
sb.append(arr[i][j]).append(" "); // append로 문자열 정리
}
sb.append("\n"); // 개행
}
sb.append(trow).append(" ").append(tcol);
System.out.println(sb.toString());
}
}
Java
복사
•
현 위치 (1, 1)
•
1번째 - (1, 1) 위치에 1 추가 (value++)
•
행 1 감소(row—), 열은 유지
0 | 2 | 3 |
0 | 1 | 0 |
0 | 0 | 0 |
•
2번째
◦
현 위치 (0, 1)
◦
현 위치에 2 추가 (value++)
◦
현 위치의 열 1 증가 (col++)
•
3번째 (1번 반복)
◦
제한 횟수 증가 (1 → 2), 아래로 2번 이동시켜주기 위함
◦
현 위치 (0, 2)
◦
현 위치에 3 추가 (value++)
◦
현 위치의 행 1 증가 (row++)
•
4번째 (2번 반복)
◦
현 위치 (1, 2)
◦
현 위치에 4 추가 (value++)
◦
현 위치의 행 1 증가 (row++)
•
5번째 (1번 반복)
◦
현 위치 (2, 2)
◦
현 위치에 5 추가 (value++)
◦
현 위치의 열 감소 (col—)
•
6번째 (2번 반복)
◦
현 위치 (2, 1)
◦
현 위치에 6 추가 (value++)
◦
현 위치의 열 감소 (col—)
•
7번째
◦
제한 횟수 증가 - 나머지 3개 행의 값을 넣어주기 위해 반복횟수 증가
◦
현 위치 (2, 0)
◦
현 위치에 7 추가
◦
현 위치 행 감소 (row—)
•
8번째
◦
현 위치 (1, 0)
◦
현 위치에 8 추가 (value++)
◦
현 위치 행 감소 (row—)
•
9번째
◦
현 위치 (0, 0)
◦
현 위치에 9 추가 (value++)
◦
현 위치 행 감소 (row—) ⇒ 행 인덱스 음수로 바뀜, 예외 처리 필요
•
최종 마무리
◦
만약에 N을 제곱한 값이 9와 같으면 반복문 빠져나옴