깔끔한 UI와 태그로 카테고리를 나눠주는 기능, 부제목에 따라 오른쪽에 목차가 자동 생성되는 이점 때문에 사용했지만 velog 처음 진입 시 로딩이 너무 길다. 왜? 인지는 모르겠으나 이외에도 글을 장시간 작성할 경우 작성하기 버튼을 누르면 화면이 움직임 없이 그대로 멈춰 있고 시리즈 추가한 상태에서 작성하기를 여러번 누르면 글은 1개인데 시리즈 목록에는 2개가 생성된다.

위와 같은 이유로 자잘한 스트레스를 받고 있다가 결국 더는 못 쓸 것 같는 결론에 도달했다 😂

velog 접속하면 간헐적으로 일어났던 로딩 문제 이미지 첨부합니다.

velog 그동안 고마웠다.. 잘 가라 🤚🏻🤚🏻 나머지 글은 다시 티스토리에 이어서 작성하도록 하겠습니다.

티스토리에서 만나요! 😘 https://jokerapp.tistory.com/

📝 나의 문제풀이

class Solution {
    fun solution(strList: Array<String>): Array<String> {
        // "l"과 "r"의 인덱스를 찾음
        val lIndex = strList.indexOf("l")
        val rIndex = strList.indexOf("r")

        // "l"과 "r" 중 먼저 나오는 문자열에 따라 결과 반환
        return when {
            lIndex in strList.indices && (rIndex !in strList.indices || lIndex < rIndex) -> {
                strList.copyOfRange(0, lIndex)
            }
            rIndex in strList.indices -> {
                strList.copyOfRange(rIndex + 1, strList.size)
            }
            else -> {
                arrayOf() // "l"과 "r"이 모두 없는 경우 빈 배열 반환
            }
        }
    }
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(strList: Array<String>): Array<String> {
        if (!strList.contains("r") && !strList.contains("l")) return emptyArray()
        if (strList.contains("l") && (!strList.contains("r") || strList.indexOf("l") < strList.indexOf("r"))) return strList.sliceArray(0 until strList.indexOf("l"))
        if (strList.contains("r") && (!strList.contains("l") || strList.indexOf("r") < strList.indexOf("l"))) return strList.sliceArray((strList.indexOf("r") + 1) until strList.size)
        return emptyArray()
    }
}

🖊 문제 풀이 시 알면 좋을 것

• indexOf

  • 특정 요소가 배열에 존재하면 해당 요소의 첫 번째 인덱스를 반환.
  • 요소가 없으면 -1 반환.

    val index = arrayOf("a", "b", "c").indexOf("b") // 결과: 1
    val notFound = arrayOf("a", "b", "c").indexOf("d") // 결과: -1

• contains

  • 배열에 특정 요소가 포함되어 있는지 확인.
  • 반환값: true 또는 false.

    val hasElement = arrayOf("a", "b", "c").contains("b") // 결과: true
    val notFound = arrayOf("a", "b", "c").contains("d") // 결과: false

• when 표현식

  • 여러 조건을 분기 처리할 때 간결하고 읽기 좋은 구문.
  • 조건문 대신 사용 가능.

    val x = 10
    val result = when {
    x > 5 -> "Greater than 5"
    x == 5 -> "Equal to 5"
    else -> "Less than 5"
    }
    
    

• emptyArray

  • 빈 배열 생성 시 사용.
  • 배열에 아무것도 반환할 필요가 없을 때 유용.

    val empty = emptyArray<String>() // 결과: []

• sliceArray

  • 배열의 특정 범위를 추출하여 새로운 배열을 반환합니다.
  • 범위는 IntRange 또는 until 키워드로 지정.
  • 인덱스 포함 여부:
    • 시작 인덱스는 포함.
    • 끝 인덱스는 포함.

      val array = arrayOf("a", "b", "c", "d")
      val result = array.sliceArray(0..2) // ["a", "b", "c"] (인덱스 0, 1, 2 포함)
      val result2 = array.sliceArray(1 until 3) // ["b", "c"] (인덱스 1, 2 포함)

• copyOfRange

  • 배열의 시작 인덱스와 끝 인덱스를 지정하여 새로운 배열을 반환합니다.
  • 인덱스 포함 여부:
    • 시작 인덱스는 포함.
    • 끝 인덱스는 포함되지 않음.

      val array = arrayOf("a", "b", "c", "d")
      val result = array.copyOfRange(0, 3) // ["a", "b", "c"] (인덱스 0, 1, 2 포함, 3은 제외)
      val result2 = array.copyOfRange(1, 3) // ["b", "c"] (인덱스 1, 2 포함, 3은 제외)
      
      

sliceArray vs copyOfRange

📝 나의 문제풀이

class Solution {
    fun solution(numList: IntArray, n: Int): IntArray {
         val aList = numList.copyOfRange(n, numList.size)
         val bList = numList.copyOfRange(0, n)
         return aList + bList
    }
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(numList: IntArray, n: Int) = (numList + numList).copyOfRange(n, n + numList.size)
}

🖊 문제 풀이 시 알면 좋을 것

• copyOfRange
  • 배열의 특정 범위를 복사해 새로운 배열을 반환.
  • 포함 여부: 시작 인덱스는 포함, 끝 인덱스는 제외.

    val array = intArrayOf(1, 2, 3, 4, 5)
    val subArray = array.copyOfRange(1, 4) // 1번부터 3번까지 복사
    println(subArray.joinToString()) // 출력: 2, 3, 4
    
    

• 효율적인 배열 회전 (다른 사람의 풀이)
  • (numList + numList)로 배열을 두 번 이어 붙여 하나의 큰 배열 생성.
  • 필요한 범위만 copyOfRange로 잘라서 반환.
  • 메모리 효율적이며, 코드가 간결해짐.

    val numList = intArrayOf(1, 2, 3, 4, 5)
    val rotated = (numList + numList).copyOfRange(2, 7)
    println(rotated.joinToString()) // 출력: 3, 4, 5, 1, 2
    

