코틀린 언어 특성

• vararg : 호출 시 인자 개수가 달라질 수 있는 함수를 정의할 수 있음
• 중위 함수 호출 구문: 인자가 하나인 메소드를 편하게
• 구조 분해 선언: 복합적인 값을 분해하고 여러 변수에 나눠 담을 수 있음

자바 컬렉션 API의 확장

last()

val strings: List<String> = listOf("first", "second", "last")
println(strings.last())

>>> last

실제 구현은 다음과 같이 List의 확장함수로 구현되어 있다.

max()

val numbers: Collection<Int> =setOf(1, 14, 2)
println(numbers.max())

→ 코틀린 1.4 버전 이후로 deprecated되었고, maxOfNull()을 사용한다.

가변 인자 함수

위에서 사용한 listOf()는 다음과 같이 정의되어 있다.

public fun <T> listOf(vararg elements: T): List<T> = if (elements.size > 0) elements.asList() else emptyList()

• 자바의 가변 길이 인자 : ...
• 코틀린의 가변 길이 인자: 파라미터 앞에 vararg

이미 배열인 원소를 가변 길이 인자로 넘기기

fun main(args: Array<String>) {
    val list = listOf("args: ", *args)
    println(list)
}

• 스프레드 연산자 * 사용

  → 자바에서는 사용할 수 없는 기능

중위 호출과 구조 분해 선언

val map = mapOf(1 to  "one", 7 to "seven", 53 to "fifty-three")

와 같이 map을 만들때, to는 중위호출로 to라는 일반 메소드를 호출한다.

중위 호출

• 인자가 하나뿐인 일반 메소드/확장 함수에 사용 가능
• 사용 방법
  • infix 변경자를 함수 선언 앞에 추가

• to를 일반 방법으로 호출 : 1.to("one")
• to를 중위 호출로 호출 : 1 to("one")

구조 분해 선언

infix fun Any.to(other: Any) = Pair(this, other)

위와 같이 선언된 to()는 Pair의 구조 분해 선언으로 두 변수를 즉시 초기화 한다.

val (number, name) = 1 to "one"

• 활용: Pair 뿐만 아니라 다른 객체에도 적용 가능함

    for ((index, element) in collection.withIndex()) {
        println("$index: $element")
    }

문자열과 정규식 다루기

문자열 나누기

• 자바의 split : separator가 정규식임 → .는 모든 문자를 나타내는 정규식으로 해석됨

• 코틀린에서의 문자열 나누기

  • 파라미터로 Regex 타입을 받는다.

    println("12.345-6.A".split("\\.|-".toRegex()))
    
    >>> [12, 345, 6, A]

    → 코틀린 정규식 문법은 자바와 같음

  • 자바 split 오버로딩

    println("12.345-6.A".split(".", "-"))
    
    >>> [12, 345, 6, A]

    → 여러 separator 사용 가능

정규식과 3중 따옴표로 묶은 문자열

파일 path를 디렉토리, 파일명, 확장자로 구분하기

• 방법 1) 코틀린 라이브러리 사용

fun parsePath(path: String) {
    val directory = path.substringBeforeLast("/")
    val fullName = path.substringAfterLast("/")
    val fileName = fullName.substringBeforeLast(".")
    val extension = fullName.substringAfterLast("/")

    println("Dir: $directory, name: $fileName, ext: $extension")
}

fun main() {
    parsePath("/Users/yole/kotlin-book/chapter.doc")
}

• 방법 2) 정규식 사용

fun parsePath(path: String) {
    val regex = """(.+)/(.+)\.(.+)""".toRegex()
    val matchResult = regex.matchEntire(path)

    if (matchResult != null) {
        val (directory, filename, extension) = matchResult.destructured
        println("Dir: $directory, name: $filename, ext: $extension")
    }
}

fun main() {
    parsePath("/Users/yole/kotlin-book/chapter.doc")
}

