konjee's devlog

int level;          //정수형 변수 level을 선언
level = 10;         //값 10을 level 변수에 대입

int level = 10;     //level 변수 선언과 동시에 값을 대입(초기화)

int iNum = 10;
byte bNum = (byte)iNum;     //강제로 형을 바꾸려면 바꿀 형을 괄호로 써서 명시해야 함

double dNum = 3.14;
int iNum2 = (int)dNum;      //실수 자료형 double을 정수 자료형 int로 형 변환

if (조건식) {
    수행문;        //조건식이 참일 경우에 이 문장을 수행
}

if (조건식) {
    수행문1;       //조건식이 참일 경우에 이 문장을 수행
} else {
    수행문2;        //조건식이 거짓일 경우에 이 문장을 수행
}

if (조건식) {
    수행문1;      //조건식1이 참일 경우에 수행함
} else if (조건식2) {
    수행문2;      //조건식2가 참일 경우에 수행함
} else if (조건식3) {
    수행문3;       //조건식3이 참일 경우에 수행함
} else {
    수행문4;       //위의 조건이 모두 해당하지 않는 경우에 수행함
}
수행문5;         //if-else if-else문이 끝난 후 수행함

max = (a > b) ? a : b;

switch(조건){
        case 값1:수행문1;
        break;
        case 값2:수행문2;
        break;
        case 값3:수행문3;
        break;
default:수행문4;
        }

case 1: case 3: case 5: case 7: case 8: case 10: case 12: day = 31;
        break;
case 4: case 6: case 9: case 11: day = 30;
        break;
case 2: day = 28;
        break;

4. 반복문

(1) while문

- 조건식이 참이 동안 수행문을 반복해서 수행

int num = 1;        //초기화
int sum = 0;
while (num <= 10){  //조건 비교
    sum += num;
    num++;          //증감식
}

(2) do-while문

- { } 안의 문장을 무조건 한 번 수행 한 후에 조건식을 검사

- 조건이 만족하는지 여부를 마지막에 검사

do {
    수행문;
    ...
} while (조건식);
    수행문2;
    ...

(3) for문

//홀수일 때만 더하고 짝수일 때는 더하지 않는 프로그램
int total = 0;
int num;

for (int num = 0; num <= 100; num++) {      //100까지 반복
    if (num % 2 == 0)                       //num값이 짝수인 경우
        continue;                           //이후 수행을 생략하고 num++ 수행
    total += num;                           //num값이 홀수인 경우에만 수행
}
//변수 num이 짝수일 때는 이후 수행을 생략하고 for문의 증감식으로 돌아가서 num에 1을 더함
//num이 홀수일 때는 계속 진행(continue)해서 total += num; 문장을 수행

int sum = 0;
int num = 0;
//0부터 시작해서 숫자를 1씩 늘리면서 합을 계산할 때 숫자를 몇까지 더하면 100이 넘는지
for (num = 0; ; num++) {    //조건식을 생략하는 대신 break문을 사용
    sum += num;
    if (sum >= 100)         //sum이 100보다 크거나 같을 때(종료 조건)
        break;              //반복문 중단
}

4.배열

(1) 배열

- 배열: 자료가 연속적으로 나열된 자료 구조

int[] studentIDs = new int[10];     //int형 요소가 10개인 배열 선언

//알파벳 문자와 아스키 코드 값 출력하기
char[] alphabets = new char[26];
char ch = 'A';

for (int i = 0; i < alphabets.length; i++, ch++) {
    alphabets[i] = ch;      //아스키 값으로 각 요소에 저장
}

for (int i = 0; i < alphabets.length; i++) {
    System.out.println(alphabets[i] + "," + (int) alphabets[i]);
}

-  배열 복사하기: for문 반복 복사,  System.arraycopy( ) 메서드

System.arraycopy(array1, 0, array2, 1, 4);
// (복사할 배열, 복사할 첫 위치, 대상 배열, 붙여 넣을 첫 위치, 복사할 요소 개수)

- 얕은 복사/깊은 복사

- 향상된 for문과 배열: 배열의 처음에서 끝까지 모든 요소를 참조할 때 사용하면 편리 