```

📝 나의 문제풀이

class Solution {
    fun solution(num_list: IntArray, n: Int): IntArray {
       return if(n-1 == num_list.size){
            intArrayOf(num_list[n-1])
    }else{
            num_list.sliceArray((n-1)..(num_list.size-1))
        }
    }
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(numList: IntArray, n: Int) = numList.copyOfRange(n - 1, numList.size)
}

🖊 문제 풀이 시 알면 좋을 것

• sliceArray
  • sliceArray는 범위의 시작 인덱스와 끝 인덱스를 모두 포함한다
  • 반환 타입: 호출한 배열과 같은 타입의 배열을 반환합니다.

    val array = intArrayOf(1, 2, 3, 4, 5)
    val sliced = array.sliceArray(1..3)
    println(sliced.joinToString()) // 출력: 2, 3, 4

• copyOfRange
  • 배열의 특정 범위의 요소들을 복사해 새로운 배열을 반환.
  • 끝값은 포함되지 않음 (startIndex부터 endIndex - 1까지).

    val array = intArrayOf(1, 2, 3, 4, 5)
    val copied = array.copyOfRange(1, 4)
    println(copied.joinToString()) // 출력: 2, 3, 4

📝 나의 문제풀이

class Solution {
    fun solution(arr: IntArray, query: IntArray): IntArray {
        var tempArr = arr 
        query.forEachIndexed{idx, value -> 
            tempArr = if(idx % 2 ==0){
            tempArr.take(value + 1).toIntArray()
        }else{
            tempArr.drop(value).toIntArray()
            }
        }
        return tempArr
    }
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(arr: IntArray, query: IntArray) = query.indices
        .fold(0 to 0) { (s, e), i -> if (i % 2 == 1) s + query[i] to e else s to s + query[i] }
        .let { (s, e) -> if (s == e) intArrayOf(-1) else arr.copyOfRange(s, e) }
}

🖊 문제 풀이 시 알면 좋을 것

• take(n)

  • 배열 또는 리스트에서 앞에서부터 n개의 요소를 가져옴.
  • 반환 타입: List

    val arr = listOf(1, 2, 3, 4, 5)
    println(arr.take(3)) // [1, 2, 3]

• drop(n)

  • 배열 또는 리스트에서 앞에서부터 n개의 요소를 제외한 나머지를 반환.
  • 반환 타입: List

    val arr = listOf(1, 2, 3, 4, 5)
    println(arr.drop(2)) // [3, 4, 5]

• fold(initial, operation)

  • 컬렉션을 순회하며 누적 작업을 수행.
  • 반환 타입: 누적 작업 결과 타입.

    val result = listOf(1, 2, 3).fold(0) { acc, value -> acc + value }
    println(result) // 6

• copyOfRange(startIndex, endIndex)

  • 배열에서 startIndex부터 endIndex 직전까지의 요소를 복사.
  • 반환 타입: 배열과 동일한 타입

  val arr = intArrayOf(1, 2, 3, 4, 5)
   val subArray = arr.copyOfRange(1, 4)
    println(subArray.joinToString()) // 2, 3, 4
  
  - indices
    - 배열이나 리스트의 모든 인덱스 범위를 반환.
    - 반환 타입: IntRange
  ```kotlin
     val arr = listOf(10, 20, 30)
     println(arr.indices) // 0..2

• let

  • 객체를 변환하거나 실행 블록을 전달받아 결과를 반환.
  • 반환 타입: 블록의 결과값

    val result = listOf(1, 2, 3).let { it.sum() }
    println(result) // 6

📝 나의 문제풀이

class Solution {
    fun solution(arr: IntArray, intervals: Array<IntArray>): IntArray {
     val result = mutableListOf<Int>()
        for ((first, second) in intervals) {
            result.addAll(arr.sliceArray(first..second).toList()) 
        }
        return result.toIntArray()
    }
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(arr: IntArray, intervals: Array<IntArray>): List<Int> {
        return intervals.flatMap { ints -> arr.sliceArray(IntRange(ints[0], ints[1])).toList() }
    }
}

🖊 문제 풀이 시 알면 좋을 것

• flatMap

  • flatMap은 컬렉션의 각 요소를 처리한 결과를 하나의 리스트로 합쳐주는 함수입니다. 각 요소에 대해 매핑된 결과를 평평하게(flatten) 만들어 줍니다.

    val nestedList = listOf(listOf(1, 2), listOf(3, 4))
    val flatList = nestedList.flatMap { it }
    println(flatList) // 출력: [1, 2, 3, 4]

• sliceArray

  • sliceArray는 주어진 인덱스 범위나 인덱스 리스트에 해당하는 배열의 부분 배열을 반환합니다.

    val arr = intArrayOf(1, 2, 3, 4, 5)
    val sliced = arr.sliceArray(1..3) // [2, 3, 4]
    println(sliced.joinToString()) // 출력: 2, 3, 4

• IntRange(start, endInclusive)

  • ntRange는 정수 범위를 표현하는 클래스입니다. start..end와 같이 범위를 생성하며, step 값을 추가해 범위를 커스터마이즈할 수도 있습니다.
  • 포함 범위: IntRange는 start부터 endInclusive까지 포함합니다. 즉, 끝값(endInclusive)도 범위에 포함됩니다.
  • 표현식: 1..5는 IntRange(1, 5)와 동일한 표현입니다
  • 사용 용도: 배열이나 리스트의 일부를 처리하거나 루프 범위를 지정할 때 자주 사용됩니다.

  val range = IntRange(1, 5)
  println(range.toList()) // 출력: [1, 2, 3, 4, 5]
  
  for (i in IntRange(3, 7)) {
    println(i) // 출력: 3, 4, 5, 6, 7
  }
  

내가 작성한 코드

@Parcelize
data class RouteResponse(
    @SerializedName("features")
    val features: List<FeatureEntity>
) : Parcelable

