코틀린은 Google I/O 2017에서 안드로이드의 공식 언어로 채택되었다. 그리고 이번에 다양한 회사에서 이제 코틀린으로 어플리케이션을 개발하고 있다. 필자는 Java를 통해 Android 개발을 하고 있었지만, 코틀린으로 개발하는 방향으로 코틀린 공부를 시작하였다.

• 표현력이 높고 간결함: 적은 노력으로 많은 작업을 할 수 있습니다. 상용구 코드를 적게 사용하면서도 아이디어를 풍부하게 표현할 수 있습니다. Kotlin을 사용하는 전문 개발자 중 67%가 Kotlin을 통해 생산성이 높아졌다고 말합니다.
• 더 안전한 코드: Kotlin에는 null 포인터 예외와 같은 일반적인 프로그래밍 실수를 방지하는 데 도움이 되는 여러 언어 기능이 있다. Kotlin 코드가 포함된 Android 앱은 다운될 가능성이 20% 낮다.
• 호환성: Kotlin에서 자바 기반 코드를 호출하거나 자바 기반 코드에서 Kotlin을 호출한다. Kotlin은 자바 프로그래밍 언어와 100% 호환되므로 프로젝트에서 Kotlin을 원하는 만큼 사용할 수 있다.
• 구조화된 동시 실행: Kotlin 코루틴을 사용하면 비동기 코드를 차단 코드처럼 쉽게 사용할 수 있다. 코루틴은 네트워크 호출부터 로컬 데이터 액세스에 이르기까지 백그라운드 작업 관리를 크게 단순화한다.

👉 기본 문법

• 코틀린은 ;을 사용하지 않고, 아래와 같이 변수 타입이 뒤에 붙는 형태이다.
• 변수 타입을 지정하지 않을 수 도 있다.

  //java
  int x = 10;

  //kotlin
  val x: Int = 10
  var x = 15

👉 기본 문법1 : var, val

코틀린에는 2가지 변수 선언 방식이 존재한다.

• var : 일반적인 변수(값이 변경 가능하다.)
• val : 변할 수 없는 상수(자바에서 final과 같다.)

val는 변할 수 없는 상수로 로컬 변수이다. 즉, 초기화 이후에는 값을 변경할 수 없다. 그리고 val는 꼭 초기화를 해주어야 한다.

//int 타입으로 x변수를 10으로 초기화
val x: Int = 10

//val 타입은 변수의 값 변경이 불가하여 오류가 발생
x = 15

//val 타입은 초기화 해주지 않으면 오류가 발생
val x: Int

var는 일반적인 변수로 변수의 값을 변경할 수 있다.

//int 타입으로 x 변수를 10으로 초기화
var x : Int = 10

//var 타입은 변수의 값을 변경 가능
x = 15

👉 기본 문법2 : 함수 생성

자바의 경우 아래와 같이 함수를 생성한다.

public int sum(int a, int b){
    return a+b;
}

코틀린의 경우 아래와 같이 함수를 생성한다.

fun sum(a: Int, b: Int): Int{
    return a+b
}

좀 더 단순하게 생성할 수도 있다.

fun sum(a: Int, b: Int) = a+b // 타입을 생략하여 바로 return 할 수도 있다.

함수에 조건식을 추가하면 아래와 같이 표현이 가능하다.

fun min(a: Int, b: Int) = if(a > b) b else a

👉 기본 문법3 : 코틀린에서 null 값

코틀린의 기본 변수는 null을 가질 수 없다. 따라서 null 값을 사용하기 위해 추가적인 작업이 필요하다.

아래와 같이 x에 null 값을 넣어주면 오류가 발생하지만, y와 같이 ?를 추가해주면 null이 가능한 변수임을 명시해줄 수 있다.

var x: Int = 10
x= null // 오류 발생

var y: Int? = 10
y = null // 정상 수행

코틀린은 null을 안전하게 사용하기 위해 ?.연산자를 사용한다. 자바에서 if(str != null) return str.toUpperCase() else return null 과 같은 것이다.

val str = "abc"

