Java 과제 [배열]

최대, 최소, 평균, 분산, 표준편차

package me.day06.practice;

import java.util.Scanner;

public class Practice01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        final int STUDENTS = 10;
        int[] scores = new int[STUDENTS];

        for (int i = 0; i < scores.length; i++) {
            System.out.printf("[%d] 학생 성적 입력 = ", i + 1);
            scores[i] = scanner.nextInt();
        }

        System.out.println("max = " + max(scores));
        System.out.println("min = " + min(scores));
        System.out.println("average = " + average(scores));
        System.out.println("variance = " + variance(scores));
        System.out.println("standard = " + standard(scores));

        scanner.close();
    }
    public static int max(int[] scores) {
        int max = Integer.MIN_VALUE; // 최소값을 최대값으로 설정해놓고

        for (int i = 0; i < scores.length; i++) {
            if (scores[i] > max) { // 더 큰 수를 저장
                max = scores[i];
            }
        }
        return max;
    }
    public static int min(int[] scores) {
        int min = Integer.MAX_VALUE;

        for (int i = 0; i < scores.length; i++) {
            if (scores[i] < min) {
                min = scores[i];
            }
        }
        return min;
    }
    public static double average(int[] scores) {
        int sum = 0;

        for (int i = 0; i < scores.length; i++) {
            sum += scores[i];
        }
        return (double)sum / scores.length;
    }
    public static double variance(int[] scores) { // 분산
        double avg = average(scores);
        double dev = 0.0;

        for (int i = 0; i < scores.length; i++) {
            dev += Math.pow((scores[i]-avg), 2); // pow : (원소-평균)^2
        }
        dev /= scores.length; // 개수로 나누기
        return dev;
    }
    public static double standard(int[] scores) { // 표준편차
        return Math.sqrt(variance(scores)); // sqrt : aquare root (루트 씌우기)
    }
}

이차원 배열의 평균, 오름차순/내림차순

package me.day06.practice;

import java.util.Arrays;

public class Practice02 {
    public static void main(String[] args) {

        final int STUDENT_NUM = 5; // row
        final int SUBJECT_NUM = 3; // col

        String[] subjectsName = { "국어", "수학", "영어" };

        // 1. 주어진 테이블 저장하는 이차원 배열
        int[][] scores2d = { // 점수
                { 50,  60,  70},
                { 60,  76, 100},
                { 95,  88,  87},
                { 60,  65,  85},
                {100,  85,  77}
        };

        // 과목 이름 / 학생 번호도 같이 정렬하기 위해 인덱스 만들기
        int[] subjects = new int[SUBJECT_NUM];
        for (int i = 0; i < subjects.length; i++) {
            subjects[i] = i;
        }
        int[] students = new int[STUDENT_NUM];
        for (int i = 0; i < students.length; i++) {
            students[i] = i;
        }

        // 과목별/학생별 평균 구하기
        double[] subjectsAverage = calculateSubjectsAverage(scores2d);
        double[] studentsAverage = calculateStudentsAverage(scores2d);
        System.out.println("subject's average => " + Arrays.toString(subjectsAverage));
        System.out.println("student's average => " + Arrays.toString(studentsAverage));
        System.out.println();

        // 과목별 평균 내림차순
        sort(subjectsAverage, subjects, "descending");
        System.out.println("[ subject's average by descending order ]");
        for (int i = 0; i < subjects.length; i++) {
            System.out.printf("%12s | ", subjectsName[subjects[i]]); // 과목의 인덱스도 같이 출력
        }
        for (int i = 0; i < subjectsAverage.length; i++) {
            System.out.printf("%12f  | ", subjectsAverage[i]); // s: , f:
        }
        System.out.println("\n-----------------------------------------------");

        // 학생별 평균 오름차순
        System.out.println();
        sort(studentsAverage, students, "ascending");
        System.out.println("[ student's average by ascending order ]");
        for (int i = 0; i < students.length; i++) {
            System.out.printf("%10s  | ", students[i] + 1 + "번 학생"); // 학생의 인덱스도 같이 출력
        }
        for (int i = 0; i < studentsAverage.length; i++) {
            System.out.printf("%12f | ", studentsAverage[i]);
        }
    }