왜 위처럼 썼냐면

1. 해당 데이터를 bundle로 주고받을 일이 있어서 Parcelable과 @Parcelize를 사용함
2. RouteResponse를 API 통신을 통해 받아오고 있기 때문에 프로퍼티 매핑을 위하여 @SerializedName("features")을 사용함

결론: 찾아본 결과 함께 사용하는 것은 문제가 없다. 두 어노테이션은 서로 다른 용도로 사용되며 위 코드처럼 사용할 경우 각자 역할을 잘 수행할 수 있다.

그래도 이번 기회에 한번 더 직렬화/역직렬화에 대해 공부해보기로 함

Serializable에 대해 알아보자!

Serializable은 "직렬화 가능"이란 뜻이고 "시리얼라이져블"이라고 발음한다.

직렬화? 그게 뭔데.

데이터를 주고 받거나 저장할 때 일정한 형식으로 바꾸는 것을 뜻한다.

그러니까 어떤 것을 어떤 것으로 바꾼다는 건데...

자바에서 뜻하는 직렬화로 말하자면 객체를 바이트 스트림으로 변환하여 파일로 저장하거나 네트워크를 통해 전송할 수 있게 만드는 과정이다. 반대로, 바이트 스트림을 객체로 복원하는 "역직렬화" 라고 해!

(사진 출처 https://www.geeksforgeeks.org/serialization-in-java/)

왜 직렬화가 필요할까?

"바이트스트림이고 뭐고 그냥 저장하면 되는 거 아니야?" "왜 꼭 변환해서 저장해야 돼?" "왜 꼭 변환해서 데이터를 주고받아야 해?"

라고 생각할 수 있다.

그 이유는 우선 바이트 스트림은 어떠한 플랫폼에도 종속되지 않는다. 윈도우, 리눅스, 맥 등 서로 다른 환경에서도 같은 데이터를 해석할 수 있고 바이트 스트림은 저장 공간을 최소화하여 읽기/쓰기에도 빠르다! 또한 객체 구조 유지도 해준다. 속성 값, 참조 관계 등을 그대로 저장해준다. 네트워크로 데이터를 전송할 때는 표준적으로 바이트 단위를 사용하기 때문에 네트워크 통신도 수월해진다.

어떻게 사용하는데

Serializable은 Java 내장 지원을 하고 있고 Kotlin에서 사용할 경우에는 Kotlinx Serialization 라이브러리에서 제공하는 기능을 사용하면 쉽게 사용 가능하다.

나는 현재 kotlin을 주로 사용하고 있기 때문에 kotlin에서 사용하는 방법에 대해 알아보려고한다.

1. 일단, kotlinx.serialization 라이브러리 추가해줘야 한다. 프로젝트의 build.gradle에 아래 코드를 추가한다.

   dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")
   }

   
   
   
2. 그 다음 plugins 블록에도 kotlinx-serialization을 추가한다

   plugins {
    kotlin("plugin.serialization") version "1.9.0" // 사용 중인 Kotlin 버전에 맞춰 설정
   }

   
   
   
3. 다음은 직렬화가 필요한 class에 @Serializable 어노테이션 추가

   import kotlinx.serialization.Serializable
   

@Serializable data class Person( val name: String, val age: Int )