→ """"" : 삼중 따옴표 문자열에서는 어떤 문자도 이스케이프 할 필요가 x

여러 줄 3중 따옴표 문자열

fun main() {
    val kotlinLogo = """| //
        .| //
        .|/\"""
    println(kotlinLogo.trimMargin("."))
}

>>> | //
>>> | //
>>> |/\

→ 와 같이 문자열이 텍스트가 포함해도 쉽게 문자열로 변환할 수 있음

로컬 함수 확장

• 추출한 함수를 원래 함수 내부에 중첩시키기

  : 일반적으로 한단계만 중첩시키라고 권장

import java.lang.IllegalArgumentException

class User(val id: Int, val name: String, val address: String)

fun saveUser(user: User) {
    if (user.name.isEmpty()) {
        throw IllegalArgumentException("name null")
    }

    if (user.address.isEmpty()) {
        throw IllegalArgumentException("address null")
    }
}

fun main() {
    saveUser(User(1, "", ""))
}

→ 함수가 복잡하지는 않지만, 검증하는 코드가 반복된다

import java.lang.IllegalArgumentException

class User(val id: Int, val name: String, val address: String)

fun saveUser(user: User) {
    fun validate(user: User, value: String, fieldName: String) {
        if (value.isEmpty()) {
            throw IllegalArgumentException("$[user.id]: null $fieldName")
        }
    }
    validate(user, user.name, "Name")
    validate(user, user.address, "Address")
}

fun main() {
    saveUser(User(1, "", ""))
}

→ 중복되는 검증 부분을 메소드로 추출하고, 원래 함수 내부에 중첩

→ user 객체를 로컬 함수에 하나하나 전달해야 된다

import java.lang.IllegalArgumentException

class User(val id: Int, val name: String, val address: String)

fun saveUser(user: User) {
    fun validate(value: String, fieldName: String) {
        if (value.isEmpty()) {
            throw IllegalArgumentException("$[user.id]: null $fieldName")
        }
    }
    validate(user.name, "Name")
    validate(user.address, "Address")
}

fun main() {
    saveUser(User(1, "", ""))
}

→ 로컬 함수가 자신이 속한 바깥 함수의 모든 파라미터와 변수를 사용할 수 있음을 이용

import java.lang.IllegalArgumentException

class User(val id: Int, val name: String, val address: String)

fun User.validateBeforeSave(user: User) {
    fun validate(value: String, fieldName: String) {
        if (value.isEmpty()) {
            throw IllegalArgumentException("$[user.id]: null $fieldName")
        }
    }
    validate(name, "Name")
    validate(address, "Address")
}

fun saveUser(user: User) {
    user.validateBeforeSave(user)
}

fun main() {
    saveUser(User(1, "", ""))
}

→ 확장 함수로 추출

: 이 검증 로직이 User 외에 다른 데에서는 쓰이지 않아서 포함시키고 싶지 않은 경우

• 함수명을 선언하고 사용하는 것이 아닌 식별자 없이 실행가능한 함수
• 공통 코드 구조를 라이브러리 함수로 쉽게 뽑아낼 수 있음
• 코틀린 표준 라이브러리에서 많이 사용

5.1 람다 식과 멤버 참조

5.1.1 코드 블록을 인자로 넘기기

람다 도입 이전

: 내부 익명 클래스를 사용

button.setOnClickListner(new OnClickListener() {
    @Override
    public void onClick(View view) {
        //
    }
}

→ 코드가 번잡스럽고, 이런 작업을 여러번 수행해야 하는 경우엔..

→ 일회용 클래스

람다 도입 이후

: 함수를 값처럼 다루자!

button.setOnClickListner{ // }

5.1.2 람다와 컬렉션

람다 없이

data class Person(val name: String, val age: Int) {
    companion object {}
}

fun findTheOldest(people: List<Person>) {
    var maxAge = 0
    var theOldest: Person? = null

    for (person in people) {
        if (person.age > maxAge) {
            maxAge = person.age
            theOldest = person
        }
    }
    println(theOldest)
}

fun main() {
    val people = listOf(Person("Alice", 29), Person("Bob", 24), Person("Carol", 39))
    findTheOldest(people)
}

람다 활용하기

data class Person(val name: String, val age: Int) {
    companion object {}
}

fun main() {
    val people = listOf(Person("Alice", 29), Person("Bob", 24), Person("Carol", 39))
    println(people.maxByOrNull{ it.age })
    println(people.maxByOrNull(Person::age))
}

→ 책에는 maxBy()로 나오는데 이건 deprecated

→ 람다나 멤버 참조를 사용해서 더 짧고 가독성 좋게 개선

5.1.3 람다 식의 문법

val sum = { x: Int, y: Int -> x + y }
println(sum(1, 2))

1. 항상 중괄호 사이에 위치한다
2. 인자 목록에 괄호 필요 x
3. 람다식을 변수에 저장할 수 있음 → runCatching에서 onSuccess, onFailure

run

: 코드의 일부분을 블록으로 둘러싸서 실행이 필요한 경우

val num = 42
num.run { println(this) }

→ 기본 람다를 언제 사용해야 할지?

https://medium.com/@limgyumin/코틀린-의-apply-with-let-also-run-은-언제-사용하는가-4a517292df29

https://kotlinlang.org/docs/scope-functions.html#function-selection

위의 코드 정식으로 람다 활용하기

people.maxByOrNull({ p: Person -> p.age })
people.maxByOrNull(){ p: Person -> p.age }
people.maxByOrNull { p: Person -> p.age }
people.maxByOrNull{ it.age }  // 제일 익숙한 형태

→ 코틀린에서 맨 뒤의 인자가 람다면 밖으로 뺄 수 있고, 다른 인자가 없으면 () 생략 가능

를 활용해보자

val name = people.joinToString(separator = " ", transform = {p->p.name})
val name = people.joinToString(" "){ p->p.name }

파라미터 타입 추론이 필요할 때

코틀린 컴파일러가 자동으로 파라미터 타입을 추론하여 굳이 명시하지 않아도 되지만, 변수에 저장할때는 타입 추론 문맥이 없어서 명시해야됨

val getAge = { p: Person -> p.age }

5.1.4 현재 영역에 있는 변수 접근

fun printMessageWithPrefix(responses: Collection<String>, prefix: String) {
    var clientErrors = 0
    var serverErrors = 0

    responses.forEach {
        if (it.startsWith("4")) clientErrors++
        else if (it.startsWith("5")) serverErrors++
    }
    println("$prefix $clientErrors client errors, $prefix  $serverErrors server errors")
}

fun main() {
    val errors = listOf("401 Unauthorized", "404 Not Found", "200 Ok", "500 Internal Server Error")
    printMessageWithPrefix(errors, "Errors:")
}

포획 변수 (captured variable)

• 위 코드에서 prefix, clientErrors, serverErrors와 같이 람다 안에서 사용되는 외부 변수

• 포획 변수의 생명 주기

  : 일반적으로 함수 안의 로컬 변수는 함수가 반환되면 생명 주기가 끝나지만, 함수가 해당 로컬 변수를 포획한 람다를 반환하거나 변수에 저장하면 함수가 끝난 뒤에도 여전히 포획 변수를 사용할 수 있음

class Button {
    fun onClick(function: () -> Int) {
        function()
    }
}

fun tryToCountButtonClicks(button: Button): Int {
    var clicks = 0
    button.onClick{ clicks++ }
    return clicks
}

fun main() {
    val button = Button()
    val clickNum = tryToCountButtonClicks(button)
    println(clickNum)
}

→ 책에서의 설명(tryToCountButtonClicks가 clicks를 반환 한 다음 tryToCountButtonClicks이 호출되어 항상 0이 반환된다고 하는데 실제로 디버깅하면 반환 전에 onClick()이 먼저 호출된 다음 반환이 된다. 따라서 위와 같이 실행하면 1이 출력되는데 요건 번역 오류인지 무슨 의미인지 잘 모르겠다

5.1.5 멤버 참조

people.maxByOrNull{ it.age }

→ 최상위에 선언된 함수나 프로퍼티도 참조 가능하다

fun salute() = println("salute!")

fun main() {
    run(::salute)
}

인자가 여러개인 경우

: 직접 위임 함수에 대한 참조 제공하면 편함

fun sendEmail(person: Person, message: String) {
    println("${person.name} sent $message")
}

fun main() {
    val action1 = {
            person: Person, message: String -> sendEmail(person, message)
    }
    val action2 = ::sendEmail //람다 대신 멤버 참조 사용

    action1(Person("leean", 25), "hi")
    action2(Person("leean", 25), "hi")
}

5.2 컬렉션 함수형 API

5.2.1 filter와 map

filter

val list = listOf(1, 2, 3, 4)
println(list.filter { it%2 == 0 })

→ 컬렉션에서 원하는 원소만 필터해서 새 컬렉션 반환

map

val list = listOf(1, 2, 3, 4)
println(list.filter { it%2 == 0 })

→ 컬렉션에서 주워진 람다를 각 컬렉션에 적용한 결과를 새 컬렉션으로 반환

// 위의 코드에서 불필요한 연산 제거하기
val maxAge = people.maxBy(Person::age)!!.age
people.filter{ it.age == maxAge }

5.2.2 all, any, find

• count: 조건을 만족하는 원소의 개수 반환
• find: 조건을 만족하는 첫번째 원소 반환
• all: 모든 원소가 만족하는지 여부 체크
• any: 하나라도 만족하는지 여부 체크

val canBeInClub27 = { p:Person -> p.age <= 27 }
val people = listOf(Person("Alice", 27), Person("Bob", 25), Person("Carol", 37))

println(people.all(canBeInClub27))
println(people.any(canBeInClub27))
println(people.count(canBeInClub27))
println(people.find(canBeInClub27))

>>> false
>>> true
>>> 2
>>> Person(name=Alice, age=27)

5.2.3 groupBy

원소를 특성에 따라 그룹으로 나누기

val people = listOf(Person("Alice", 27), Person("Bob", 25), Person("Carol", 27))
println(people.groupBy { it.age })

>>> {27=[Person(name=Alice, age=27), Person(name=Carol, age=27)], 25=[Person(name=Bob, age=25)]}

→ 결과: Map<Int, List> → db에서 인덱스 타더라도 groupBy/aggregate 때문에 slow가 발생하는경우가 왕왕 있다 → 메모리에 올려놔도 상관없는 경우에 app단에서 groupBy를 사용하는게 더 빠른 경우가 있다

5.2.4 flapMap, flatten

flatMap

인자로 주어진 람다를 컬렉션 모든 객체에 매핑

data class Book(val title: String, val author: List<String>) {
    companion object
}

fun main() {
    val books = listOf(
        Book("kotlin in action", listOf("rein", "moka", "leean")),
        Book("modern java in action", listOf("jace", "dante", "moka"))
    )

    println(books.flatMap { it.author }.toSet())
}

flatten

특별히 매핑이 필요 없는 경우

외에 더 많은 API는 https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-collection/#kotlin.collections.Collection 를 참고하자~!

→ 람다 안에 뭔가 로직이 복잡하다,,? 중첩된다? 싶으면 바로 검색

val setExample = hashSetOf(1, 7, 53)
val listExample = arrayListOf(1, 7, 53)
val mapExample = hashMapOf(1 to "one", 7 to "seven", 53 to "fifty-three")

println(setExample.javaClass)
println(listExample.javaClass)
println(mapExample.javaClass)

결과

: 코틀린은 자신만의 컬렉션을 제공하지 않고, 기존 자바 컬렉션을 활용한다. → 왜? 자바 코드와의 상호작용을 위해서 굳이 컬렉션을 서로 변환할 필요가 없게 한다.

val strings = listOf("first", "second", "fourteenth")
println(strings.last())

:코틀린은 기존 자바 컬렉션을 활용하지만, 자바보다 더 많은 기능을 쓸 수 있다.

3.2 함수를 호출하게 쉽게 만들기

자바 컬렉션의 toSring()

• 디폴트 toString()

import java.util.HashSet;

class Main {  
  public static void main(String args[]) { 
    HashSet set = new HashSet();
    set.add("abc");
    set.add("efg");
    set.add("hij");
    System.out.println(set.toString());
  } 
}

>>> [abc, efg, hij]

→ 원하는 형식으로 toString()을 재정의 하려면? : 구아바, 아파치 커먼즈 같은 라이브러리 혹은 직접 관련 로직 구현해야 한다 → 번거롭다

코틀린에서의 toString()

방법 1) 기본 호출

fun <T> joinToString(
    collection: Collection<T>,
    separator: String,
    prefix: String,
    postfix: String
): String {
    val result = StringBuilder(prefix)

    for((index, element) in collection.withIndex()) {
        if (index > 0) result.append(separator)
        result.append(element)
    }

    result.append(postfix)
    return result.toString()
}

호출 결과

>>> val list = listOf(1, 2, 4)
>>> println(joinToString(list, ":", "(", ")"))
>>> (1:2:4)

: 의도대로 잘 작동한다. 하지만? 호출 부분이 번거롭다 → 인자로 전달한 separator, prefix, postfix가 각각 어떤 역할하는지 구분이 어렵고, 매번 함수의 시그니처를 찾아봐야함

방법2) 이름 붙힌 인자

>>> println(joinToString(list, separator = ":", prefix = "(", postfix = ")"))

: 전달하는 인자 중 일부/전부의 이름을 명시할 수 있다. → 인자 중 하나라도 이름을 명시하면 그 뒤에 오는 모든 인자는 이름을 꼭 명시해야 한다??

명시하지 않아도 잘 컴파일이 된다 ..?

방법 3) 디폴트 파라미터 값

• 자바의 문제점

  : java.Lang.Thread의 생성자는 8개나 정의되어 있다. → 파라미터 이름과 타입이 계속 반복되고, 인자 중 일부가 생략된 오버로드 함수를 호출하면 어떤 함수를 호출할지 모호하다.

• 코틀린에서의 디폴트 파라미터 : 함수 선언에서 파라미터의 디폴트 값을 지정할 수 있다.

  fun <T> joinToString(
      collection: Collection<T>,
      separator: String = ",",
      prefix: String = "(",
      postfix: String = ")"
  ): String {
      val result = StringBuilder(prefix)
  
      for((index, element) in collection.withIndex()) {
          if (index > 0) result.append(separator)
          result.append(element)
      }
  
      result.append(postfix)
      return result.toString()
  }
  
  >>> println(joinToString(list)
  >>> println(joinToString(list, ":") // 일부를 생략하면 맨 뒤에 n개가 생략된다.

- 디폴트 파라미터가 설정된 코틀린 함수를 자바에서 호출하면?
    : 자바에는 디폴트 파라미터 개념이 없어서 디폴트 파라미터가 설정된 코틀린 함수더라도 모든 인자를 명시해야 된다.
    → `@JvmOverloads` : 코틀린 컴파일러가 자동으로 맨 마지막 파라미터로 부터 하나씩 생략한, 오버로딩된 자바 메소드를 추가함 
    → joinToString위에 JvmOverloads 어노테이션을 추가하면?

    ```kotlin
    String joinToString(Collection<T> collection, String seperator, String prefix, String postfix); 
    String joinToString(Collection<T> collection, String seperator, String prefix); 
    String joinToString(Collection<T> collection, String seperator); 
    String joinToString(Collection<T> collection);
    ```

    와 같은 네개의 오버로딩한 함수가 만들어진다. 생략된 파라미터는 코틀린 디폴트 파라미터 값을 사용

정적인 유틸리티 클래스 없애기

• 정적 유틸리티 클래스? : 다양한 정적 메소드를 모아두는 역할로 특별한 상태나 인스턴스 메소드가 없는 클래스

• 코틀린에서의 정적 유틸리티 클래스 : 코틀린 파일의 모든 최상위 함수는 해당 클래스의 정적 메소드가 된다.

package strings

fun <T> joinToString(
    collection: Collection<T>,
    separator: String = ",",
    prefix: String = "(",
    postfix: String = ")"
): String {
    val result = StringBuilder(prefix)

    for ((index, element) in collection.withIndex()) {
        if (index > 0) result.append(separator)
        result.append(element)
    }

    result.append(postfix)
    return result.toString()
}

→ 이 함수의 실행 과정 : 컴파일러가 join.kt를 컴파일할때 새로운 클래스 정의 → JVM에서 호출할때는

pakage strings;

public class JoinKt {
    public static String joinToString(...) {...}
}

와 같이 컴파일된다.

• 파일에 대응하는 클래스 이름 변경하기 : 코틀린 최상위 함수가 포함되는 클래스의 이름 바꿀때는 @JvmNames 어노테이션을 사용한다. → 어떤 경우에 클래스 이름이 바뀌어야 하는지 잘 이해가 안간다..

• 최상위 프로퍼티

var opCount = 0

fun performOperation() {
    opCount++
}

fun reportOperationCount() {
    println("Operation performed $opCount times")
}

fun main() {
    performOperation()
    performOperation()
    performOperation()
    reportOperationCount()
}

>>> Operation performed 3 times

: 최상위 프로퍼티를 활용해서 코드에 상수를 추가할 수 있음

확장 함수와 확장 프로퍼티

확장 함수

• 기존 자바 API를 재작성 하지 않고도 코틀린 제공 기능 활용하는 방법
• 추가하려는 함수 이름 앞에 확장할 클래스 이름 덧붙히기

fun String.lastChar(): Char = this.get(this.length - 1)
// fun String.lastChar(): Char = get(length - 1) 
// this 생략 가능

fun main() {
    println("Kotlin".lastChar())
}

>>> n

→ String: 수신 객체 타입 → 확장할 클래스 → this: 수신 객체 → 확장 함수가 호출되는 대상이 되는 값

• 왜 사용하는가? 확장할 클래스(예제에서는 String)을 직접 작성한게 아니어도 해당 클래스에 새로운 메소드를 추가하는 것과 같게 동작한다.
• 캡슐화를 깨지 않는다 : 수신 객체 타입의 private이나 protected 멤버는 사용할 수 없다!

임포트와 확장 함수

• 클래스 임포트할 때와 같이 개별 함수 임포트 가능

import strings.lastChar

fun main() {
    val c = "Kotlin".lastChar()
    println(c)
}

• 코틀린 문법 상 확장 함수는 반드시 짧은 이름을 써야 한다 ??

자바에서 확장 함수 호출하기

: 정적 메소드를 호출하면서 첫번째 인자로 수신 객체 넘기기

char c = StringUtilsKt.lastChar("Java");

확장 함수로 유틸리티 함수 정의하기

fun main() {
    val list1 = listOf(1,2,3)
    println(list1.joinToString(separator = ";", prefix = "[", postfix = "]"))

    val list2 = arrayListOf(1,2,3)
    println(list2.joinToString(separator = ";", prefix = "[", postfix = "]"))
}

→ joinToString을 마치 클래스 멤버인거처럼 호출이 가능

확장 함수는 오버라이드할 수 없다

오버라이딩

open class View {
    open fun click() = println("View clicked")
}

// Button은 View를 확장한다.
class Button: View() {
    override fun click() = println("Button clicked")
}

fun main() {
    val view: View = Button()
    view.click()
}

>>> Button clicked

확장 함수의 오버라이딩

• 확장 함수는 이렇게 작동하지 x

  → 클래스 밖에 선언되므로 확장 함수를 호출할 때 수신객체로 지정한 변수의 정적 타입에 의해 어떤 확장 함수가 호출될지 결정된다.

• 코틀린은 호출될 확장 함수를 정적으로 결정한다

open class View {
    open fun click() = println("View clicked")
}

// Button은 View를 확장한다.
class Button: View() {
    override fun click() = println("Button clicked")
}

fun View.showOff() = println("I'm a view")
fun Button.showOff() = println("I'm a button")

fun main() {
    val view: View = Button()
    view.showOff()
}

>>> I'm a view

→ view가 가리키는 객체의 실제 타입은 Button이지만, view의 type은 View이므로 View.showOff()가 호출된다.

💡 확장 함수와 멤버 함수의 이름이 같으면? 멤버 함수의 우선 순위가 더 높아서 멤버 함수가 호출된다.

fun FunctionUtil.hello() {
    println("hello-extend")
}

class FunctionUtil {
    constructor()

    fun hello() {
        println("hello-class")
    }
}

fun main() {
    val func: FunctionUtil = FunctionUtil()
    func.hello()
}

>>> hello-class

확장 프로퍼티

• 프로퍼티 형식 구문으로 사용 가능
• 이름은 프로퍼티지만 상태 저장할 방법은 x

var StringBuilder.lastChar: Char
    get() = get(length - 1)
    set(value: Char) {
        this.setCharAt(length - 1, value)
    }


fun main() {
    val sb = StringBuilder("Kotlin?")
    sb.lastChar = '!'
    println(sb)
}
>>> Kotlin!

• 일반적인 프로퍼티와 같은데 수신 객체 클래스만 추가됨
• 자바에서 사용하고 싶다면? 게터&세터를 명시적으로 호출해야됨

2306 - 유전자

문제 설명

DNA는 a,c,g,t로 이루어진 문자열이다.

KOI 유전자는

1. at와 gt는 가장 짧은 길이의 KOI 유전자
2. X가 KOI 유전자이면 aXt와 gXc도 KOI 유전자이다.
3. X와 Y가 KOI 유전자이면 XY도 KOI 유전자이다.

KOI 유전자가 DNA 서열의 임의의 0개 이상 문자를 삭제해서 얻어지는 부분서열이라고 할때, 길이가 최대가 되는 KOI 유전자를 구하시오

문제 풀이

dp에서 유명한 유형인 DNA 서열,,, 3학년 알골시간 중간고사에도 나왔던 걸로 기억 ,, 하지만 DP는 역시 쉽지않내요,,

Top-Down 방식으로 풀었다. 주어진 DNA 서열에 대해서

1. (앞,뒤)의 쌍이 ('a','t')이거나 ('g','c')이면 앞+1, 뒤-1로 재귀
2. 1 검사하고 주어진 서열 길이만큼 (앞,i), (i+1,뒤)가 KOI 서열을 만족하는지 재귀를 돈다.

import sys

input = sys.stdin.readline

def findKOI(start, end):
    isKOI = dp[start][end]
    if isKOI != -1:
        return isKOI

    isKOI = 0
    # 조건 2: aXt, gXc 인지? 
    if((dna[start] == 'a' and dna[end] == 't') or (dna[start] == 'g' and dna[end] == 'c')):
        isKOI = findKOI(start+1, end-1) + 2;

    for i in range(start, end):
        isKOI = max(isKOI, findKOI(start, i) + findKOI(i+1, end))

    dp[start][end] = isKOI
    return isKOI

dna = input()
dp = [[-1 for _ in range(len(dna))] for _ in range(len(dna))]
print(findKOI(0, len(dna)-1))

참고

https://www.crocus.co.kr/964

3649 - 로봇 프로젝트

문제 설명

x 센치의 너비를 가진 구멍을 채우기 위해서 길이의 합이 구멍의 너비와 정확하게 일치하는 두 개의 레고 조각이 필요하다. 각 테스트 케이스마다

• 구멍의 크기
• 레고조각의 개수
• 각 조각마다의 길이

가 주어질때, 구멍을 완벽하게 막을 수 있는 두 조각을 구하시오.

문제 풀이

EZ한 투포인터 문제였다,,~ 근데 테스트케이스가 몇개인지 주어지지 않기 때문에 try except를 이용해서 풀어야 한다.

각 테스트 케이스마다

1. 레고 조각의 길이를 정렬
2. 투포인터를 사용해서 구멍과 일치하는 두조각 찾기 로 풀면 된다.

   import sys 
   

input = sys.stdin.readline

while True: try: x = int(input())* pow(10,7) n = int(input()) lego = [] for _ in range(n): lego.append(int(input()))

    # 1. 정렬하기
    lego.sort()

    # 2. 투포인터로 탐색
    left, right = 0, len(lego)-1
    flag = False

    while left < right :
        if lego[left] + lego[right] == x:
            flag = True
            print("yes", str(lego[left]), str(lego[right]))
            break
        elif lego[left] + lego[right] > x:
            right -= 1
        else:
            left += 1

    if flag == False:
        print("danger")
except:
    break

거의 사용하지 않는다고 알고 있습니다

2xx : 요청의 정상 처리

• 200 OK 성공
• 201 리소스의 생성시 사용 → 헤더 필드에 리소스의 주소가 들어있다.
• 202 accessed 접수는 됐는데 아직 처리는 안된 경우 → 배치 처리에서 사용한다.
• 204 no content → 정상 요청이지만 payload 본문에 데이터가 필요없는 경우

3xx : 리다이렉션

요청 완료를 위해 추가 행동이 필요한 경우이다

리다이렉션?

Location header의 위치로 다시 이동하는 것

영구 리다이렉션

: 특정 리소스의 URI가 영구적으로 이동한 경우

• 301 Moved permanantly → 리다이렉트시 요청이 GET 본문은 제거 (May)
• 308 Permanent Redirect 위에꺼랑 기능은 같은데 요청과 본문은 유지

일시 리다이렉션

• 302 Found → 리다이렉트시 요청은 GET, 본문은 제거 (May)
• 307 Temporary Redirect 위에꺼랑 기능은 같은데 요청과 본문은 유지
• 303 See Other 리다이렉트시 요청 메소드가 무조건 GET으로

→ 는 언제 사용할까? PRG에서!

PRG란 POST→ REDIRECT→ GET의 약자이다.

Post로 주문 후에 웹 브라우저를 그대로 새로고침하면 중복 주문의 오류가 발생이 가능하다. POST로 주문 후 GET으로 리다이렉트 하도록 200ok가 아닌 302나 303으로 리다이렉트 하도록 한다.

특수 리다이렉션

: 결과 대신 캐시를 사용하는 방법

4xx : 클라이언트의 오류

: 오류의 원인이 클라이언트에게 있는 경우이다. 뭔가 잘못된 문법이 있거나, 요청한 파라미터가 잘못된 경우가 그 예이다. 여러번 재시도해도 똑같이 실패한다.

• 400 Bad Request 잘못된 요청시 e.g. 요청 parameter가 잘못될때
• 401 unauthorized → 인증이 되지 않은 경우
• 403 forbidden → 서버가 요청은 정상적으로 이해했는데 승인이 거부된 경우
• 404 not found → 요청한 리소스가 없는 경우

5xx : 서버의 오류

→ 서버가 정상 처리되지 않은 경우 → 이때는 재시도시 성공할 수도 있음

• 500 Internal Server Error 애매하면 대부분 이 에러
• 503 서비스 이용 불가 → 서비스가 과부하 또는 점검으로 일시적으로 다운된 경우

클라이언트가 서버에게 요청할때 기대하는것입니다.

자주 사용하는 HTTP Method에는 크게 GET, POST, PUT, PATH, DELETE가 있습니다.

GET

조회하는데 사용합니다. 쿼리 파라미터를 통해서 조회의 대상을 전달합니다. 바디를 통해서도 전달이 가능하지만, 지원하지 않는 서버가 많다고 알고 있습니다.

POST

요청한 data에 대한 처리를 하는 Method이고, 주로 등록하는데 많이 사용합니다. 바디를 통해서 요청할 데이터를 전달하고, 서버는 요청한 데이터를 처리합니다. 포스트 요청에 대해서는 리소스별로 각자 액션을 정의해줘야합니다.

역할은 크게

1. 새 리소스의 생성
2. 요청한 데이터의 처리 → 단순히 값의 변경이 아닌, process의 상태가 변경되는 경우에 사용합니다.
3. 다른 메소드로 처리하기 애매한 경우

가 있습니다.

PUT

폴더에 파일을 넣는다고 생각하면 이해가 쉬운데, 이미 해당 리소스가 있으면 완전히 대체, 없으면 새로 작성하는 메소드입니다. "수정"이 아닌 덮어쓰기의 개념입니다. 클라이언트가 리소스를 식별하여 구체적인 리소스의 URL을 알고 있습니다.

PATCH

리소스를 부분 변경하는 메소드입니다. 해당 필드만 부분 변경이 가능하고, 일부 지원되지 않는 서버의 경우에는 POST로 사용합니다.

DELETE

리소스를 삭제할때 사용합니다.

IP 프로토콜은 지정한 주소로 packet을 전달하는 프로토콜입니다.

특징

• 비연결성 : 패킷을 받을 대상이 없거나 불능이어도 알 수 없음
• 비신뢰성 : 중간에 패킷이 사라지거나, packet이 순서대로 오지 않아도 알 수 없음

-> 이런 IP의 한계를 해결하자~

TCP와 UDP

이런 IP의 한계를 해결하기 위해서 Transport 계층에서 사용하는 프로토콜이 TCP와 UDP입니다.

TCP

• 연결 지향형 : 3 way handshake

• 수신자가 SYN를 보내면 송신자는 잘 받았단 뜻의 ACK + SYN, 수신자는 SYN에 대해 ACK를 보내고, 이로서 통신이 시작됩니다.

• 데이터 전달 보증: 패킷이 누락되면 알 수 있습니다.
• 순서보장: packet의 순서가 보장됩니다.

-> 따라서 TCP는 신뢰가능한 프로토콜!

UDP

• 연결지향x, 순서보장x, 데이터 전달 보장 x인 프로토콜입니다. IP와 거의 같지만, 차이점은 Port 번호 정보와 checksum을 포함한다는 것입니다.
• TCP보다 속도가 빠르다는 장점이 있습니다.
• 요즘은 UDP가 각광받고 있는데, HTTP3에서 최적화를 위해 UDP를 사용하기 떄문입니다.

  port?

  한 IP에서 프로세스를 구분하기 위해 사용하는 주소

pipeline의 시나리오는 다음과 같습니다.

• git checkout
• gcc hello.c; ./a.out > index.html
• docker build image
• docker push image
• docker run image

New Item에서 Pipeline을 만들어 줍니다.

스크립트는 http://3.37.87.174:8080/job/demo/pipeline-syntax/ 를 참고할 수 있습니다. credentials는 public repo라 없어도 되지만 한번 설정해보았습니다. 연결하려는 github의 계정정보를 입력하면 됩니다. 여기서 만든 pipeline script를 checkout stage에 추가해줍니다.

master instance에서 확인했을때 맞게 checkout됐음을 알 수 있습니다.

docker pipeline을 사용하기 위한 plugin을 설치합니다. master node에 docker-jenkins 권한을 설정해줍니다.

sudo usermod -aG docker jenkins
sudo chown root:jenkins /var/run/docker.sock

dockerhub에 로그인 하기 위한 credentials를 설정합니다. 명령어 자체를 입력해서 비밀번호를 하드코딩 해서 넣을 수도 있지만, 비밀번호 노출을 막기 위해 credentials binfing plugin을 활용합니다. 위의 github credentials 설정과 같이 http://3.37.87.174:8080/job/demo/pipeline-syntax/ 에서 script를 작성합니다.

에서 Username and password를 선택합니다. 두개중에 아무거나 골라도 상관 무,, 저는 seperated를 골랐습니당 도커 계정 정보를 입력합니다. 여기서 generate한 스크립트를 다음 스테이지에 넣어줍니당

전체 시나리오에 대한 pipeline scipt은 다음과 같습니다.

node {
    stage('git checkout'){
        git branch: 'master', credentialsId: 'gitpasswd', url: 'https://github.com/wookyoungkim/CICD'
    }
    stage('compile hello.c and produce index.html'){
        sh 'gcc hello.c'
        sh './a.out > index.html'
    }
    stage('build docker image'){
        sh 'docker build -t viliketh1s/myweb:1.1.0 .'
    }
    stage('push docker image'){
        withCredentials([usernamePassword(credentialsId: 'docker', passwordVariable: 'dockerpwd', usernameVariable: 'dockeruser')]) {
            sh "docker login -u ${dockeruser} -p ${dockerpwd}"
        }
        sh 'docker push viliketh1s/myweb:1.1.0'
    }
    stage('deploy demo container'){
        sh 'docker run -itd -p 5000:80 --name my-app viliketh1s/myweb:1.1.0'
    }
}

으음 ,,, ^ ^낫 이지 ^_ㅠ 졸프에서 빌드 자동화툴로 써먹어야지

첫번째 project 만들기

New Item 클릭

이 프로젝트가 build node에서만 실행될 수 있도록 설정해줍니다.

연결할 github의 repository 주소를 입력해줍니다. 브랜치는 기본 Master로 설정해주었습니다. 브랜치 안만들거라,,

Build Trigger는 GitHub hook trigger for GITScm polling 를 선택! 말 그대로 GitHub 의 hook trigger 를 받으면 빌드를 하겠다는 뜻임

지금은 build툴을 사용하지 않을것이므로 build는 따로 설정해주지 않았습니다. 까지 설정하고 save~

repository에 새 commit을 올려서 제대로 반영이 되는지 확인해봅시다.

만든 프로젝트를 run 해봅니다. 빌드 히스토리를 보면 맞게 빌드됨을 확인할 수 있습니다.

두번째 프로젝트 만들기

첫번째 프로젝트에서 pull받아온 코드를 컴파일하고 빌드하는 프로젝트를 만들어보겠습니다. 아까와 같이 new items를 클릭하여 새 프로젝트를 만듭니다. 대상을 아까처럼 build agent로 설정해주고, git은 사용하지 않을 것이므로 선택하지 않습니다.

빌드는 쉘을 사용해서 다음과 같은 스크립트로 컴파일->빌드하려고 합니다.

빌드에 사용하기 위한 gcc와 docker를 Agent instance에 설치합니다.

sudo apt-get install docker.io
sudo apt-get install gcc

설치 후 두번째 프로젝트를 빌드합니다.

성공 😎

Agent Instance의 public IP주소에서 접근하여 맞게 빌드됐는지 확인해봅시당 .

두 프로젝트를 엮어보자

지금은 수동으로 Build Now를 클릭해서 빌드하였는데, 첫번째 프로젝트가 문제없이 빌드되면 두번째 프로젝트가 수행되도록 해보겠습니다.

첫번째 프로젝트의 configure를 수정합시다. 빌드 후 다른 프로젝트를 빌드하도록 설정!

Github에서 WebHook을 추가합니다. Jenkins가 돌고있는 인스턴스의 publicIP:8080으로 주소를 설정해줍니다.

repo에 새 commit을 하여 자동화되었는지 확인해봅시다.! 첫번째 pull-code가 실행되고, 두번째인 compile-build를 트리거했다는 로그를 볼 수 있습니다. compile-build의 로그에서 pull-code에 의해 실행되었고, 설정한 스크립트대로 수행되었음을 볼 수 있습니다.

가장 널리 쓰이는 DevOps Integrity 도구

• 오픈소스이다
• 어떤 SW DevOps도 자동화가 가능하다
• Java로 작성되어 있음

설치하기

https://linuxize.com/post/how-to-install-jenkins-on-ubuntu-18-04/ 와 https://pkg.jenkins.io/debian-stable 를 참고해서 설치했습니다. 이해를 위해 흰 배경은 Master, 회색 배경은 Agent로 사용하겠습니다.

새 인스턴스 생성

Master로 쓸 인스턴스 하나와 Agent로 쓸 인스턴스 하나를 생성합니다.

Master와 Agent 사이의 통신을 위해 다음과 같이 보안 규칙을 수정해줍니다. 특정 포트로 통신할 수도 있지만 간단한 실습을 위한 것이니 그냥 어디서든 접근 가능하게 수정해줍니다.

인스턴스에 자바 설치하기

Jenkins는 자바로 작성된 프로그램이므로 인스턴스에 자바를 설치해줍니다.! Master Instance sudo apt install openjdk-8-jdk 자바 8을 사용해야 동작하므로 맞는 버전을 설치해줍니다. BuildAgent Instance에서도 마찬가지로 자바를 설치해줍니다.

Master에 Jenkins 설치

https://pkg.jenkins.io/debian-stable 를 참고하여 Master Instance에 젠킨스를 설치합니다.

Master Node에서 sudo 권한으로 바꿉니다. -> 해당 위치는 일반 권한으로 접근이 안되기 떄문에~ sudo su /etc/apt/sources.list 파일의 맨 윗줄에 다음 명령어를 추가합니다. deb https://pkg.jenkins.io/debian-stable binary/

저장하고, 루트권한을 종료시킨뒤 젠킨스를 설치합니다. sudo apt-get update sudo apt-get install jenkins

맞게 설치되어 동작하는지 확인합니다~

젠킨스 접속하기

Master Instance의 퍼블릭IPv4:8080으로 접속하면 다음과 같은 화면을 볼 수 있습니다. 페이지에 안내되어있는 경로를 접속하여 비밀번호를 찾고, 해당 비밀번호를 입력합니당. sudo cat /var/lib/jenkins/secrets/initialAdminPassword 전 왼쪽의 suggested plugins를 선택하여 설치했습니다. 설치가 오래 걸린다,,

적절한 유저네임, 패스워드를 설정한다음 Continue!

Agent 기계와 연결될 수 있도록 설정합니다. Random port로 클릭! Agent로 사용할 New Node를 추가합니다. 적절한 이름을 생성해주고, 아까 Master Node에 생성한 jenkins 폴더의 경로를 Labels에 입력, Launch Method는 connecting to the master로 설정해줍니다.

Master와 Agent 연결하기

build node 클릭! Launch를 클릭해서 jnlp파일을 다운받고, agent.jar 파일을 다운받습니다.

깃헙 레포지토리를 하나 파고, 아까 다운받은 두 파일을 업로드 해줍니다.

Agent에 Git 설치

Agent Instance에 git을 설치합니다. sudo apt-get install -y git Agent에 jenkins 디렉토리를 만들고 git init & 아까 만든 레포지토리를 origin으로 설정해줍니다. 그리고 풀받아오기 !

git init
git remote add origin {레포지토리주소}
git pull origin master

그리고 아까 Jenkins에서 안내해준 cmd를 입력합니다.

java -jar agent.jar -jnlpUrl http://3.37.87.174:8080/computer/build/jenkins-agent.jnlp -secret 48bccd95d36f1ba45658657a1d88557b94814bca39070eaff9873e14e537552f -workDir "/home/ubuntu/jenkins"

-> 연결 완 료 @~!!

자바의 ORM 기술 표준으로 인터페이스의 모음이다. → 이를 실제로 구현한 구현체가 하이버네이트

• ORM? Object Oriented Mapping: RDB 테이블을 객체지향적으로 사용하기 위한 기술

Java 어플리케이션과 JDBC 사이에서 동작한다.

→ 개발자가 JPA를 사용하면 JPA 내부에서 JDBC API를 사용하여 SQL을 호출하고, DB와 통신한다.

Spring Data JPA

JPA를 한단계 더 추상화시킨 Repository 인터페이스를 제공

→ 정해진 규칙대로 메소드를 입력하면, 해당 메소드에 맞는 쿼리를 날리는 구현체를 만들어서 Bean으로 등록해준다.

장점

• 반복된 코드를 제거하므로 생산성이 크게 향상
• SQL을 직접 실행함으로서 객체 중심의 설계가 가능 → SQL 중심 개발? 코드 반복이 많음, 모델링 과정에서 문제 발생
• 기본적인 CRUD를 제공한다. 개발자가 핵심 비즈니스 로직에만 집중할 수 있게 해준다.

단점

• 복잡한 쿼리보다는 실시간 처리용 쿼리에 최적화되어있다.

  : 통계와 같이 미세하게 쿼리작업이 필요하면 Mybatis등의 다른 Mapper 방식을 사용해야한다

데이터 생성 프로그램이 종료되어도 데이터는 사라지지 않는 특성 → 파일시스템, RDB 등을 사용해서 객체에 영속성을 부여한다.

Persistence Framework

JDBC

자바에서 DB에 접근하기 위해 사용하는 API → 모든 Persistence Framework는 내부적으로 JDBC API를 이용한다.

이러한 Persistence를 부여하는 Framework에는 두가지 종류가 있다.

SQL Mapper

SQL과 객체를 매핑 → 직접 SQL을 다뤄서 매핑한다. → MyBatis, JDBCTemplate

• MyBatis : SQL, procedure 등을 지원하는 SQL Mapper이다. SQL에 대한 모든 control이 가능하다.
• JDBCTemplate : 스프링의 가장 기본적인 Data Access 템플릿으로 쿼리 기반으로 데이터 베이스의 접근 가능

ORM

Object Oriented Mapping의 약자로 RDB과 객체를 매핑하는 기술이다. 프로그래머가 SQL을 직접 다룰 필요 없이, SQL을 자동 생성해준다. → JPA

장점

• 객체 지향적인 코드로 인해 더 직관적이고 비즈니스 로직에 더 집중할 수 있게 도와준다.
• 재사용 및 유지보수의 편리성이 증가한다.
• DBMS에 대한 종속성이 줄어든다.

단점

• 완벽한 ORM 으로만 서비스를 구현하기가 어렵다.
• 프로시저가 많은 시스템에선 ORM의 객체 지향적인 장점을 활용하기 어렵다.

출처

https://gmlwjd9405.github.io/2018/12/25/difference-jdbc-jpa-mybatis.html https://github.com/WeareSoft/tech-interview/blob/master/contents/db.md#orm%EC%9D%B4%EB%9E%80

• 주소를 잃어버려서 사용할 수 없는 정리되지 않은 메모리
• 앞으로 사용하지 않고 메모리를 가지고 있는 객체

Garbage Collector

• 이러한 가비지들을 메모리에서 정리하여 다른 용도로 사용할 수 있게 해주는 프로그램

• 자바는 개발자가 명시적으로 메모리 해제를 수행하지 않고, 가비지 컬렉터가 대신 해줌 → C에서는 free()를 이용해서 직접 해제

• GC의 대상 : 객체가 NULL 인 경우, 블록 안에서 객체가 생성되고 블록의 실행이 끝난 경우

GC의 동작

Minor GC와 Major GC

GC는 두가지 가정 하에 동작한다.

1. 대부분의 객체는 금방 접근 불가능 상태(unreachable)가 된다.
2. 오래된 객체에서 젊은 객체로의 참조는 아주 적게 존재한다.

이 가설에 기반하여, 영역을 young 영역, old 영역 두가지로 나눈다.

→ young 영역에서의 GC가 Minor GC, old 영역에서의 GC가 Major GC이다.

Minor CG

• young 영역 : eden영역 + 2*survivor 영역

1. 새롭게 생성되는 객체는 eden 영역에 생성
2. eden 영역이 가득차게 된다면 minor GC → 살아남은 객체들을 survivor영역 중 하나로
3. survivor 영역이 가득차게 되면 살아남은 객체를 다른 survivor 영역으로
4. aging이 되고 정해진 threshold를 넘으면, old 영역으로

Major GC

Old 영역의 메모리가 부족해지면 발생하게 된다.

→ Old 영역은 Young 영역보다 크고, Young 영역을 참조할 수도 있기 때문에 일반적으로 Minor GC보다 오래걸림

동작방식

stop-the-world

• GC을 실행하기 위해 JVM이 애플리케이션 실행을 멈추는 것

  → GC 관련 스레드를 제외한 모든 스레드의 동작을 중단

  → GC 튜닝? 이 stop-the-world 시간을 줄이는 것

Mark and Sweep

• Mark: 힙(heap) 내의 객체 중에서 가비지를 식별하는 작업

  → reachability라는 개념을 사용 : 어떤 객체에 유효한 참조가 있으면 'reachable'로, 없으면 'unreachable'로 구별하고, unreachable 객체를 가비지로 간주해 GC를 수행

• Sweep: Mark 단계에서 찾은 가비지를 처리해서 메모리를 회수하는 작업

출처

https://d2.naver.com/helloworld/329631 https://d2.naver.com/helloworld/1329

기본규칙

1. URL은 자원에 대한 정보를 포함한다.
2. 자원에 대한 행위는 HTTP Method로 표현한다.

RESTful URL 작성하기

1. 소문자로 !
2. 동사보다는 명사를 사용한다. : 단순 명사가 아니라 복수 명사를 사용한다.
3. 언더바대신 하이픈을 사용한다. : 하이픈도 사용하지 않는게 좋다고 함
4. 행위는 포함하지 않는다.
5. /는 계층을 나타낸다.

생성자가 여러 차례 호출되더라도 실제로 생성되는 객체는 하나이고 최초 생성 이후에 호출된 생성자는 최초의 생성자가 생성한 객체를 리턴한다. -위키피디아-

객체를 하나만 생성하고, 생성된 객체를 어디서든 참조가능하게 하여 프로그램 전반에서 하나의 인스턴스만 사용하게 하는 패턴이다.

자바의 싱글톤 패턴

• private 사용 : 생성자를 private으로 선언하여 외부에서의 호출과 상속이 불가능하게 지정

장점

• 메모리 낭비 방지 : 한번의 new로 인스턴스를 사용하므로 메모리 낭비를 방지할 수 있다.
• 데이터의 공유가 용이함 : 전역 인스턴스이므로 다른 클래서의 인스턴스들과 데이터 공유가 쉬움
• 주로 공통된 객체를 여러개 생성해서 사용하는 DBCP(DataBase Connection Pool)와 같은 상황에서 많이 사용 -> DBCP란? 데이터베이스와 애플리케이션을 효율적으로 연결하는 커넥션 풀 라이브러리

문제점

• 동시성 문제 고려 : 멀티쓰레드 환경에서 제대로 동기화 하지 않으면 race condition이 발생하여 인스턴스가 두개 생성되는 경우가 발생 가능
• 개방 폐쇄 원칙 위배 가능 : 각 객체간의 결합도가 높아지고, 변경에 유연하게 대처할 수 없다.

동시성 문제 해결 방법

방법 1: 정적 변수에 인스턴스를 만들어 바로 초기화하기

private static Printer printer = new Printer();

와 같이 static 변수에 바로 인스턴트를 만들어서 초기화시킨다.

-> static 변수란? 객체가 생성되기 전 클래스가 메모리에 로딩될 때 만들어져 초기화가 한 번만 실행된다.
프로그램 시작~종료까지 없어지지 않고 메모리에 계속 상주하며 클래스에서 생성된 모든 객체에서 참조할 수 있다.

방법 2: 메소드에 동기화 블록을 지정하기

인스턴스를 만드는 메소드에 synchronized를 지정하여 해당 메소드를 임계구역으로 지정한다. -> 다중 스레드 환경에서 여러 스레드가 동시에 접근하는 것을 방지한다.

출처

https://ko.wikipedia.org/wiki/%EC%8B%B1%EA%B8%80%ED%84%B4_%ED%8C%A8%ED%84%B4 https://gmlwjd9405.github.io/2018/07/06/singleton-pattern.html https://velog.io/@kyle/%EC%9E%90%EB%B0%94-%EC%8B%B1%EA%B8%80%ED%86%A4-%ED%8C%A8%ED%84%B4-Singleton-Pattern

10942 - 펠린드롬?

문제설명

N개의 자연수에 대해서 M번의 질문을 받는다. 각 질문은 두 정수 S와 E(1 ≤ S ≤ E ≤ N)로 나타낼 수 있으며, S번째 수부터 E번째 까지 수가 팰린드롬을 이루는지 물어본다. 펠린드롬이면 1을, 아니면 0을 반환한다.

문제풀이

DP로 풀이하는 문제이다. nums[S:E+1]에 대해서 해당 문자가 펠린드롬이기 위해서는 -> nums[S] == nums[E]이고, nums[S-1:E]가 펠린드롬이어야 한다. 여기서 nums[S-1:E]의 부분을 DP로 처리한다.

크게 세가지 경우로 나누어서 풀이했다.

1. 문자열의 길이가 1인 경우 이때는 무조건 팰린드롬이다.
2. 문자열의 길이가 2인 경우 (E=S+1) nums[S]==nums[S+1]이면 팰린드롬이다.
3. 문자열의 길이가 3인 경우 nums[S] == nums[E]이고, nums[S-1:E]

import sys

input = sys.stdin.readline

N = int(input())
nums = list(map(int, input().split()))
M = int(input())
questions = []
dp = [[0 for _ in range(N)] for _ in range(N)]

for i in range(N):
    dp[i][i] = 1

for i in range(N-1):
    if nums[i] == nums[i+1]:
        dp[i][i+1] = 1

for l in range(2, N):
    # 길이가 3 이상
    for i in range(N-l):
        # 처음 문자 == 마지막 문자 && dp[처음+1][마지막-1]
        if nums[i] == nums[i+l] and dp[i+1][i+l-1] == 1:
            dp[i][i+l] = 1


for m in range(M):
    S, E = map(int, input().split())
    print(dp[S-1][E-1])

dp는 참 한번에 떠올리기 어려움,,

1261 - 알고스팟

문제 설명

N*M크기의 미로는 1*1크기의 방으로 이루어져 있다. 각 칸은 빈 방 또는 벽으로 이루어져 있고, 벽은 부수지 않으면 이동할 수 없다. 이동은 상하좌우 인접한 칸으로 가능하다. 현재 (1, 1)에서 (N, M)으로 이동하려면 벽을 최소 몇 개 부수어야 하는지 구하는 프로그램을 작성하시오.

문제 풀이

BFS + 우선순위 큐로 풀이하면 된다.

[부신 벽의 개수,시작 좌표]를 힙에 넣고, 부신 벽의 개수가 작은 순서대로 차례대로 pop하면서 이동가능한 칸에 대해 다시 append해주면 된다.

import sys
from collections import deque
import heapq

input = sys.stdin.readline
dx = [-1, 0, 1, 0]
dy = [0, -1, 0, 1]

def in_bound(x, y):
    if x in range(N) and y in range(M):
        return True
    return False

M, N = map(int, input().split())
board = []
for _ in range(N):
    board.append(list(map(int, list(input().strip()))))

queue = []
heapq.heappush(queue, [0,0,0])
visited = [[False for _ in range(M)] for _ in range(N)]
visited[0][0] = 0

while queue:
    count, x, y = heapq.heappop(queue)

    if x == N-1 and y == M-1:
        print(count)
        break

    for i in range(4):
        nx, ny = x+dx[i], y+dy[i]
        if in_bound(nx, ny) and visited[nx][ny] == False:
            if board[nx][ny] == 1:
                heapq.heappush(queue, [count+1, nx,ny])
            else:
                heapq.heappush(queue, [count, nx,ny])
            visited[nx][ny] = True

BFS+우선순위큐 조합의 문제는 처음 풀어보는데 담에 이런 문제 풀때 바로 생각 날라나 ,,

5430 - AC

문제 설명

AC는 정수 배열 연산을 위한 언어다. 이 언어에는 두 가지 함수 R(뒤집기)과 D(버리기)가 있다.

함수 R은 배열에 있는 숫자의 순서를 뒤집는 함수이고, D는 첫 번째 숫자를 버리는 함수이다. 배열이 비어있는데 D를 사용한 경우에는 에러가 발생한다.

배열의 초기값과 수행할 함수가 주어졌을 때, 최종 결과는?

문제 풀이

deque를 이용해서 푸는 문제이다.

입력

입력이 좀 까다롭다고 느껴졌다. 연산할 정수 배열이 "배열"형태로 주어지기 때문에 앞뒤로 붙은 []와 ,를 파싱해야 한다. python에서 제공되는 strip으로 []와 뒤에 붙는 개행 문자를 제거하고, split을 이용해서 ,를 기준으로 나누었다. 빈 배열이 들어오는 경우를 처리하기 위해 if nums[0] != '':를 통해 처리했다. 이렇게 파싱한 결과를 deque에 저장한다.

nums = list(input().strip("[]\n").split(","))
if nums[0] != '':
    nums = list(map(int, nums))
    nums = deque(nums)
else:
    nums = []

연산의 수행

R 연산의 경우 매번 reverse를 하게되면 시간 초과가 발생한다. 따라서 R 연산을 짝수번 수행했는지, 홀수번 수행했는지 저장하는 플래그를 이용했다.

D 연산의 경우에 R을 짝수번 수행한 경우 맨 앞의 원소를 pop, 홀수번 수행한 경우에는 맨 뒤의 원소를 pop한다. 위에서 구한 플래그에 따라 연산해주면 된다.

    count_reverse = 1 # 1: 원상태 2: 한번 reverse된 상태

    for f in funcs:
        if f == 'R':
            count_reverse *= -1
        elif f == 'D':
            if len(nums) == 0:
                flag = False
                print("error")
                break
            elif count_reverse == 1:
                nums.popleft()
            else:
                nums.pop()

결과의 출력에 약간의 낚시가,, 있는데 파이썬의 리스트 그대로 출력하면 안된다. 정답의 출력 형태는 [1,2,3,5,8]와 같이 원소를 나누는 , 뒤에 띄어쓰기가 없기 때문,,

    print("[", end='')

      if len(nums) > 0:
          if count_reverse == 1:
              for i in range(len(nums)-1):
                  print(nums[i], end=',')
              print(nums[-1], end='')
          else:
              for i in range(len(nums)-1, 0, -1):
                  print(nums[i], end=',')
              print(nums[0], end='')
      print("]")

따라서 위와 같이 처리해주었다.

전체 코드

import sys
from collections import deque

input = sys.stdin.readline

T = int(input())
answer = []

for t in range(T):
    funcs = list(input().strip())
    N = int(input())
    nums = list(input().strip("[]\n").split(","))
    if nums[0] != '':
        nums = list(map(int, nums))
        nums = deque(nums)
    else:
        nums = []

    flag = True

    count_reverse = 1 # 1: 원상태 2: 한번 reverse된 상태

    for f in funcs:
        if f == 'R':
            count_reverse *= -1
        elif f == 'D':
            if len(nums) == 0:
                flag = False
                print("error")
                break
            elif count_reverse == 1:
                nums.popleft()
            else:
                nums.pop()

    if flag:
        print("[", end='')

        if len(nums) > 0:
            if count_reverse == 1:
                for i in range(len(nums)-1):
                    print(nums[i], end=',')
                print(nums[-1], end='')
            else:
                for i in range(len(nums)-1, 0, -1):
                    print(nums[i], end=',')
                print(nums[0], end='')
        print("]")

Download Python에서 OS에 맞게 설치한다.

-> pip란? package installer for python: python의 여러 패키지를 쉽게 설치하고 관리하게 해주는 역할 -> mac의 brew나 ubuntu의 apt-get과 같은 패키지 관리 툴임

2. selenium 라이브러리 설치

pip3 install -U selenium

3. Chrome Webdriver 설치

chromedriver.chromium.org에서 OS에 맞게 다운로드한다.

4. webdriver 사용 실습

webdriver를 간단히 실습해보았다. 다운받은 드라이버를 /drivers안에 넣어주고, 다음과 같은 코드를 실행한다.

from selenium import webdriver
import time

driver = webdriver.Chrome("/Users/kimwookyoung/Desktop/2021/2021-1/소공/selenium-demo/drivers/chromedriver")
driver.implicitly_wait(10)
driver.get("http://google.com")
driver.find_element_by_name("q").send_keys("Hongik University")
driver.find_element_by_name("btnK").click()
driver.maximize_window()
driver.refresh()
time.sleep(2)
driver.quit()
print("Test Completed")

5. Unit Test 실습

from selenium import webdriver
import HtmlTestRunner
import unittest
import time


class DemoUnitTest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.driver = webdriver.Chrome("/Users/kimwookyoung/Desktop/2021/2021-1/소공/selenium-demo/drivers/chromedriver")
        cls.driver.implicitly_wait(10)
        cls.driver.maximize_window()

    def test_GoogleSearch_Hongik(self):
        self.driver.get("https://google.com")
        self.driver.find_element_by_name("q").send_keys("HongikUniversity")
        self.driver.find_element_by_name("btnK").click()

    @classmethod
    def tearDownClass(cls):
        time.sleep(3)
        cls.driver.close()
        cls.driver.quit()

    print("Test Done Successfully!")


if __name__ == '__main__':
    unittest.main(testRunner=HtmlTestRunner.HTMLTestRunner(output='/Users/kimwookyoung/Desktop/2021/2021-1/소공/selenium-demo/reports'))