// ?.앞의 변수가 null이 아닐 때만 함수가 실행되고 앞의 변수가 null이면 null을 반환
println(str?.toUpperCase()) 

nullable로 !!도 존재하는데, !!는 강제로 null이 아님을 선언하는 것이다. 즉, !!를 사용하면 x는 이후부터 not null로 인식한다. 하지만 그 값이 null이면 Null Point Exception이 발생한다.

val s: String? = null
val x: String = s!!

👉 기본 문법4 : loop 반복문

코틀린에서 for 반복문은 자바와 비슷하다.

//java
ArrayList<String> arrayList = new ArrayList<>();
for(Stirng str: arrList){
    System.out.println(str);
}

//kotlin
var arrayList: ArrayList<String> = ArrayList<>()
for(str in arrayList){
    println(str)
}

• range for 문

  //java
  for(int i=0; i<5; i++){
    System.out.println(i);
  }

  //kotlin
  

// 1에서 5까지 출력 for(i in 1..5){ println(i) }

// 역순으로 5부터 1까지 출력 for(i in 5 downTo 1){ println(i) }

// 일정 간격으로 출력 for(i in 1..5 step 2){ println(i) }

// 끝 번호 제외하고 출력 for(i in 1 until 5){ println(i) }

## 👉 기본 문법5 : if, when 조건문

> 코틀린에서 if문은 자바와 거의 동일하다.