<br></br>
4. _JSON 직렬화 및 역직렬화도 가능하다_
`kotlinx.serialization.json.Json`을 사용해 객체를 JSON으로 변환하거나 JSON을 객체로 변환할 수 있음
```kotlin
import kotlinx.serialization.*
import kotlinx.serialization.json.*

fun main() {
    val person = Person("Alice", 25)

    // 직렬화: 객체 -> JSON 문자열
    val json = Json.encodeToString(person)
    println("직렬화된 JSON: $json")

    // 역직렬화: JSON 문자열 -> 객체
    val deserializedPerson = Json.decodeFromString<Person>(json)
    println("역직렬화된 객체: $deserializedPerson")
}

직렬화된 JSON: {"name":"Alice","age":25} 역직렬화된 객체: Person(name=Alice, age=25)

지금까지 자바에서 말하는 Serializable에 대해 설명하고 사용법은 왜 코틀린에서 사용하는 Serializable로 알려줘요? 둘이 같은 거 아니에요?!

Java Serializable와 Kotlinx Serialization 비교

참고로 도입부에서 말한 _바이트스트림_으로 변환해주는 직렬화는 자바에서의 Serializable을 말한 거고, kotlin에서 사용하는 Kotlinx Serialization와는 다르다. 밑에 표에서 살펴보자!

흠.. 그렇군 그럼 또

@Parcelize는 뭔데?

뭐 data class위에 어노테이션 갖다 붙이면 다 직렬화/역직렬화 알아서 시켜주는 것 같죠? 저도 뭣 모르고 사용하던 코흘리개 시절에는 둘의 차이점도 자세히 모르고 갖다 붙이면 알아서 변환해주것지.. 하고 썼슴미다..

둘 다 직렬화/역직렬화 해주는 건 맞는데 어떻게 해주는지, 그리고 어떤 상황에 사용하는지를 알고 써야 찐 개발자라고 할 수 있죠.. maybe

(저 아님)

@Parcelize는 번역하면 "소포화", 발음은 "파썰라이즈"이다. @Parcelize는 Kotlin에서 Parcelable 인터페이스를 자동으로 구현해주는 어노테이션이다. 이 어노테이션을 사용하면, 직렬화/역직렬화 과정을 매우 간편하게 처리할 수 있다.

Parcelable은 또 뭔데요?

Parcelable은 Android 시스템에 최적화된 직렬화 방식이다. 즉, Android에서 객체를 Intent, Bundle 등을 통해 전달할 수 있도록 하는 인터페이스

@Parcelize를 함께 사용하면 Kotlin에서 Parcelable을 쉽게 구현할 수 있도록 도와준다. @Parcelize를 사용하지 않을 경우 writeToParcel()와 describeContents() 메소드를 직접 구현해야 한다.

왜 Intent, Bundle 등을 통해 전달할 때는 Parcelable를 쓰라고 하는 거지?

Parcelable을 Intent, Bundle 등을 통해 객체를 전달할 때 사용하는 것이 권장되는 이유는 성능과 효율성 때문이다. Serializable도 직렬화 방식으로 사용할 수 있지만, Parcelable은 Android에서 더 최적화된 방식으로 데이터를 전달하는 데 유리하다.

• 성능(속도)이 뛰어난 이유 Parcelable은 Android 시스템에 맞게 최적화되어 있어서, 객체를 Parcel에 직렬화하고 이를 Intent나 Bundle로 전달할 때 훨씬 더 빠르고 메모리 효율적입니다.
  
  잠깐만.. Parcel은 또 뭐야? ( Parcel에 대해 궁금하다면 ? => https://developer.android.com/reference/android/os/Parcel )
  
  

Pacel은 Android 플랫폼에 특화된 클래스이고, 직렬화된 데이터를 담는 컨테이너인데 이 Parcel을 사용할 수 있는 것이 바로 Parcelable이다. Serializable은 Parcel을 사용할 수 없다..!!

즉, Parcelable은 Android의 Parcel 구조에 맞게 설계되어 있어, 객체를 전달하는 데 필요한 메모리 양이 적다. 이로 인해, 대규모 데이터를 처리할 때 메모리 소비가 적고 효율적이다.

Parcelable 작동방식

1. 데이터를 직렬화/역직렬화 해서 Parcel에 저장한다.
2. 그리고 Intent안에 Parcel 객체를 담아 Activity나 Service에 전달하고, 이 객체는 Intent가 도착한 곳에서 Parcel을 역직렬화하여 다시 원래의 객체로 복원할 수 있다.
   
   

📌 결론: Intent를 통해 데이터 전달 시 Parcelable은 Parcel 에 담아 전달! Serializable은 바이트스트림으로 변환하여 전달!

정리해 봅시다

1. Serializable과 Pacelable은 어떤 용도로 사용하나요?

-> 객체 또는 데이터를 직렬화/역직렬화할 때 사용하는 인터페이스입니다.

2. 자바에서의 직렬화가 뭔가요?

-> 객체 또는 데이터를 외부 시스템에서도 사용할 수 있도록 byte-stream 형태로 변환하는 기술을 의미합니다.

3. Serializable은 어떻게 직렬화시키나요? JVM이 자동으로 ObjectOutputStream을 통해 객체의 필드를 바이트 스트림으로 변환합니다.

4. Pacelable은 어떻게 직렬화시키나요?

-> Android에서 객체 데이터를 Parcel에 쓰고 읽는 방식으로 직렬화를 수행합니다.

5. Serializable이 Pacelable에 비해 성능이 떨어진다는 말이 나오는 이유가 뭘까요?

-> Serializable은 리플렉션을 통해 객체의 메타데이터를 동적으로 검색하고 직렬화/역직렬화 하는 반면, Pacelable은 리플렉션을 사용하지 않고 필요한 필드만 개발자가 명시적으로 Parcel에 어떤 데이터를 저장할지, 그리고 어떻게 복원할지를 정의합니다.

6. 리플렉션이 뭔가요?

-> 런타임에 클래스, 메서드, 필드 등의 정보를 동적으로 탐색하고 수정할 수 있는 기능입니다.

추가로 Serializable과 Parcelable에 대해 이해하기 쉽게 정리된 영상 자료 및 글을 첨부합니다

• https://youtu.be/-_scGU1nkPg?si=zmwvdjr1snXnbzxE
• https://medium.com/jaesung-dev/android-%EC%A7%81%EB%A0%AC%ED%99%94%EC%99%80-%EC%97%AD%EC%A7%81%EB%A0%AC%ED%99%94-18fd04f1c0ed
  
  

끝으로..!

본 글에서 다른 의견이 있거나 추가적으로 공유하고 싶은 내용이 있다면 댓글로 남겨주시면 저에게 엄청난 도움이 됩니다

문제대로 풀었는데 계속 답이 안 나와서 질문하기 페이지에 봤더니 문제가 잘못 나와있었다. idx보다 크면서 x -> idx보다 같거나 크면서 o 문제 풀 때 참고하시길...!

📝 나의 문제풀이

class Solution {
    fun solution(arr: IntArray, idx: Int): Int {
          for (i in idx until arr.size) {
            if (arr[i] == 1) {
                return i
            }
        }
        return -1
    }

}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(arr: IntArray, idx: Int): Int = (idx until arr.size).firstOrNull { arr[it] == 1 } ?: -1
}

🖊 문제 풀이 시 알면 좋을 것

• firstOrNull { arr[it] == 1 }
  • firstOrNull은 컬렉션에서 첫 번째로 조건을 만족하는 요소를 찾는 함수입니다.
  • arr[it] == 1은 arr 배열의 it번째 인덱스에 해당하는 값이 1인지 확인하는 조건입니다.
  • it은 firstOrNull 내에서 자동으로 제공되는 현재 순회 중인 인덱스를 나타냅니다.
  • 만약 arr[it] == 1인 요소가 있으면 그 첫 번째 인덱스를 반환합니다. 만약 조건을 만족하는 요소가 없다면 null을 반환합니다.

📝 나의 문제풀이

class Solution {
    fun solution(start_num: Int, end_num: Int): IntArray {
            return (end_num..start_num step 1).toList().reversed().toIntArray()
    }
}

📝 다른 사람의 문제 풀이

첫번째 풀이는 좋아요가 많은 풀이고 두번째는 개인적으로 흥미롭게 느껴 가지고 온 문제 풀이다.

class Solution {
    fun solution(start: Int, end: Int) = (end..start).toList().sortedDescending()
}

class Solution {
    fun solution(start: Int, end: Int): IntArray = (start downTo end).toList().toIntArray()
}

🖊 문제 풀이 시 알면 좋을 것

• (start downTo end)
  • downTo의 특징
    • 내림차순 범위: downTo는 주어진 start 값에서 end 값까지 내림차순으로 값을 반환하는 IntProgression을 만듭니다.
    • step(간격)을 설정하지 않으면 기본값으로 1씩 감소하는 범위가 생성됩니다.

      val result = (10 downTo 3).toList()
      println(result)  // 출력: [10, 9, 8, 7, 6, 5, 4, 3]
      
      

 val range = 10 downTo 1 step 2
 println(range.toList())  // 출력: [10, 8, 6, 4, 2]

위 예시는 step을 2로 설정하여 10부터 1까지 내림차순으로 2씩 감소하는 범위를 생성합니다.

📝 나의 문제풀이

class Solution {
    fun solution(my_string: String, indices: IntArray): String {
            return my_string.filterIndexed{ i, _ -> i !in indices}
}
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(my_string: String, indices: IntArray): String {
        return my_string.filterIndexed { index, w -> index !in indices }
    }
}

🖊 문제 풀이 시 알면 좋을 것

• filterIndexed
  • filterIndexed는 문자열이나 리스트 등 인덱스와 값을 동시에 가져오면서 조건에 맞는 요소만 남기는 함수입니다.
  • 각 요소를 순회하며 인덱스(index)와 값(value)을 받아옵니다.
  • 특정 조건에 맞는 요소만 남겨 새롭게 반환합니다.
• in
  • 정의: in은 어떤 값이 특정 컬렉션(리스트, 배열, Set 등)에 포함되어 있는지 검사하는 연산자입니다.
  • 동작 방식: x in collection은 내부적으로 collection.contains(x)를 호출합니다. 결과는 Boolean 값(true 또는 false)으로 반환됩니다.

    val indices = intArrayOf(0, 2, 4)
    

// 2가 indices에 있는지 확인 println(2 in indices) // true

// 3이 indices에 있는지 확인 println(3 in indices) // false

📝 나의 문제풀이

class Solution {
    fun solution(n: Int, k: Int): IntArray {
        return (1..n).filter{ it % k == 0 }.sorted().toIntArray()
    }
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(n: Int, k: Int) = (k..n step k).toList()
}

🖊 문제 풀이 시 알면 좋을 것

• (1..n)

  • 1에서 n까지의 값을 포함하는 정수 범위(IntRange)를 생성합니다.
  • 시작 값(1)부터 끝 값(n)까지 포함됩니다.
  • 반환 타입: IntRange.
  • 고차 함수 사용 가능: .filter, .map, .forEach 등.

    val range = 1..5
    println(range.toList())  // 출력: [1, 2, 3, 4, 5]

• sorted()

  • 컬렉션의 요소를 오름차순으로 정렬한 새로운 리스트를 반환합니다.
  • 특징:
    • 원본 데이터를 변경하지 않고, 정렬된 새로운 컬렉션을 반환합니다.
    • 기본적으로 숫자는 오름차순, 문자열은 사전순 정렬됩니다.
    • 컬렉션(리스트, 배열 등)에서 사용 가능.

      val list = listOf(3, 1, 4, 2)
      println(list.sorted())  // 출력: [1, 2, 3, 4]
      
      

• (k..n step k)
  • k부터 n까지의 범위를 생성하되, 간격이 k인 정수 범위를 만듭니다.
  • 특징:
    • 시작 값(k), 끝 값(n), 간격(step)을 지정할 수 있습니다.
    • 반환 타입: IntProgression.
    • 기본 범위(1..n)와 달리 step 간격으로 값을 포함.

      val range = 2..10 step 2
      println(range.toList())  // 출력: [2, 4, 6, 8, 10]
      

📝 나의 문제풀이

class Solution {
    fun solution(my_string: String): IntArray {
        val alphabetList = ('A'..'Z').toList() + ('a'..'z').toList()
        val charFrequency = my_string.groupingBy { it }.eachCount()

        return alphabetList.map { charFrequency[it] ?: 0 }.toIntArray()
    }
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(my_string: String): IntArray {
        return (('A'..'Z').map { alpha -> my_string.count { it == alpha } } +
        ('a'..'z').map { alpha -> my_string.count { it == alpha } }).toIntArray()
    }
}

주어진 코드에서 count의 역할은 문자열(my_string)에서 특정 문자의 개수를 세는 것입니다.

역할 설명 my_string.count { it == alpha } my_string의 각 문자(it)가 alpha와 같은지 확인합니다. 조건(it == alpha)을 만족하는 문자의 개수를 세어 반환합니다.

동작 방식 ('A'..'Z')와 ('a'..'z') 범위의 각각의 문자(alpha)에 대해 count를 호출합니다. 예를 들어, alpha가 'A'라면 my_string에서 'A'가 몇 번 등장하는지 세어 반환합니다.

간략한 요약 count는 문자열에서 특정 조건(예: 특정 문자와 일치)을 만족하는 요소의 개수를 세는 데 사용됩니다. 이 코드에서는 대문자와 소문자의 각각의 등장 횟수를 계산하는 역할을 합니다.

🖊 문제 풀이 시 알면 좋을 것

• groupingBy

  • 컬렉션을 특정 기준으로 그룹화할 때 사용합니다.
  • 결과는 Grouping 객체로 반환되며, 이를 통해 추가적인 연산(예: 개수 세기)을 수행할 수 있습니다.

    val words = listOf("apple", "banana", "cherry", "apple")
    val grouped = words.groupingBy { it.first() } // 첫 글자로 그룹화

• eachCount

  • groupingBy로 생성된 Grouping 객체에 사용하여, 각 그룹에 포함된 요소의 개수를 계산합니다.

    val words = listOf("apple", "banana", "cherry", "apple")
    val counts = words.groupingBy { it.first() }.eachCount()
    println(counts) // {a=2, b=1, c=1}

• count는

  • count는 컬렉션이나 문자열에서 특정 조건을 만족하는 요소의 개수를 반환하는 함수입니다.
    • 조건이 없으면 전체 개수를 반환합니다.
    • 조건이 있으면 해당 조건을 만족하는 요소의 개수를 반환합니다.

      val text = "hello"
      val totalCount = text.count()              // 전체 문자 개수: 5
      val lCount = text.count { it == 'l' }      // 'l'의 개수: 2

xml에서는 ConstraintLayout을 사용할 경우 중첩을 줄이고, 복잡한 UI를 효율적으로 배치할 수 있으며, 다양한 화면 크기와 해상도에 적응하는 동적인 레이아웃을 구현할 수 있기 때문에 xml에서 constraintLayout이 권장되었다.

하지만 compose는 이미 compose의 기본 레이아웃(Column, Row, Box)이 강력하며, 중첩된 구조를 통해 다양한 배치를 쉽게 구현할 수 있기 때문에 필수 사항은 아니다.

compose에서 ConstraintLayout은 더 복잡한 정렬 요구사항이 있거나 더 큰 레이아웃을 구현할 때 유용하다.

사용법

1. build.grale에 추가하기

   implementation "androidx.constraintlayout:constraintlayout-compose:1.0.1"

2. createRefs() 설정하기

   val (redBox, magentaBox, greenBox, yellowBox) = createRefs()

   다음과같이 createRefs()는 컴포넌트를 16개까지 지원한다 16개 넘게 사용할 경우에는 createRefs()를 추가 생성하면 된다.

3. constrainAs, linkTo 설정하기

        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Magenta)
            .constrainAs(magentaBox) {
                start.linkTo(parent.start)
                end.linkTo(parent.end)
            })

   constrainAs 괄호 안에는 해당 박스에 이름을 넣어주었고 start.linkTo(parent.start) 라는 뜻은 내 start 라인을 parent의 start라인에 붙이겠단 뜻이다

4. centrtTo(), centerHorizontallyTo(), centerVerticallyTo() 괄호 안에 레퍼런스를 넣어주면 그 레퍼런스를 기준으로 중앙 배치가 된다. 어떻게 중앙 배치가 되는지는 뜻을 그대로 해석해서 사용하면 된다.

그렇게 테스트해본 constraintLayout 샘플 코드를 올려놓겠다..

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MyApplicationTheme {
                // A surface container using the 'background' color from the theme
                Surface(modifier = Modifier.fillMaxSize(),
                    color = MaterialTheme.colorScheme.background) {
                    ConstraintLayoutEx()
                }
            }
        }
    }
}

@Composable
fun ConstraintLayoutEx() {
    ConstraintLayout(modifier = Modifier.fillMaxSize()) {
        val (redBox, magentaBox, greenBox, yellowBox) = createRefs()


        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Red)
            .constrainAs(redBox) {
                bottom.linkTo(parent.bottom, margin = 8.dp)
                end.linkTo(parent.end, margin = 8.dp)
            })
        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Magenta)
            .constrainAs(magentaBox) {
                start.linkTo(parent.start)
                end.linkTo(parent.end)
            })
        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Green)
            .constrainAs(greenBox) {
                centerTo(parent)
            })
        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Yellow)
            .constrainAs(yellowBox) {
                start.linkTo(magentaBox.end)
                top.linkTo(magentaBox.bottom)
            })
    }
}


@Preview(showBackground = true)
@Composable
fun DefaultPreview() {
    MyApplicationTheme {
        ConstraintLayoutEx()
    }
}

ConstraintSet도 알아보자

ConstraintSet을 이용해 constraintLayout을 밖으로 빼내보자 위 코드에서는 modifier 안에 모든 제약들이 있었다. 그 제약들을 별도로 설정하는 방법을 지금부터 알아보자.

1. ConstraintSet 안에 레퍼런스를 만들어주자.

    val constraintSet = ConstraintSet{
        val redBox = createRefFor("redBox")
        val magentaBox = createRefFor("magentaBox")
        val greenBox = createRefFor("greenBox")
        val yellowBox = createRefFor("yellowBox")
    }

2. constrian으로 제약을 옮겨주자

    val constraintSet = ConstraintSet {
        val redBox = createRefFor("redBox")
        val magentaBox = createRefFor("magentaBox")
        val greenBox = createRefFor("greenBox")
        val yellowBox = createRefFor("yellowBox")
   
        constrain(redBox) {
            bottom.linkTo(parent.bottom, margin = 8.dp)
            end.linkTo(parent.end, margin = 8.dp)
        }
        constrain(magentaBox) {
            start.linkTo(parent.start)
            end.linkTo(parent.end)
        }
        constrain(greenBox) {
            centerTo(parent)
        }
        constrain(yellowBox) {
            start.linkTo(magentaBox.end)
            top.linkTo(magentaBox.bottom)
        }
    }

   3. layoutId 설정하기

      ConstraintLayout(modifier = Modifier.fillMaxSize()) {
      
        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Red)
            .layoutId("redBox")
        )
        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Magenta)
            .layoutId("magentaBox")
        )
        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Green)
            .layoutId("greenBox")
        )
      
        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Yellow)
            .layoutId("yellowBox")
        )
      }

   4. ConstraintLayout과 ConstarintSet을 연결 시키자

      ConstraintLayout(
        constraintSet,
        modifier = Modifier.fillMaxSize()) {
      
        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Red)
            .layoutId("redBox")
        )
        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Magenta)
            .layoutId("magentaBox")
        )
        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Green)
            .layoutId("greenBox")
        )
      
        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Yellow)
            .layoutId("yellowBox")
        )
      }
      

전체 코드를 보고 ConstraintSet을 쓰기 전과 쓴 후 어떻게 다른지 비교해 봅시다!

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MyApplicationTheme {
                // A surface container using the 'background' color from the theme
                Surface(modifier = Modifier.fillMaxSize(),
                    color = MaterialTheme.colorScheme.background) {
                    ConstraintLayoutEx()
                }
            }
        }
    }
}

@Composable
fun ConstraintLayoutEx() {
    val constraintSet = ConstraintSet {
        val redBox = createRefFor("redBox")
        val magentaBox = createRefFor("magentaBox")
        val greenBox = createRefFor("greenBox")
        val yellowBox = createRefFor("yellowBox")

        constrain(redBox) {
            bottom.linkTo(parent.bottom, margin = 8.dp)
            end.linkTo(parent.end, margin = 8.dp)
        }
        constrain(magentaBox) {
            start.linkTo(parent.start)
            end.linkTo(parent.end)
        }
        constrain(greenBox) {
            centerTo(parent)
        }
        constrain(yellowBox) {
            start.linkTo(magentaBox.end)
            top.linkTo(magentaBox.bottom)
        }
    }
    ConstraintLayout(
        constraintSet,
        modifier = Modifier.fillMaxSize()) {

        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Red)
            .layoutId("redBox")
        )
        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Magenta)
            .layoutId("magentaBox")
        )
        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Green)
            .layoutId("greenBox")
        )

        Box(modifier = Modifier
            .size(40.dp)
            .background(Color.Yellow)
            .layoutId("yellowBox")
        )
    }
}


@Preview(showBackground = true)
@Composable
fun DefaultPreview() {
    MyApplicationTheme {
        ConstraintLayoutEx()
    }
}

끝으로 이런 의문이 들 수도 있다. 아니, ConstraintLayout으로 구현 가능한데 왜 굳이 ConstraintSet을 사용하지?

이러한 이유 때문에 ConstraintSet을 사용한다

1. 레이아웃 변경을 동적으로 처리

• ConstraintSet은 앱 실행 중에 레이아웃의 제약 조건을 동적으로 업데이트할 수 있도록 해줍니다.
  • 예시: 버튼 클릭 시 뷰의 위치를 변경하거나, 특정 이벤트에 따라 레이아웃을 조정해야 할 때.

2. 제약 조건의 재사용 가능

• 반복적으로 사용되는 제약 조건을 하나의 ConstraintSet으로 정의하고 재사용할 수 있습니다.
  • 예시: 다수의 화면에서 동일한 제약 조건을 적용해야 할 경우, 코드 중복을 줄이고 유지보수성을 높일 수 있습니다.

3. 애니메이션과 전환 구현

• ConstraintSet은 애니메이션과 전환을 구현할 때도 유용합니다.
  • 예시: 두 개의 ConstraintSet을 정의하고, 이를 TransitionManager와 함께 사용하면 자연스러운 애니메이션 효과를 줄 수 있습니다.

4. ConstraintLayout 대비 코드 간결화

• ConstraintLayout에 직접 제약 조건을 정의하면 코드가 길고 가독성이 떨어질 수 있습니다.
• ConstraintSet은 제약 조건을 구조적으로 정의하므로, 코드가 더 읽기 쉽고 유지보수가 간편합니다.

결론

ConstraintSet은 다음과 같은 경우 유용하다.

• 실행 중 레이아웃 변경이 필요한 경우
• 제약 조건을 재사용하려는 경우
• 애니메이션이나 전환 효과를 구현할 때.

단순한 제약 조건이라면 ConstraintLayout만으로도 충분하지만, 복잡한 레이아웃 변경이나 재사용성이 중요한 경우 ConstraintSet이 더 효율적입니다.

질문은 언제나 환영입니다!! 👍💚

q로 나눈 나머지가 1인 인덱스의 문자들을 앞에서부터 순서대로 이어 붙이면 "jerry"가 되므로 이를 return 합니다. q로 나눈 나머지가 1인 인덱스의 문자들을 앞에서부터 순서대로 이어 붙이면 "programmers"가 되므로 이를 return 합니다.

📝 나의 문제풀이

class Solution {
    fun solution(q: Int, r: Int, code: String): String {
      return  code.chunked(q)
            .filter{ it.length > r }
            .map{ it[r] }
            .joinToString("")
    }
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(q: Int, r: Int, code: String): String {
        return code.indices.filter { it % q == r }.joinToString("") { code[it].toString() }
    }
}

🖊 문제 풀이 시 알면 좋을 것

• indices

  • indices는 컬렉션(예: String, List)의 유효한 인덱스를 범위로 반환하는 프로퍼티입니다.
  • 예를 들어, 문자열이나 리스트의 모든 인덱스를 순회하거나 특정 범위를 설정할 때 유용합니다.

    val text = "abc"
    println(text.indices)  // 출력값: 0..2

• filter

  • filter는 컬렉션에서 주어진 조건을 만족하는 원소만 새로운 컬렉션으로 반환하는 함수입니다.
  • 이 함수는 원본 컬렉션을 변경하지 않으며, 조건에 맞는 원소들만 추출하여 새로운 리스트를 생성합니다.

    val numbers = listOf(1, 2, 3, 4, 5)
    val evenNumbers = numbers.filter { it % 2 == 0 }
    println(evenNumbers)  // [2, 4]

• joinToString("")

  • joinToString("")는 컬렉션의 모든 원소를 지정한 구분자(이 경우 ""`, 즉 공백 없이)로 결합하여 하나의 문자열로 반환하는 함수입니다.
  • 구분자를 지정할 수 있으며, 기본적으로 각 원소를 문자열로 변환한 후 결합합니다.

    val words = listOf("hello", "world")
    val result = words.joinToString(" ")
    println(result)  // "hello world"