    // 2. 과목별 평균
    public static double[] calculateSubjectsAverage(int[][] scores2d) {
        double[] subjectAverage = new double[scores2d[0].length]; // 열의 개수

        for (int i = 0; i < scores2d[0].length; i++) { // col 고정
            int sum = 0;
            for (int j = 0; j < scores2d.length; j++) { // ROW 회전
                sum += scores2d[j][i]; // j = 행, i = 열
            }
            subjectAverage[i] = (double) sum / scores2d.length;
        }
        return subjectAverage;
    }

    // 3. 학생별 평균
    // 자바는 row-major : 각 행의 모든 열은 같은 주소에 연속되어(+4) 저장, 각 행은 연속되지 않을 수도 있다 (각 행의 첫번째 위치를 저장)
    // 순차적 접근(column-major) 이므로 더 빠르다
    // cache fit 에 적합 (cache : CPU가 다음 데이터를 예상하여 넣어놓는 곳, hit : 예상 적중)
    public static double[] calculateStudentsAverage(int[][] scores2d) {
        double[] studentsAverage = new double[scores2d.length]; // 행의 개수

        for (int i = 0; i < scores2d.length; i++) { // ROW 고정
            int sum = 0;
            for (int j = 0; j < scores2d[0].length; j++) { // col 회전
                sum += scores2d[i][j]; // i = 행, j = 열
            }
            studentsAverage[i] = (double) sum / scores2d[0].length;
        }
        return studentsAverage;
    }

    // 4. 내림차순/오름차순 wiht 과목이름/학생번호
//    Arrays.sort(array); // quicksort()로 구현됨
//    Arrays.sort(array, new Compa); // 안쓰고 정렬 해보기 : Timsort(), quicksort(), mergesort(), bubblesort(), insertsort(), ...
    // Timsort() : 들어오는 데이터가 완전히 무작위일 확률보다는 순서대로 들어올 확률이 높다 라는 개념에서 만들어짐. 다음에 들어올 데이터 예측하여 속도 절약. 현업에서 많이 사용됨

    public static int compare(String order) {
        return (order.equals("ascending")) ? 1 : -1;
    }

    public static void sort(double[] array, int[] index, String order) {
        int comp = compare(order); // 1 : ascending, -1 : descending

        // bubble sort : 배열의 앞뒤 원소를 비교하여 더 큰수를 뒤로 (첫번째 반복문에서 가장 큰 수가 맨뒤로 옴)
        // 외부 for문 : [원소의 개수-1]번 반복
        // 내부 for문 : 매 반복마다 수행문이 하나씩 줄어듬
        for (int i = array.length - 1; i > 0; i--) { // [원소의 개수-1]번 반복
            for (int j = 0; j < i; j++) {
                if ((array[j] - array[j + 1]) * comp > 0) { // 연속적인 두개의 원소 중 앞의 원소가 더 크다면 // comp : 내림차순까지 한번에 구현하기 위함 (더 작은수 뒤로 보내기)
                    double value = array[j]; // 앞의 원소 빈컵에 담아 두고
                    array[j] = array[j + 1]; // swap
                    array[j + 1] = value;

                    // swap 될때마다 인덱스도 같이 뒤로 보내기
                    int idx = index[j];
                    index[j] = index[j + 1];
                    index[j + 1] = idx;
                }
            }
        }
    }
}

boj1157 단어공부

package me.day06.practice;

import java.io.*;

public class Practice03 { // boj1157 단어공부 (가장 많이 입력된 알파벳을 대문자로 출력)
    public static void main(String[] args) throws IOException {
        // 입력 받기
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
        String word = bufferedReader.readLine().toLowerCase();

        // 'z' - 'a' = 25개 <-> 'a' <= < 'z' (알파벳 총 26개)
        int[] counts = new int['z' - 'a' + 1]; // 0 으로 초기화
        char[] alpha = new char['z' - 'a' + 1];

        // a ~ z 넣기
        for (int i = 0; i < alpha.length; i++) {
            alpha[i] = (char)('a' + i); // i = 0~25
        }

        // 입력 받은 word 에서 각 문자별 빈도수 체크 (알파벳, 인덱스 모두 연속적이므로 ++ 하여 카운팅 가능)
        for (int i = 0; i < word.length(); i++) {
            counts[word.charAt(i) - 'a']++; // word = aaz 라면 -> counts[0] = 2, counts[25] = 1
        }

        // 최대값
        int max = -1;
        String popular = "";
        for (int i = 0; i < counts.length; i++) {
            if (counts[i] > max) {
                max = counts[i];
                popular = Character.toString(alpha[i]).toUpperCase();
            } else if (counts[i] == max) {
                popular = "?";
            }
        }

        // 출력
        bufferedWriter.write(popular);
        bufferedWriter.flush();
        bufferedWriter.close();
        bufferedReader.close();
    }
}