String[] strArray = {"Java", "Android", "C", "JavaScript", "Python"};

for (String lang : strArray) {
    System.out.println(lang);
}

(2) 다차원 배열

- 조건식이 참

(3) ArrayList

- 조건식이 참

import java.util.stream.IntStream;

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

        //1. 팩토리얼
        System.out.println("== 팩토리얼 ==");
        //5!
        int n = 5;
        int result = 1;

        for (int i = 1; i <= n; i++) {
            result *= i;
        }
        System.out.println("result = " + result);
        //스트림으로도 구현
        //**reduce: 스트림의 요소를 하나씩 줄여가며 누적연산 수행
        System.out.println(IntStream.range(2, 6).reduce(1, (x, y) -> (x * y)));

        //2. 순열
        System.out.println("== 순열 ==");
        //5명을 3줄로 세우는 경우의 수
        n = 5;
        int r = 3;
        result = 1;

        for (int i = n; i >= n - r + 1; i--) {
            result *= i;
        }
        System.out.println("result = " + result);

        //3. 중복 순열
        System.out.println("== 중복 순열 ==");
        //서로 다른 4개의 수 중 2개를 뽑는 경우의 수(중복 허용)
        n = 4;
        r = 2;
        result = 1;

        for (int i = 0; i < r; i++) {
            result *= n;
        }
        System.out.println("result = " + result);
        //Math.pow(): 거듭 제곱 구하기
        System.out.println(Math.pow(n, r));

        //4. 원 순열
        System.out.println("== 원 순열 ==");
        //원 모양의 테이블에 3명을 앉히는 경우의 수
        n = 3;
        result = 1;

        for (int i = 1; i < n; i++) {
            result *= i;
        }
        System.out.println("result = " + result);

    }
}

//조합
public class Combination {

    static int getCombination(int n, int r) {
        int pResult = 1;
        for (int i = n; i >= n - r + 1; i--) {
            pResult *= i;
        }

        int rResult = 1;
        for (int i = 1; i <= r; i++) {
            rResult *= i;
        }

        return pResult / rResult;
    }

    public static void main(String[] args) {
        //1. 조합
        System.out.println("==조합==");
        //서로 다른 4명 중 주번 2 명 뽑는 경우의 수
        int n = 4;
        int r = 2;

        int pResult = 1;
        for (int i = n; i >= n - r + 1; i--) {
            pResult *= i;
        }

        int rResult = 1;
        for (int i = 1; i <= r; i++) {
            rResult *= i;
        }
        System.out.println("결과: " + pResult / rResult);

        //2. 중복 조합
        System.out.println("==중복 조합==");
        //후보 2명, 유권자 3명일 때 무기명 투표 경우의 수
        n = 2;
        r = 3;

        System.out.println("결과: " + getCombination(n + r - 1, r));

    }
}

//점화식과 재귀함수
public class Recursion {

    //1, 3, 9, 27, ...의 n번째 수
    static int recursion1(int n) {
        if (n == 1) {
            return 1;
        }
        return 3 * recursion1(n - 1);
    }

    //1, 2, 3, 4, 5, 6, ...의 n번째까지의 합
    static int recursion2(int n) {
        if (n == 1) {
            return 1;
        }
        return n + recursion2(n - 1);
    }

    //1, 1, 2, 3, 5, 8, 13, ...의 n번째 수
    static int recursion3(int n) {
        if (n == 1 || n == 2) {
            return 1;
        }
        return recursion3(n - 2) + recursion3(n - 1);
    }

    public static void main(String[] args) {
        int n = 5;
        System.out.println(recursion1(n));
        System.out.println(recursion2(n));
        System.out.println(recursion3(n));
    }
}