📝 나의 문제풀이

class Solution {
    fun solution(my_string: String, m: Int, c: Int): String {

     return  my_string.chunked(m)
            .map{ it[c-1] }
            .joinToString("")
    }
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(my_string: String, m: Int, c: Int): String {
        return my_string.chunked(m).map { it[c - 1] }.joinToString("")
    }
}

🖊 문제 풀이 시 알면 좋을 것

• chunked(size: Int)

  • 문자열을 지정한 크기(size)로 나누어 리스트를 생성합니다.
  • 마지막 덩어리는 남은 글자만 포함합니다(길이가 부족해도 OK).

    val text = "ihrhbakrfpndopljhygc"
    

  // 4글자씩 끊어서 리스트 생성 val result = text.chunked(4) println(result) // [ihrh, bakr, fpnd, oplj, hygc]

• map

  • map은 단순히 반복하는 역할이 아니라, 컬렉션의 각 원소를 특정 방식으로 변환하여 새로운 컬렉션을 생성하는 변환 메소드입니다.
  • 변환 수행: 각 원소를 특정 방식으로 변환하여 새로운 컬렉션을 반환합니다.
  • 원본 컬렉션은 변경되지 않음: map은 불변성을 유지하며, 원본 데이터는 그대로 두고 새로운 데이터를 생성합니다.
  • 컬렉션의 모든 원소에 적용: 모든 원소에 대해 변환을 적용하고, 결과를 수집합니다.

    val numbers = listOf(1, 2, 3, 4, 5)
    

  // 각 원소를 2배로 변환 val doubled = numbers.map { it * 2 } println(doubled) // [2, 4, 6, 8, 10]