```kotlin
val x = 10
val y = 15

if(x < y) println(true)

코틀린에서 when은 자바의 switch문과 동일하다.

//java
int x = 5;

switch(x){
    case 1:
        System.out.println("1");
        break;
    case 5:
        System.out.println("5");
        break;
    default:
        break;
}

//kotlin
val x = 5

when(x){
    1 -> println("1")
    5 -> println("5")
    else -> println("10")
}

정리

코틀린의 기본 문법에 대해 공부해보고 자바랑 어떻게 다른지에 대해 알게 되었다. 확실히 자바를 사용할 때보다 코드의 수가 많이 줄 것 같다는 것을 체감할 수 있었다.

문제풀이

이 문제는 Stack 클래스를 사용할 줄 알면 굉장히 쉽게 풀 수 있는 문제이다.

1. 입력 받은 K 수 만큼 숫자를 입력 받는다.
2. 입력 받은 숫자가 0이냐 아니냐 라는 조건에 따라 push를 해주고 pop을 해준다.
3. 마지막 숫자를 입력받고 난 뒤의 스택의 모든 값의 합을 구해준다.

소스 코드

package data_structure;

import java.util.Iterator;
import java.util.Scanner;
import java.util.Stack;

public class stack_zero {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        Stack<Integer> stack = new Stack<>();
        int k = in.nextInt();
        int sum = 0;

        for(int i = 0; i<k; i++){
            int input = in.nextInt();

            if(input != 0){
                stack.push(input);
            }
            else if(input == 0) {
                stack.pop();

            }


        }
        Iterator<Integer> iter = stack.iterator();
        while(iter.hasNext()) {
            sum += iter.next();
        }
        System.out.println(sum);
    }

}

정리

• 이제 Stack을 이용하는 문제에 대해서는 어려움 없이 문제를 풀 수 있을 것 같다.

문제풀이

*이 문제는 숫자를 분해하여 조합해야하는 완전 탐색 문제이다. *

1. 1부터 입력받은 N 까지 한 개씩 모두 대입해본다.
2. 만약 탐색 도중 생성자를 찾으면 종료하고 해당 생성자를 출력하며, N을 넘길 때 까지 찾지 못하면 0을 출력하면 된다.

소스 코드

package brute_force;

import java.util.*;

public class digit_generator {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner in = new Scanner(System.in);

        int N = in.nextInt();
        int answer = 0;

        for(int i = 0; i<N; i++) {
            int number = i;
            int sum = 0;

            while(number != 0) {
                sum += number %10;
                number = number/10;
            }
            if((sum + i) == N) {
                answer = i;
                break;
            }
        }
        System.out.println(answer);
    }

}

정리

• 다들 브루트 포스 문제는 그렇게 어렵지 않게 풀 수 있을 것이다. 완전 탐색 알고리즘만 구현하고 만족하는 값을 찾을 때 까지 돌리면 되기 때문이다. 하지만 같은 같은 브루트 포스 알고리즘이라고 불가능한 범위를 제외시키면 성능을 향상 시킬 수 있으니 그 부분을 고려해보는 과정이 중요할 것 같다.

문제풀이

브루트 포스 문제는 완전 탐색으로써 모든 경우를 다 확인하여 구하는 알고리즘이다. 이 문제 역시 모든 경우의 수를 확인하여 푸는 문제이다.

1. 입력 받은 N만큼의 사이즈를 가진 배열을 선언해준다.
2. 그 배열에 두번째 줄에 입력받은 수를 넣어주고 3개씩 모든 경우의 수를 조합한다.
3. 조합한 3개의 수의 합을 조합할 때마다 최대의 수로 갱신해주고 그 값을 입력 받은 M의 값과 비교하여 그 수를 넘지않는 최대한 가까운 수를 구한다.

소스 코드

package brute_force;

import java.util.*;

public class blackjack {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);

        int N = in.nextInt();
        int M = in.nextInt();

        int[] card = new int[N];
        int sum = 0;
        int temp = 0;

        for(int i = 0; i< N; i++) {
            card[i] = in.nextInt();
        }

        for(int i =0; i< N; i++) {
            for(int j = i+1; j<N; j++) {
                for(int z = j+1; z<N; z++) {
                    sum = card[i] + card[j] + card[z];

                    if(temp < sum && sum <= M) {
                        temp = sum;
                    }
                }
            }
        }


        System.out.println(temp);
    }


}

정리

• 완전 탐색 알고리즘에 대해 이해할 수 있는 시간이었고, 어떤 경우에 완전 탐색을 사용하여 문제를 풀어야하는지 감을 잡을 수 있게 되었다.

문제풀이

이 문제는 숫자를 오름차순으로 정렬하는 문제이다. JAVA에서 sort 함수로 오름차순으로 정렬해주는 함수가 존재한다. 그 함수를 사용하면 쉽게 풀 수 있다. 하지만 시간제한 5초에 메모리 제한 8MB로 제한 되어있기 때문에 입력, 출력 부분만 잘 해결하면 쉽게 풀 수 있다.

1. Scanner로 입력을 받게 되면 내부적으로 자체 정규식 검사 과정에서 시간이 엄청 소요되기 때문에 '시간 초과'가 발생할 수 밖에 없다. 그렇기 때문에 BufferedReader 를 사용해야 한다.
2. 또한 출력도 BufferedWriter 또는 StringBuilder 를 이용하여 출력해야한다.
3. 필자는 BufferedReader와 StringBuilder를 사용하여 문제를 풀었다.

소스 코드

package sort;

import java.util.*;
import java.io.*;

public class number_sort2 {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        //Scanner in = new Scanner(System.in);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();

        int N = Integer.parseInt(br.readLine());

        int[] nums = new int[N];

        for(int i = 0; i<N; i++) {
            nums[i] = Integer.parseInt(br.readLine());
        }
        Arrays.sort(nums);
        for(int i=0; i<N; i++) {
            sb.append(nums[i]).append("\n");
        }
        System.out.println(sb);
    }

}

정리

• 백준 문제에서는 시간복잡도와 메모리 제한을 두어 코드를 구현했을 때 답은 나와도 시간초과나 메모리 초과로 문제가 틀리는 경우가 있다. 이러한 경우처럼 시간제한과 메모리제한을 두었을 때 만족할 수 있는 방법들에 대해 배우고 대처할 수 있게 되었다.

문제풀이

문제에 나와있는 식을 참조하거나 피보나치 수열에 대해 알고 있다면 쉽게 풀 수 있는 문제일 것이다.

1. 문제에 나와 있는 식 F(n) = F(n-1) + F(n-2) (n>=2)과 0번째 피보나치 수는 0, 1번째 피보나치 수는 1이다.를 이용하여 문제를 푼다.
2. 앞서 말했던 조건을 가지고 N>=2 인 경우와 N = 0인 경우, N = 1인 경우의 조건에 따라 알맞게 구현한다.

소스 코드

package recursion;

import java.util.*;

public class fibonacci {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    Scanner in = new Scanner(System.in);

    int n = in.nextInt();

    int ans = fibo(n);

    System.out.println(ans);
}

public static int fibo(int N) {
    if(N >= 2) {
        return fibo(N-1) + fibo(N-2);
    }
    else if(N == 0)
        return 0;
    else
        return 1;

}

}

문제를 풀고 느낀점

• 우선 피보나치 수열에 대해 알고 있었고, 문제에 답이 있는 경우 이므로 재귀함수를 알고 문제의 조건들만 앎맞게 구현한다면 굉장히 쉽게 풀 수 있는 기본 문제였다.

문제풀이

이 문제는 팩토리얼 문제로 재귀함수를 사용하면 반복문을 사용하지 않아도 쉽게 풀 수 있는 재귀함수의 기본적인 문제이다.

1. 팩토리얼 함수 factor를 구현해준다.
2. 0!은 1이므로 함수를 구현할 때 조건문으로 0인 경우는 1을 리턴하게 한다.
3. 입력 받은 N X factor(N-1)을 하게 하여 재귀를 건다.

소스 코드

package recursion;

import java.util.*;

public class factorial {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    Scanner in = new Scanner(System.in);

    int N = in.nextInt();

    int fac = factor(N);

    System.out.println(fac);
}

public static int factor(int n) {
    if(n == 0) return 1;

    return n * factor(n-1);

}

}

문제를 풀고 느낀점

• 재귀 함수의 간단한 문제를 풀어보면서 재귀 함수가 어떻게 동작이 되는지 공부할 수 있는 시간이었다.

Android 앱 개발을 하다보면, Activity 클래스에 모든 동작 코드를 다 집어 넣는 경우가 많았다. 그러다 보니 앱이 동작하는 데에는 큰 문제가 없었지만 체계적인 구조 없이 코드를 작성하여 추후에 유지 보수하기가 굉장히 까다롭다. 여러 프로젝트를 진행하다 보면 이렇게 코드를 작성했을 때, 기능을 바꿔야하거나 추가하여야 하는 경우 어떤 부분을 수정해야 할지 막막했던 경험이 있다. 이러한 경험을 토대로 요즘 대세인 MVVM 디자인 패턴을 공부하고, 적용해봐야겠다는 생각이 들었다.

기존에 많이 쓰였던 단순한 형태의 MVC 패턴에 따라 Activity에 모든 코드를 다 집어넣으면 이러한 단점들이 발생하였다.

• 앱 기능이 많아질 수록 Activity 자체가 무거워진다.
• View와 Model 간의 의존성이 높아지고 코드가 복잡해진다.(일명 스파게티 코드)
• View와 UI Refresh를 위해 Model을 참조하므로 앱의 규모가 커질수록 코드가 더 복잡해지게 된다.

이런 단점들을 보면, MVC 패턴은 규모가 커질수록 유지보수하기가 점점 어려워진다는 것을 알 수 있다.

MVC 패턴의 동작은 아래와 같다.

1. Controller가 사용자의 요청을 받아들인다.
2. Controller가 사용자의 동작에 따른 Model 없데이트를 요청한다.
3. Controller가 Model을 나타낼 View를 선택한다.
4. View는 Model을 참조하여 UI를 업데이트한다.

이렇게 되다 보니 View와 Model 간의 의존성이 높아질 수 밖에 없다. 또 Controller(Activity)가 Model과 View 사이에서 바쁘게 움직이고 있다. 혼자서 요청을 보내야 하기 때문에 Controller는 당연히 동작이 무거워진다. 따라서 코드 유지보수를 하다가 잘못하면 UI 랜더링 속도가 느려져 프레임 스킵 현상 및 메모리 누수 (Memory Leak)의 위험이 생길지도 모른다.

MVC 패턴은 구현하기에는 쉬운 장점이 있지만, 기능 추가 및 수정에 있어서 유지보수하기가 어렵다. 이러한 MVC 패턴의 단점을 보완하기 위해 등장한 디자인 패턴이 바로 MVVM 패턴이다. MVVM 패턴은 기존 MVC에서 Controller가 혼자 일하기 보다, 이 동작 자체를 분리하여 동작의 흐름을 더욱 더 체계적으로 만들어주고 유지보수를 편리하게 할 수 있도록 해주는 디자인 패턴이다.

MVVM 패턴은 Model, View, ViewModel로 이루어져 아래와 같은 동작을 한다.

View

1. Activity 나 Fragment가 View 역할을 한다.
2. 사용자의 요청을 받는다.
3. ViewModel의 데이터를 관찰하여 UI를 갱신한다.

ViewModel

1. View가 요청한 데이터를 Model로 요청한다.
2. Model로 부터 요청한 데이터를 받는다.

Model

1. ViewModel이 요청한 데이터를 반환한다.
2. Room, Realm과 같은 DB 사용이나 Retrofit을 통한 백엔드 API 호출 (네트워킹)이 보편적이다.

결국 View가 필요로 하는 데이터는 ViewModel이 쥐고 있고, View는 그것을 필요로 하기 때문에 ViewModel이 쥐고 있는 데이터를 관찰한다. 그렇기에 MVC 패턴과 다르게, View가 DB에 직접 접근하는 것이 아닌 UI 업데이트에만 집중하고 관찰하고 있는 만큼 데이터 변화에 더욱 능동적으로 움직이게 된다.

MVVM 패턴의 장점은 다음과 같다.

• View가 ViewModel의 데이터를 관찰하고 있으므로 UI 업데이트가 간편하다.
• ViewModel이 데이터를 홀드하고 있으므로 Memory Leak 발생 가능성을 배제할 수 있다.(View가 직접 Model에 접근하지 않아서 Activity나 Fragment 생명주기에 의존하지 않기 때문이다.)
• 기능별 모듈화가 잘 되어 유지 보수에 용이하다.

이러한 장점을 잘 활용하여 MVVM 패턴을 가지고 앱 개발을 한다면 좋은 앱을 만들 수 있을 것 같다. 하지만 그만큼 구조가 복잡하여 진입장벽이 높다고 한다.

그래서 인지** MVVM 패턴을 간편하게 적용해볼 수 있게끔 구글에서 **AAC라는 것을 제공한다.

AAC (Android Architecture Component)

AAC란 구글에서 발표한 안드로이드 개발 가이드이다. 구글은 많은 개발자들에게 앱을 잘 만들게 하기 위해 이런 가이드라인을 제시하였다. 구조는 아래와 같다.

ViewModel

화면 변화 시에도 변하지 않는 (사라지지 않는) 데이터를 가지고 있다.

Live Data

View가 ViewModel을 관찰할 때, 그 관찰 대상이 되는 데이터 홀더 클래스이다. Live Data는 Acivity 나 Fragment의 생명주기를 인지하지 못하므로, 화면이 활성화 되어 있을 때만 동작하여 메모리 누수를 줄여준다.

Repository

ViewModel과 데이터를 주고받기 위해, 데이터 API를 포함하는 클래스이다. 사용자 동작에 따라 필요한 데이터나 외부 백엔드 서버 등에서 데이터를 가져오게 된다. Repository의 존재 덕분에 ViewModel이 데이터를 관리할 필요가 없게 된다.

RoomDatabase

Room은 SQLite를 사용함에 있어 별도의 Query문 작성없이 간편하게 Insert, Delete 등의 동작을 할 수 있게끔 도와주는 ORM 라이브러리이다.

문제풀이

*이 문제는 큐를 응용하는 문제로 N개의 문서 중 중요도에 따라 높은 것 순으로 출력해야하는 문제이다. 문제를 풀기 전 어떤 형태의 알고리즘으로 풀어야 할지 분석하였다. *

1. 0번째 부터 순서대로 입력을 받아 큐에 넣어준다.
2. 큐에는 순서 index와 중요도를 int 배열로 삽입한다.
3. 맨 앞 인덱스의 중요도를 Pop하여 나머지 중요도의 크기와 비교하고 중요도가 더 큰 것을 큐의 맨 앞으로 오게하고 count를 증가 시킨다.
4. 큐의 맨 앞의 인덱스가 M의 값과 같은지 비교한다.
5. 값이 다르면 다시 반복문을 돌리고 값이 같다면 break를 하여 count의 개수를 출력한다.

소스 코드

package data_structure;

import java.util.*;

public class print_queue {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner in = new Scanner(System.in);

    StringBuilder sb = new StringBuilder();

    int n = in.nextInt();

    for(int i = 0; i<n; i++) {
        int N = in.nextInt(); // 총 문서 개수
        int M = in.nextInt(); // 원하는 문서 위치 값

        LinkedList<int[]> que = new LinkedList<>();
        int count = 0;

        for(int j = 0; j<N; j++) {
            que.offer(new int[] {j, in.nextInt()} );
        }

        while(!que.isEmpty()) {
            int[] first = que.poll();
            boolean isMax = true;

            for(int z = 0; z<que.size(); z++) {
                if(first[1] < que.get(z)[1]) {
                    que.offer(first);
                    for(int j = 0; j<z; j++) {
                        que.offer(que.poll());
                    }
                    isMax = false;
                    break;
                }

            }
            if(isMax == false) {
                continue;
            }

            count++;
            if(first[0] == M)
                break;
        }

        sb.append(count).append("\n");

    }
    System.out.print(sb);

}

}

문제를 풀고 느낀점

• 큐의 응용문제라 쉽게 풀 수 있을거라 생각했지만 우선 어떻게 알고리즘을 설계하여할지 감이 도통 잡히지 않아 구글링을 통해 다양한 방법을 배웠고, 그 중 나와 가장 비슷하게 구현을 시도했던 코드를 참조하여 문제를 풀었다. 이번 응용 문제를 통해 큐에 대해 완벽히 숙지할 수 있는 시간이었던 것 같다.

문제풀이

자료구조 중 FIFO구조인 큐의 기본적인 동작들을 구현하는 문제로 Queue 클래스를 사용하면 쉽게 풀 수 있는 문제였다.

큐(Queue)란?

큐(Queue)는 기본 자료구조 중 하나로, 줄을 지어 순서대로 처리하는 자료구조이다. 큐는 LIFO(Last-in First-out)구조를 가진 스택(Stack)과는 다르게 FIFO(First-in First-out)구조를 가진다. 즉, 먼저 들어온 데이터가 먼제 나가는 구조이다.

큐(Queue)의 특징

• 먼저 들어간 데이터가 먼저 나간다. FIFO구조
• 접근 방법은 가장 첫 원소와 끝 원소로만 가능하다.
• 프로세스 관리, 우선순위가 같은 작업 예약에 활용된다.
• 그래프의 너비 우선 탐색(BFS)에서 사용된다.

큐(Queue)클래스의 사용법

Queue<Integer> que = new LinkedList<>();

큐(Queue)의 연산

큐(Queue)는 오버플로우(Overflow)나 언더플로우(Underflow)가 발생하면 예외를 던지거나 null 또는 false를 반환하는 메소드들이 있다.

1. 예외를 던지는 메소드

• add(A) : A를 큐(Queue)에 넣는다.
• remove() : 맨 처음에 들어간 데이터를 제거한다.
• element() : 큐(Queue)에서 가장 앞에 있는 것을 반환한다.

2. null 또는 false를 반환하는 메소드

• offer(A) : A를 큐(Queue)에 넣는다.
• poll() : 맨 처음에 들어간 데이터를 제거한다.
• peek() : 큐(Queue)에서 가장 앞에 있는 것을 반환한다.

소스 코드

package data_structure;

import java.util.; import java.io.;

public class queue {

public static void main(String[] args) throws IOException{
    // TODO Auto-generated method stub
    Queue<Integer> que = new LinkedList<>();
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb = new StringBuilder();

    int n = Integer.parseInt(br.readLine());
    int input = 0;
    for(int i=0; i<n; i++) {
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
        String str = st.nextToken();

        switch(str) {

        case "push":
            input = Integer.parseInt(st.nextToken());
            que.offer(input);
            break;
        case "pop":
            sb.append(que.isEmpty() ?  -1 : que.poll()).append("\n");
            break;
        case "size":
            sb.append(que.size()).append("\n");
            break;
        case "empty":
            sb.append(que.isEmpty() ?  1 : 0).append("\n");
            break;
        case "front":
            sb.append(que.isEmpty() ?  -1 : que.peek()).append("\n");
            break;
        case "back":
            sb.append(que.isEmpty() ?  -1 : input).append("\n");
            break;
        }

    }
    System.out.print(sb);
}

}

문제를 풀고 느낀점

• 스택과 다르게 FIFO구조를 가진 큐에 대해 공부하는 시간을 가지게 되었고, 큐 클래스를 이용하여 문제를 풀 수 있는 기본 구조를 배워 잘 활용할 수 있을 것 같다.

문제풀이

알맞은 괄호 수식의 원리를 알면 쉽게 풀 수 있는 문제였다. 원리는 여는 괄호가 '('가 있으면 반드시 이에 대응하는 닫는 괄호 ')'가 있어야한다는 것이다. 이것을 Stack을 이용하여 풀면 간단하게 해결할 수 있다. 여는 괄호가 있을 때는 스택에 추가하고 닫는 괄호가 있으면 여는 괄호를 하나씩 지워주면 된다.

1. 여는 괄호와 닫는 괄호가 올바른 경우 - 최종적으로 스택에는 아무것도 존재하지 않을 것이다. 고로 YES를 출력해준다.
2. 스택에 괄호가 남는 경우 - 여는 괄호가 많은 경우로 VPS가 아니므로 NO를 출력해준다.
3. 스택에 지울 여는 괄호가 부족한 경우 - 닫는 괄호가 많은 경우로 VPS가 아니므로 NO를 출력해준다.

소스 코드

package data_structure;

import java.util.*;

public class parenthesis {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();

        for(int i =0; i<n; i++) {
            System.out.println(solve(in.next()));

        }



    }
    public static String solve(String s) {
        Stack<Character> stack = new Stack<>();

        for(int i = 0; i<s.length(); i++) {
            char c = s.charAt(i);
            if(c == '(') {
                stack.push(c);
            }
            else if(stack.isEmpty()) {
                return "NO";
            }
            else
                stack.pop();
        }
        if(stack.isEmpty()) {
            return "YES";
        }
        else
            return "NO";
    }

}

문제를 풀고 느낀점

• 스택에 대해 다시 한번 생각할 시간을 가지게 되었고, 스택을 어느 상황에 어떻게 활용해야하는지 정확히 알 수 있게 되었다. 스택을 사용하면 편리한 상황이 나올 때 잘 활용할 수 있을 것 같다.

문제풀이

자료구조 중 LIFO구조인 스택의 기본적인 동작들을 구현하는 문제로 Stack 클래스를 사용하면 쉽게 풀 수 있는 문제였다.

Stack이란?

자료구조 중 하나인 Stack은 상자에 물건을 쌓아 올리듯이 데이터를 쌓는 자료 구조라고 할 수 있다.

Stack의 특징

• 먼저 들어간 자료가 나중에 나온다. LIFO(Last In First Out) 구조
• 시스템 해킹에서 버퍼오버플로우 취약점을 이용한 공격을 할 때 스택 메모리의 영역에서 한다.
• 인터럽트 처리, 수식의 계산, 서브루틴의 복귀 번지 저장 등에 쓰인다.
• 그래프의 깊이 우선 탐색(DFS)에서 사용된다.
• 재귀함수를 호출할 때 사용된다.

  Stack클래스의 사용법

  Stack<Integer> s = new Stack<>();

  s.push(i); // 스택의 값 넣기 s.pop(); // 스택의 가장 위의 값 빼고 출력하기 s.size(); // 스택의 크기 s.peek(); // 스택의 가장 위의 값 조회

소스 코드

package data_structure;

import java.util.*;

public class stack1 {


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Stack<Integer> stack = new Stack<>();
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();

        for(int i = 0; i<n; i++) {
            String str = in.next();

            switch(str) {

            case "push":
                int item = in.nextInt();
                stack.push(item);
                break;
            case "pop":
                System.out.println(stack.isEmpty() ? -1 : stack.pop());
                break;
            case "size":
                System.out.println(stack.size());
                break;
            case "empty":
                System.out.println(stack.isEmpty() ? 1 : 0);
                break;
            case "top":
                System.out.println(stack.isEmpty() ? -1 : stack.peek());
                break;
            }
        }
    }
}

프로그램 구현

단층 퍼셉트론 기계학습 구현

<소스 코드>

def fn_step(x):
    if(x<=0):
        return 0
    return 1

class Perceptron:
    def __init__(self, w1, w2, b, activateFn):
        self.ws=[w1,w2]
        self.bias=b
        self.activateFn=activateFn

    def calculate(self, *xs):
        result=self.bias
        for x, w in zip(xs, self.ws):
            result+=x*w
        y=self.activateFn(result)
        return y

    def train(self, inputSet, labelSet, LT=0.05, e=0.01):
        for xs,t in zip(inputSet, labelSet):
            y=self.calculate(*xs) 
            if(abs(y-t)<=e):
                continue
            self.bias=self.bias+LT*(t-y)*1 #가중치 갱신
            for i, x in enumerate(xs):
                self.ws[i]=self.ws[i]+LT*(t-y)*x

    def showWeight(self):
        print("Bias : {:.03} ".format(self.bias))
        for i,w in enumerate(self.ws):
            print("Weight {} : {:.03}".format(i, w))



if __name__ == '__main__':
    x1=[0,0,1,1]
    x2=[0,1,0,1]
    y= [0,0,0,1]

    perc=Perceptron(0.1,0.2,-1,fn_step)
    #5회 학습
    for i in range(5):
        perc.train(zip(x1,x2),y,0.05)
        print("train {} result ".format(i+1))
        perc.showWeight()

    for i in range(4):
        print("입력값 : "+str(x1[i])+ ", "+str(x2[i])+" ",end='')
        out=perc.calculate(x1[i],x2[i])
        print("예측 : "+ str(out) + ", 정답 : "+ str(y[i]))

<실행 결과>

단층 퍼셉트론과 다층 퍼셉트론의 텐서플로우 구현

<단층 퍼셉트론 소스 코드>

import tensorflow as tf
import numpy as np

# AND
x_train = np.array([[0, 0],
            [0, 1],
            [1, 0],
            [1, 1]], dtype=np.float32)
y_train = np.array([[0],
            [0],
            [0],
            [1]], dtype=np.float32)
model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Dense(1, input_dim = 2, activation='relu'))
sgd = tf.keras.optimizers.SGD(learning_rate=0.05)
model.compile(loss='mean_squared_error',optimizer=sgd)

model.fit(x_train, y_train, epochs=1000, verbose=0)
print(model.predict(x_train))

<작업화면>

<실행결과>

<다층 퍼셉트론 소스 코드>

import tensorflow as tf
import numpy as np

x_train = np.array([[0, 0],
            [0, 1],
            [1, 0],
            [1, 1]], dtype=np.float32)
y_train = np.array([[0],
            [1],
            [1],
            [0]], dtype=np.float32)

model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Dense(2, input_dim = 2, activation='relu'))
model.add(tf.keras.layers.Dense(1, activation='relu'))
sgd = tf.keras.optimizers.SGD(learning_rate=0.025)
model.compile(loss='mean_squared_error', optimizer=sgd)

model.fit(x_train, y_train, epochs=1000, batch_size=1, verbose=0)
print(model.predict(x_train))

<작업화면>

<실행결과>