//지수와 로그
public class Log {
    public static void main(String[] args) {
        //1. 제곱, 제곱근, 지수
        System.out.println("[제곱]");
        System.out.println(Math.pow(2, 3));
        System.out.println(Math.pow(2, -3));
        System.out.println(Math.pow(-2, -3));
        System.out.println(Math.pow(2, 30));
        System.out.printf("%.0f\n", Math.pow(2, 30));

        System.out.println("[제곱근]");
        System.out.println(Math.sqrt(16));
        System.out.println(Math.pow(16, 1.0 / 2));
        System.out.println(Math.pow(16, 1.0 / 4));

        System.out.println("[절대값]");
        System.out.println(Math.abs(5));
        System.out.println(Math.abs(-5));

        //2. 로그
        System.out.println("[로그]");
        System.out.println(Math.E);
        System.out.println(Math.log(2.718281828459045));
        System.out.println(Math.log10(1000));
        System.out.println(Math.log(4) / Math.log(2));
    }
}

class Solution {
    public int solution(int num1, int num2) {
        int answer = num1%num2;
        return answer;
    }
}

class Solution {
    public int solution(int num1, int num2) {
        int answer = 0;
        if (num1 == num2) {
            answer = 1;
        } else {
            answer = -1;
        }
        return answer;
    }
}

class Solution {
    public int solution(int angle) {
        int answer = 0;
        if (0 < angle && angle < 90) {
            answer = 1;
        } else if (angle == 90) {
            answer = 2;
        } else if (90 < angle && angle < 180) {
            answer = 3;
        } else if (angle == 180) {
            answer = 4;
        }
        return answer;
    }
}

class Solution {
    public int solution(int n) {
        int answer = 0;
        for (int i = 0; i <= n; i++) {
            if (i % 2 == 0) {
                answer += i;
            }
        }
        return answer;
    }
}

import java.util.Arrays;

class Solution {
    public double solution(int[] numbers) {
        double answer = 0;
        for (int i = 0; i < numbers.length; i++) {
            answer += numbers[i];
        }
        return answer / numbers.length;
    }
}

class Solution {
    public int solution(int n, int k) {
        int answer = 0;
        k -= n / 10;
        answer = 12000 * n + 2000 * k;
        return answer;
    }
}

import java.util.Arrays;

class Solution {
    public int solution(String message) {
        int answer = 0;
        char[] arr = message.toCharArray();
        answer = 2 * arr.length;
        return answer;
    }
}

class Solution {
    public int[] solution(int money) {
        int[] answer = new int[2];
        answer[0] = money / 5500;
        answer[1] = money % 5500;
        return answer;
    }
}

class Solution {
    public int solution(int n) {
        int answer = 0;
        if (n % 7 == 0) {
            answer = n / 7;
        } else {
            answer = 1 + n / 7;
        }
        return answer;
    }
}

class Solution {
    public int solution(int[] dot) {
        int answer = 0;
        if (dot[0] >= 0 && dot[1] >= 0) {
            answer = 1;
        } else if (dot[0] < 0 && dot[1] >= 0) {
            answer = 2;
        } else if (dot[0] < 0 && dot[1] < 0) {
            answer = 3;
        } else if (dot[0] >= 0 && dot[1] < 0) {
            answer = 4;
        }
        return answer;
    }
}

class Solution {
    public int[] solution(String[] strlist) {
        int[] answer = new int[strlist.length];
        for (int i = 0; i < answer.length; i++) {
            answer[i] = strlist[i].length();
        }

        return answer;
    }
}

import java.util.Arrays;

class Solution {
    public int solution(int[] array, int n) {
        int answer = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] == n) {
                answer++;
            }
        }
        return answer;
    }
}

import java.util.Arrays;

class Solution {
    public int solution(int[] array, int height) {
        int answer = 0;
        Arrays.sort(array);
        for (int i = 0; i < array.length; i++) {
            if (array[i] > height) {
                answer++;
            }
        }
        return answer;
    }
}

class Solution {
    public int[] solution(int n) {
        int[] answer = new int[(n + 1) / 2];
        for (int i = 0; i < answer.length; i++) {
            if (i + 1 % 2 != 0) {
                answer[i] = 2 * i + 1;
            }
        }
        return answer;
    }
}

class Solution {
    public int solution(int price) {
        int answer = 0;
        if (price >= 500000) {
            answer = (int) (price * 0.8);
        } else if (price >= 300000) {
            answer = (int) (price * 0.9);
        } else if (price >= 100000) {
            answer = (int) (price * 0.95);
        } else {
            answer = price;
        }
        return answer;
    }
}