map과 반복 비교:

단순 반복 (for 또는 forEach)은 작업을 수행하고 끝나지만, map은 변환 결과를 새로운 컬렉션으로 반환합니다.

val numbers = listOf(1, 2, 3)

// 단순 반복
numbers.forEach { println(it * 2) } // 출력: 2, 4, 6

// 변환하여 새로운 리스트 생성
val doubled = numbers.map { it * 2 }
println(doubled) // [2, 4, 6]

📝 나의 문제풀이

class Solution {
    fun solution(my_string: String, s: Int, e: Int) = my_string.replaceRange(s..e, my_string.slice(s..e).reversed())
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(myString: String, s: Int, e: Int) = myString.substring(0, s) + myString.substring(s..e).reversed() + myString.substring(e + 1, myString.length)
}

🖊 문제 풀이 시 알면 좋을 것

• replaceRange()
  • 문자열의 특정 범위(Range)를 지정하여 해당 부분을 교체합니다.
  • 범위 표현으로 대체할 범위를 지정합니다.
  • 반환값: 새로운 문자열 (원본 문자열은 변경되지 않음).

    val text = "HelloWorld"
    

// 범위 0..4의 문자열("Hello")을 "Hi"로 교체 val result = text.replaceRange(0..4, "Hi") println(result) // "HiWorld"