boj8958 OX퀴즈

package me.day06.practice;

import java.io.*;

public class Practice04 { // boj8958 OX퀴즈 ("OOXXOXXOOO" -> 1+2+0+0+1+0+0+1+2+3 = 10점)
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
        int N = Integer.parseInt(bufferedReader.readLine()); // 테스트 케이스의 개수

        for (int i = 0; i < N; i++) {
            String score = bufferedReader.readLine(); // 문자열 입력
            int count = 0;
            int sum = 0;
            for (int j = 0; j < score.length(); j++) {
                if (score.charAt(j) == 'O') {
                    count++;
                } else {
                    count = 0; // X 나오면 초기화
                }
                sum += count; // 누적
            }
            bufferedWriter.write(sum + "\n");
        }

        bufferedWriter.flush();
        bufferedWriter.close();
        bufferedReader.close();
    }
}

/*
socre : O O X X O X X O O O
count : 1 2 0 0 1 0 0 1 2 3
sum :   1 3 3 3 4 4 4 5 7 10
 */

programmers [1차] 비밀지도

1. 십진수로 비트 연산
2. 이진수로 변환
3. 문자열로 변환
4. "0" 패딩
5. replace ("1"->"#", "0"->"")

package me.day06.practice;

import java.math.BigInteger;
import java.util.Arrays;

class Solution1 { // programmers [1차]비밀지도
    public String[] solution(int n, int[] arr1, int[] arr2) {
        String[] answer = new String[n]; // n : 원소의 개수
        for (int i = 0; i < n; i++) {
            // 십진수로 비트연산 -> 이진수로 변환 -> 문자열로 변환
            String binaryString = Long.toBinaryString(arr1[i] | arr2[i]);

            binaryString = String.format("%" + n + "s", binaryString); // 5 == 101(2) -> 101 앞에 0을 5개 패딩 (비트 수 맞추기)
            binaryString = binaryString.replace("1", "#"); // "1" -> "#"
            binaryString = binaryString.replace("0", " "); // "0" -> " "
            answer[i] = binaryString;
        }

        return answer;
    }
}

class Solution2 {
    public String[] solution(int n, int[] arr1, int[] arr2) {
        String[] answer = new String[n];

        for (int i = 0; i < n; i++) {
            String binaryString = Integer.toBinaryString(arr1[i] | arr2[i]);

            // 문자열을 이진수로 바꾼뒤 0 패딩 (%d)
            binaryString = String.format("%" + "0" + n + "d", new BigInteger(binaryString)); // 원소의 개수 <= 2^n - 1 이면 int 넘어갈수 있으므로 BigInteger()
            binaryString = binaryString.replace("1", "#");
            binaryString = binaryString.replace("0", " ");
            answer[i] = binaryString;
        }

        return answer;
    }
}

public class Practice05 {
    public static void main(String[] args) {
        String[] answer1 = new Solution1().solution(6,
                new int[] {65535, 65535, 65535, 65535, 65535, 65535},
                new int[] {65535, 65535, 65535, 65535, 65535, 65535});
        System.out.println(Arrays.toString(answer1));

        String[] answer2 = new Solution2().solution(6,
                new int[] {65535, 65535, 65535, 65535, 65535, 65535},
                new int[] {65535, 65535, 65535, 65535, 65535, 65535});
        System.out.println(Arrays.toString(answer2));
    }
}

<BigInteger() 쓰는 이유>

• 1 ≦ n ≦ 16
• 최대 비트값 : 1111111111111111 (16bit)
• toBinaryString() 통해 문자열로 변환하면 16byte ("1111111111111111")
  (문자 하나: '1' (1 byte), '가' (2 byte) 이므로)
• 16byte 사용하려면 int는 부족하기 때문

<new BigInteger(binaryString) 대신 Long.parseLong(binaryString)>

• long 도 부족