// 범위 5..9의 문자열("World")을 "Everyone"으로 교체 val result2 = text.replaceRange(5..9, "Everyone") println(result2) // "HelloEveryone"

- replaceRange(startIndex, endIndex, replacement) 형식으로도 사용할 수 있습니다. 이 경우 endIndex는 포함되지 않음에 유의하세요
```kotlin
val result = text.replaceRange(0, 5, "Hi") // "HiWorld"

📝 나의 문제풀이

class Solution {
    fun solution(my_string: String, is_prefix: String) = 
    if(my_string.startsWith(is_prefix)) 1 else 0
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(my_string: String, is_prefix: String): Int = if (my_string.startsWith(is_prefix)) 1 else 0
}

🖊 문제 풀이 시 알면 좋을 것

• startsWith()

  • 접두사인지 확인하려면 startsWith() 메소드를 사용합니다.
  • 설명: 문자열이 특정 접두사로 시작하는지 확인합니다.
  • 반환값: Boolean (true 또는 false)

    val text = "HelloWorld"
    

  // "Hello"로 시작하는지 확인 println(text.startsWith("Hello")) // true

  // "World"로 시작하는지 확인 println(text.startsWith("World")) // false

📌 마치며

이전에 풀었던 문제 중에 접미사인지 확인하는 문제랑 흡사하여 endsWith()메소가 떠올라 그 반대인 startsWith()메소드를 사용해 풀었다.

📝 나의 문제풀이

class Solution {
    fun solution(my_string: String, n: Int) = my_string.substring(0, n)
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(my_string: String, n: Int): String = my_string.slice(0 until n)
}

🖊 문제 풀이 시 알면 좋을 것

• substring(0, n)

  • 문자열에서 특정 시작 인덱스(start)부터 종료 인덱스(end) 전까지 부분 문자열을 반환합니다.
  • 종료 인덱스 n은 포함되지 않습니다.

    val text = "Hello"
    println(text.substring(0, 3)) // "Hel"

• slice(0 until n)

  • 범위(Range)를 기반으로 문자열의 부분 문자열을 반환합니다.
  • 종료 값 n은 포함되지 않습니다. -> until일 경우에만 해당
  • until은 범위를 나타내는 키워드로, 끝 값이 포함되지 않는 범위를 생성합니다.

    val text = "abcd"
    println(text.slice(0..2)) // "abc"
    

  val text = "abcd" println(text.slice(0 until 2)) // "ab"

substring()과 slice()의 주요 차이점

표현 방식 substring()은 직접 인덱스를 지정하며, slice()는 범위를 지정합니다.

범위 표현 가능성 slice()는 범위 표현(0..2, 0 until 3)을 활용할 수 있어 가독성이 더 좋습니다.

선택 기준 간단한 인덱스 값만 사용할 경우: substring 범위 표현을 활용하거나 가독성을 선호할 경우: slice

📝 나의 문제풀이

class Solution {
    fun solution(rny_string: String) = rny_string.replace("m", "rn") 
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(rnyString: String) = rnyString.replace("m", "rn")
}

📝 나의 문제풀이

class Solution {
    fun solution(flo: Double): Int {
        return flo.toInt()
    }
}

📝 다른 사람의 문제 풀이

class Solution {
    fun solution(flo: Double): Int {
        return flo.toInt()
    }
}