신종 바이러스인 웜 바이러스는 네트워크를 통해 전파된다. 한 컴퓨터가 웜 바이러스에 걸리면 그 컴퓨터와 네트워크 상에서 연결되어 있는 모든 컴퓨터는 웜 바이러스에 걸리게 된다. 예를 들어 7대의 컴퓨터가 <그림 1>과 같이 네트워크 상에서 연결되어 있다고 하자. 1번 컴퓨터가 웜 바이러스에 걸리면 웜 바이러스는 2번과 5번 컴퓨터를 거쳐 3번과 6번 컴퓨터까지 전파되어 2, 3, 5, 6 네 대의 컴퓨터는 웜 바이러스에 걸리게 된다. 하지만 4번과 7번 컴퓨터는 1번 컴퓨터와 네트워크상에서 연결되어 있지 않기 때문에 영향을 받지 않는다. 어느 날 1번 컴퓨터가 웜 바이러스에 걸렸다. 컴퓨터의 수와 네트워크 상에서 서로 연결되어 있는 정보가 주어질 때, 1번 컴퓨터를 통해 웜 바이러스에 걸리게 되는 컴퓨터의 수를 출력하는 프로그램을 작성하시오.

입력 첫째 줄에는 컴퓨터의 수가 주어진다. 컴퓨터의 수는 100 이하이고 각 컴퓨터에는 1번 부터 차례대로 번호가 매겨진다. 둘째 줄에는 네트워크 상에서 직접 연결되어 있는 컴퓨터 쌍의 수가 주어진다. 이어서 그 수만큼 한 줄에 한 쌍씩 네트워크 상에서 직접 연결되어 있는 컴퓨터의 번호 쌍이 주어진다.

출력 1번 컴퓨터가 웜 바이러스에 걸렸을 때, 1번 컴퓨터를 통해 웜 바이러스에 걸리게 되는 컴퓨터의 수를 첫째 줄에 출력한다.

풀이

import java.util.*;

class Main{

    static boolean[][] graph;
    static boolean[] visited;
    static int N, M;
    static int answer;

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        M = sc.nextInt();

        graph = new boolean[N + 1][N + 1];
        visited = new boolean[N + 1];

        int x, y;
        for(int i = 0; i < M; i++){
            x = sc.nextInt();
            y = sc.nextInt();
            graph[x][y] = graph[y][x] = true;
        }

        dfs(1);
        System.out.println(answer - 1);
        sc.close();
    }

    public static void dfs(int index){
        answer++;
        visited[index] = true;
        for(int i = 1; i <= N; i++){
            if(!visited[i] && graph[index][i]){
                dfs(i);
            }
        }
    }
}

그래프를 DFS로 탐색한 결과와 BFS로 탐색한 결과를 출력하는 프로그램을 작성하시오. 단, 방문할 수 있는 정점이 여러 개인 경우에는 정점 번호가 작은 것을 먼저 방문하고, 더 이상 방문할 수 있는 점이 없는 경우 종료한다. 정점 번호는 1번부터 N번까지이다.

입력 첫째 줄에 정점의 개수 N(1 ≤ N ≤ 1,000), 간선의 개수 M(1 ≤ M ≤ 10,000), 탐색을 시작할 정점의 번호 V가 주어진다. 다음 M개의 줄에는 간선이 연결하는 두 정점의 번호가 주어진다. 어떤 두 정점 사이에 여러 개의 간선이 있을 수 있다. 입력으로 주어지는 간선은 양방향이다.

출력 첫째 줄에 DFS를 수행한 결과를, 그 다음 줄에는 BFS를 수행한 결과를 출력한다. V부터 방문된 점을 순서대로 출력하면 된다.

💡풀이

import java.util.*;

public class Main {

    static int[][] arr;
    static boolean[] visited;

    public static void main(String[] args){

        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();  
        int M = sc.nextInt();  
        int V = sc.nextInt();    

        arr = new int[N+1][N+1];

        for(int i = 0; i < M; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            arr[a][b] = 1;
            arr[b][a] = 1;
        }

        visited = new boolean[N + 1];
        dfs(V);

        System.out.println();

        visited = new boolean[N + 1];

        bfs(V);

        System.out.println();
    }

    private static void dfs(int v) {
        visited[v] = true;
        System.out.print(v + " ");

        if(v == arr.length){
            return;
        }

        for(int j = 1; j < arr.length; j++) { 
            if(arr[v][j] == 1 && !visited[j]) {
                dfs(j);
            }
        }
    }

    private static void bfs(int v) {
        Queue<Integer> queue = new LinkedList<Integer>();
        queue.offer(v);
        visited[v] = true;

        System.out.print(v + " ");

        while(!queue.isEmpty()) {
            int n = queue.poll();

            for(int i = 1; i < arr.length; i++) { 
                if(arr[n][i] == 1 && !visited[i]) {
                    visited[i] = true;
                    System.out.print(i + " ");
                    queue.offer(i);
                }
            }
        }   
    }

}

N×M크기의 배열로 표현되는 미로가 있다.

미로에서 1은 이동할 수 있는 칸을 나타내고, 0은 이동할 수 없는 칸을 나타낸다. 이러한 미로가 주어졌을 때, (1, 1)에서 출발하여 (N, M)의 위치로 이동할 때 지나야 하는 최소의 칸 수를 구하는 프로그램을 작성하시오. 한 칸에서 다른 칸으로 이동할 때, 서로 인접한 칸으로만 이동할 수 있다. 위의 예에서는 15칸을 지나야 (N, M)의 위치로 이동할 수 있다. 칸을 셀 때에는 시작 위치와 도착 위치도 포함한다.

입력 첫째 줄에 두 정수 N, M(2 ≤ N, M ≤ 100)이 주어진다. 다음 N개의 줄에는 M개의 정수로 미로가 주어진다. 각각의 수들은 붙어서 입력으로 주어진다.

출력 첫째 줄에 지나야 하는 최소의 칸 수를 출력한다. 항상 도착위치로 이동할 수 있는 경우만 입력으로 주어진다.

💡풀이

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

public class Main{

    static int[] dx = {1, 0, -1, 0};
    static int[] dy = {0, 1, 0, -1};
    static boolean[][] visited;
    static int[][] A;
    static int N, M;

    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        A = new int[N][M];
        visited = new boolean[N][M];

        for(int i = 0; i < N; i++){
            st = new StringTokenizer(br.readLine());
            String line = st.nextToken();
            for(int j = 0; j < M; j++){
                A[i][j] = Integer.parseInt(line.substring(j, j+1));
            }
        }

        bfs(0,0); 
        System.out.print(A[N - 1][M - 1]);
    }

    private static void bfs(int i, int j){
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{i, j});
        visited[i][j] = true;

        while(!queue.isEmpty()){
            int now[] = queue.poll();
            for(int k = 0; k < 4; k++){
                int x = now[0] + dx[k];
                int y = now[1] + dy[k];

                if(x >= 0 && y >= 0 && x < N && y < M){
                    if(A[x][y] != 0 && !visited[x][y]){
                        visited[x][y] = true;
                        A[x][y] = A[now[0]][now[1]] + 1;
                        queue.add(new int[]{x, y});
                    }
                }
            }
        }
    }


}

2. 프로젝트에 Android KTX 사용 Android KTX 사용을 시작하려면 프로젝트의 build.gradle 파일에 다음 종속 항목을 추가합니다.

repositories {
    google()
}

3. Android KTX 모듈별 사용 예

• CoreKTX Core KTX 모듈은 Android 프레임워크의 일부인 일반 라이브러리에 확장 프로그램을 제공합니다. 이러한 라이브러리에는 build.gradle에 추가해야 하는 자바 기반 종속 항목이 없습니다. 이 모듈을 포함하려면 앱의 build.gradle 파일에 다음을 추가합니다.

  dependencies {
    implementation("androidx.core:core-ktx:1.9.0")
  }

• Collection KTX Collection 확장 프로그램에는 ArrayMap, LongSparseArray, LruCache 등 메모리 효율성이 높은 Android의 컬렉션 라이브러리와 호환되는 유틸리티 함수가 포함되어 있습니다. 이 모듈을 사용하려면 앱의 build.gradle 파일에 다음을 추가합니다.

  dependencies {
    implementation("androidx.collection:collection-ktx:1.2.0")
  }

Collection 확장 프로그램은 다음 예와 같이 Kotlin의 연산자 오버로드를 활용하여 컬렉션 연결과 같은 작업을 단순화합니다.

// Combine 2 ArraySets into 1.
val combinedArraySet = arraySetOf(1, 2, 3) + arraySetOf(4, 5, 6)

// Combine with numbers to create a new sets.
val newArraySet = combinedArraySet + 7 + 8

• Fragment KTX Fragment KTX 모듈은 여러 확장 프로그램을 제공하여 프래그먼트 API를 단순화합니다. 이 모듈을 포함하려면 앱의 build.gradle 파일에 다음을 추가합니다.

dependencies {
    implementation("androidx.fragment:fragment-ktx:1.5.5")
}

Fragment KTX 모듈을 사용하면 다음과 같이 람다로 프래그먼트 트랜잭션을 단순화할 수 있습니다.

fragmentManager().commit {
   addToBackStack("...")
   setCustomAnimations(
           R.anim.enter_anim,
           R.anim.exit_anim)
   add(fragment, "...")
}

또한 다음과 같이 viewModels 및 activityViewModels 속성 위임을 사용하여 한 줄로 ViewModel에 결합할 수도 있습니다.

// Get a reference to the ViewModel scoped to this Fragment
val viewModel by viewModels<MyViewModel>()

// Get a reference to the ViewModel scoped to its Activity
val viewModel by activityViewModels<MyViewModel>()

• Lifecycle KTX Lifecycle KTX는 각 Lifecycle 객체의 LifecycleScope를 정의합니다. 이 범위에서 실행된 코루틴은 Lifecycle이 끝나면 제거됩니다. lifecycle.coroutineScope 또는 lifecycleOwner.lifecycleScope 속성을 사용하여 Lifecycle의 CoroutineScope에 액세스할 수 있습니다. 이 모듈을 포함하려면 앱의 build.gradle 파일에 다음을 추가합니다.

  dependencies {
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.5.1")
  }

아래 예는 lifecycleOwner.lifecycleScope를 사용하여 미리 계산된 텍스트를 비동기적으로 만드는 방법을 보여줍니다.

class MyFragment: Fragment() {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        viewLifecycleOwner.lifecycleScope.launch {
            val params = TextViewCompat.getTextMetricsParams(textView)
            val precomputedText = withContext(Dispatchers.Default) {
                PrecomputedTextCompat.create(longTextContent, params)
            }
            TextViewCompat.setPrecomputedText(textView, precomputedText)
        }
    }
}

• LiveData KTX LiveData를 사용할 때 값을 비동기적으로 계산해야 할 수 있습니다. 예를 들어 사용자의 환경설정을 검색하여 UI에 제공하려고 할 수 있습니다. 이런 상황에서 LiveData KTX는 liveData 빌더 함수를 제공함으로써 suspend 함수를 호출하여 그 결과를 LiveData 객체로 제공할 수 있습니다. 이 모듈을 포함하려면 앱의 build.gradle 파일에 다음을 추가합니다.

dependencies {
    implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.5.1")
}

다음 예에서 loadUser()는 다른 곳에서 선언된 정지 함수입니다. liveData 빌더 함수를 사용하여 loadUser()를 비동기적으로 호출한 후 emit()를 사용하여 결과를 내보낼 수 있습니다.

val user: LiveData<User> = liveData {
    val data = database.loadUser() // loadUser is a suspend function.
    emit(data)
}

• Navigation KTX Navigation 라이브러리의 각 구성요소에는 API를 조정하여 더 간결하고 Kotlin 직관적이 되도록 하는 자체 KTX 버전이 있습니다. 이러한 모듈을 포함하려면 앱의 build.gradle 파일에 다음을 추가합니다.

dependencies {
    implementation("androidx.navigation:navigation-runtime-ktx:2.5.3")
    implementation("androidx.navigation:navigation-fragment-ktx:2.5.3")
    implementation("androidx.navigation:navigation-ui-ktx:2.5.3")
}

다음 예와 같이 확장 함수 및 속성 위임을 사용하여 대상 인수에 액세스하고 대상을 탐색합니다.

class MyDestination : Fragment() {

    // Type-safe arguments are accessed from the bundle.
    val args by navArgs<MyDestinationArgs>()

    ...
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        view.findViewById<Button>(R.id.next)
            .setOnClickListener {
                // Fragment extension added to retrieve a NavController from
                // any destination.
                findNavController().navigate(R.id.action_to_next_destination)
            }
     }
     ...

}

• Palette KTX Palette KTX 모듈은 색상 팔레트 작업에 직관적인 Kotlin 지원을 제공합니다. 이 모듈을 사용하려면 앱의 build.gradle 파일에 다음을 추가합니다.

dependencies {
    implementation("androidx.palette:palette-ktx:1.0.0")
}

예를 들어 Palette 인스턴스로 작업할 때 get 연산자([ ])를 사용하여 주어진 target의 selected 견본을 검색할 수 있습니다

val palette = Palette.from(bitmap).generate()
val swatch = palette[target]

• Reactive Streams KTX Reactive Streams KTX 모듈을 사용하면 ReactiveStreams 게시자에서 식별 가능한 LiveData 스트림을 생성할 수 있습니다. 이 모듈을 포함하려면 앱의 build.gradle 파일에 다음을 추가합니다.

dependencies {
    implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:2.5.1")
}

예를 들어 작은 사용자 목록이 있는 데이터베이스를 가정해보겠습니다. 앱에서 데이터베이스를 메모리로 로드한 다음 UI에 사용자 데이터를 표시합니다. 이를 위해 RxJava를 사용할 수 있습니다. Room Jetpack 구성요소는 사용자 목록을 Flowable로 검색할 수 있습니다. 이 시나리오에서는 프래그먼트나 활동의 수명 전체에 걸쳐 Rx 게시자 구독도 관리해야 합니다.

그러나 다음 예와 같이 LiveDataReactiveStreams를 사용하면 RxJava 및 다양한 연산자 세트와 작업 일정 예약 기능의 이점은 물론 LiveData의 단순성이라는 이점도 누릴 수 있습니다.

val fun getUsersLiveData() : LiveData<List<User>> {
    val users: Flowable<List<User>> = dao.findUsers()
    return LiveDataReactiveStreams.fromPublisher(users)
}

• Room KTX Room 확장 프로그램은 데이터베이스 트랜잭션을 위한 코루틴 지원을 추가합니다. 이 모듈을 사용하려면 앱의 build.gradle 파일에 다음을 추가합니다.

dependencies {
    implementation("androidx.room:room-ktx:2.5.0")
}

다음은 Room에서 현재 코루틴을 사용하는 몇 가지 예입니다. 첫 번째 예에서는 suspend 함수를 사용하여 User 객체 목록을 반환하는 반면 두 번째 예에서는 Kotlin의 Flow를 활용하여 User 목록을 비동기적으로 반환합니다. Flow 사용 시 쿼리 중인 테이블의 변경사항 알림을 받습니다.

@Query("SELECT * FROM Users")
suspend fun getUsers(): List<User>

@Query("SELECT * FROM Users")
fun getUsers(): Flow<List<User>>

• SQLite KTX SQLite 확장 프로그램은 트랜잭션에서 SQL 관련 코드를 래핑하여 여러 상용구 코드를 제거합니다. 이 모듈을 사용하려면 앱의 build.gradle 파일에 다음을 추가합니다.

dependencies {
    implementation("androidx.sqlite:sqlite-ktx:2.3.0")
}

다음은 transaction 확장을 사용하여 데이터베이스 트랜잭션을 실행하는 예입니다.

db.transaction {
    // insert data
}

• ViewModel KTX ViewModel KTX 라이브러리는 viewModelScope() 함수를 제공합니다. 이 함수로 ViewModel에서 코루틴을 실행하기가 더 쉬워집니다. CoroutineScope는 Dispatchers.Main에 바인딩되며 ViewModel이 삭제되면 자동으로 취소됩니다. 각 ViewModel에 새로운 범위를 만드는 대신 viewModelScope()를 사용할 수 있습니다. 이 모듈을 포함하려면 앱의 build.gradle 파일에 다음을 추가합니다.

dependencies {
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.5.1")
}

예를 들어 다음 viewModelScope() 함수는 백그라운드 스레드에서 네트워크를 요청하는 코루틴을 실행합니다. 라이브러리는 모든 설정 및 상응하는 범위 삭제를 처리합니다.

class MainViewModel : ViewModel() {
    // Make a network request without blocking the UI thread
    private fun makeNetworkRequest() {
        // launch a coroutine in viewModelScope
        viewModelScope.launch  {
            remoteApi.slowFetch()
            ...
        }
    }

    // No need to override onCleared()
}

• WorkManager KTX WorkManager KTX는 코루틴을 위한 최고 수준의 지원을 제공합니다. 이 모듈을 포함하려면 앱의 build.gradle 파일에 다음을 추가합니다.

dependencies {
    implementation("androidx.work:work-runtime-ktx:2.8.0")
}

Worker를 확장하는 대신 API가 약간 다른 CoroutineWorker를 확장할 수 있습니다. 예를 들어 간단한 CoroutineWorker를 빌드하여 일부 네트워크 작업을 실행하려면 다음과 같이 하면 됩니다.

class CoroutineDownloadWorker(context: Context, params: WorkerParameters)
        : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result = coroutineScope {
        val jobs = (0 until 100).map {
            async {
                downloadSynchronously("https://www.google.com")
            }
        }

        // awaitAll will throw an exception if a download fails, which
        // CoroutineWorker will treat as a failure
        jobs.awaitAll()
        Result.success()
    }
}

또한 WorkManager KTX는 Operations 및 ListenableFutures에 확장 함수를 추가하여 현재 코루틴을 정지합니다.

다음은 enqueue()에 의해 반환된 Operation을 정지하는 예입니다.

// Inside of a coroutine...

// Run async operation and suspend until completed.
WorkManager.getInstance()
        .beginWith(longWorkRequest)
        .enqueue().await()

// Resume after work completes...

4. 기타 KTX 모듈 또한 AndroidX 외부에 있는 추가 KTX 모듈을 포함할 수도 있습니다.

• Firebase KTX 일부 Android용 Firebase SDK에는 앱에서 Firebase를 사용할 때 직관적인 Kotlin 코드를 작성할 수 있게 하는 Kotlin 확장 라이브러리가 있습니다.

• Google Maps Platform KTX Google Maps Platform Android SDK에 사용할 수 있는 KTX 확장 프로그램이 있으며 이를 사용하면 확장 함수, 명명된 매개변수와 기본 인수, 구조 파괴 선언, 코루틴과 같은 여러 Kotlin 언어 기능을 활용할 수 있습니다

• Play Core KTX Play Core KTX는 Play Core 라이브러리의 SplitInstallManager 및 AppUpdateManager에 확장 함수를 추가하여 원샷 요청의 Kotlin 코루틴 지원 및 상태 업데이트 모니터링의 Flow 지원을 추가합니다. 이 모듈을 포함하려면 앱의 build.gradle 파일에 다음을 추가합니다.

dependencies {
    implementation("com.google.android.play:core-ktx:1.8.1")
}

다음은 상태 모니터링 Flow의 예입니다.

// Inside of a coroutine...

// Request in-app update status updates.
manager.requestUpdateFlow().collect { updateResult ->
    when (updateResult) {
        is AppUpdateResult.Available -> TODO()
        is AppUpdateResult.InProgress -> TODO()
        is AppUpdateResult.Downloaded -> TODO()
        AppUpdateResult.NotAvailable -> TODO()
    }
}

고객의 약관 동의를 얻어서 수집된 1~n번으로 분류되는 개인정보 n개가 있습니다. 약관 종류는 여러 가지 있으며 각 약관마다 개인정보 보관 유효기간이 정해져 있습니다. 당신은 각 개인정보가 어떤 약관으로 수집됐는지 알고 있습니다. 수집된 개인정보는 유효기간 전까지만 보관 가능하며, 유효기간이 지났다면 반드시 파기해야 합니다.

예를 들어, A라는 약관의 유효기간이 12 달이고, 2021년 1월 5일에 수집된 개인정보가 A약관으로 수집되었다면 해당 개인정보는 2022년 1월 4일까지 보관 가능하며 2022년 1월 5일부터 파기해야 할 개인정보입니다. 당신은 오늘 날짜로 파기해야 할 개인정보 번호들을 구하려 합니다.

모든 달은 28일까지 있다고 가정합니다.

다음은 오늘 날짜가 2022.05.19일 때의 예시입니다.

• 첫 번째 개인정보는 A약관에 의해 2021년 11월 1일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.
• 두 번째 개인정보는 B약관에 의해 2022년 6월 28일까지 보관 가능하며, 유효기간이 지나지 않았으므로 아직 보관 가능합니다.
• 세 번째 개인정보는 C약관에 의해 2022년 5월 18일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.
• 네 번째 개인정보는 C약관에 의해 2022년 5월 19일까지 보관 가능하며, 유효기간이 지나지 않았으므로 아직 보관 가능합니다.
  따라서 파기해야 할 개인정보 번호는 [1, 3]입니다.
  오늘 날짜를 의미하는 문자열 today, 약관의 유효기간을 담은 1차원 문자열 배열 terms와 수집된 개인정보의 정보를 담은 1차원 문자열 배열 privacies가 매개변수로 주어집니다. 이때 파기해야 할 개인정보의 번호를 오름차순으로 1차원 정수 배열에 담아 return 하도록 solution 함수를 완성해 주세요.

제한사항

• today는 "YYYY.MM.DD" 형태로 오늘 날짜를 나타냅니다.
• 1 ≤ terms의 길이 ≤ 20
  • terms의 원소는 "약관 종류 유효기간" 형태의 약관 종류와 유효기간을 공백 하나로 구분한 문자열입니다.
  • 약관 종류는 A~Z중 알파벳 대문자 하나이며, terms 배열에서 약관 종류는 중복되지 않습니다.
  • 유효기간은 개인정보를 보관할 수 있는 달 수를 나타내는 정수이며, 1 이상 100 이하입니다.
• 1 ≤ privacies의 길이 ≤ 100
  • privacies[i]는 i+1번 개인정보의 수집 일자와 약관 종류를 나타냅니다.
  • privacies의 원소는 "날짜 약관 종류" 형태의 날짜와 약관 종류를 공백 하나로 구분한 문자열입니다.
  • 날짜는 "YYYY.MM.DD" 형태의 개인정보가 수집된 날짜를 나타내며, today 이전의 날짜만 주어집니다.
  • privacies의 약관 종류는 항상 terms에 나타난 약관 종류만 주어집니다.
• today와 privacies에 등장하는 날짜의 YYYY는 연도, MM은 월, DD는 일을 나타내며 점(.) 하나로 구분되어 있습니다.
  • 2000 ≤ YYYY ≤ 2022
  • 1 ≤ MM ≤ 12
  • MM이 한 자릿수인 경우 앞에 0이 붙습니다.
  • 1 ≤ DD ≤ 28
  • DD가 한 자릿수인 경우 앞에 0이 붙습니다.
• 파기해야 할 개인정보가 하나 이상 존재하는 입력만 주어집니다.

입출력 예

입출력 예 설명

입출력 예 #1 문제 예시와 같습니다.

입출력 예 #2

오늘 날짜는 2020년 1월 1일입니다.

• 첫 번째 개인정보는 D약관에 의해 2019년 5월 28일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.
• 두 번째 개인정보는 Z약관에 의해 2020년 2월 14일까지 보관 가능하며, 유효기간이 지나지 않았으므로 아직 보관 가능합니다.
• 세 번째 개인정보는 D약관에 의해 2020년 1월 1일까지 보관 가능하며, 유효기간이 지나지 않았으므로 아직 보관 가능합니다.
• 네 번째 개인정보는 D약관에 의해 2019년 11월 28일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.
• 다섯 번째 개인정보는 Z약관에 의해 2019년 3월 27일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.

💡풀이

import java.util.*;

class Solution {
    public int[] solution(String today, String[] terms, String[] privacies) {
        ArrayList<Integer> answer = new ArrayList<>();
        HashMap<String, Integer> map = new HashMap<>();

        int date = getDate(today);

        for (String s : terms) {
            String[] term = s.split(" ");
            map.put(term[0], Integer.parseInt(term[1]));
        }

        for (int i = 0; i < privacies.length; i++) {
            String[] privacy = privacies[i].split(" ");

            if (getDate(privacy[0]) + (map.get(privacy[1]) * 28) <= date) {
                answer.add(i + 1);
            }
        }
        return answer.stream().mapToInt(integer -> integer).toArray();
    }

    private int getDate(String today) {
        String[] date = today.split("\\.");
        int year = Integer.parseInt(date[0]);
        int month = Integer.parseInt(date[1]);
        int day = Integer.parseInt(date[2]);
        return (year * 12 * 28) + (month * 28) + day;
    }
}

숫자로 이루어진 문자열 t와 p가 주어질 때, t에서 p와 길이가 같은 부분문자열 중에서, 이 부분문자열이 나타내는 수가 p가 나타내는 수보다 작거나 같은 것이 나오는 횟수를 return하는 함수 solution을 완성하세요. 예를 들어, t="3141592"이고 p="271" 인 경우, t의 길이가 3인 부분 문자열은 314, 141, 415, 159, 592입니다. 이 문자열이 나타내는 수 중 271보다 작거나 같은 수는 141, 159 2개 입니다.

제한사항

• 1 ≤ p의 길이 ≤ 18
• p의 길이 ≤ t의 길이 ≤ 10,000
• t와 p는 숫자로만 이루어진 문자열이며, 0으로 시작하지 않습니다.

입출력 예

입출력 예 설명

입출력 예 #1 본문과 같습니다.

입출력 예 #2 p의 길이가 1이므로 t의 부분문자열은 "5", "0", 0", "2", "2", "0", "8", "3", "9", "8", "7", "8"이며 이중 7보다 작거나 같은 숫자는 "5", "0", "0", "2", "2", "0", "3", "7" 이렇게 8개가 있습니다.

입출력 예 #3 p의 길이가 2이므로 t의 부분문자열은 "10", "02", "20", "03"이며, 이중 15보다 작거나 같은 숫자는 "10", "02", "03" 이렇게 3개입니다. "02"와 "03"은 각각 2, 3에 해당한다는 점에 주의하세요

💡풀이

class Solution {
    public int solution(String t, String p) {
        int answer = 0;

        for(int i = 0; i <= t.length() - p.length(); i++){
            if(Long.parseLong(t.substring(i, i + p.length())) <= Long.parseLong(p)){
                answer++;
            }
        }
        return answer;
    }
}

문자열 s가 주어졌을 때, s의 각 위치마다 자신보다 앞에 나왔으면서, 자신과 가장 가까운 곳에 있는 같은 글자가 어디 있는지 알고 싶습니다. 예를 들어, s="banana"라고 할 때, 각 글자들을 왼쪽부터 오른쪽으로 읽어 나가면서 다음과 같이 진행할 수 있습니다.

• b는 처음 나왔기 때문에 자신의 앞에 같은 글자가 없습니다. 이는 -1로 표현합니다.
• a는 처음 나왔기 때문에 자신의 앞에 같은 글자가 없습니다. 이는 -1로 표현합니다.
• n은 처음 나왔기 때문에 자신의 앞에 같은 글자가 없습니다. 이는 -1로 표현합니다.
• a는 자신보다 두 칸 앞에 a가 있습니다. 이는 2로 표현합니다.
• n도 자신보다 두 칸 앞에 n이 있습니다. 이는 2로 표현합니다.
• a는 자신보다 두 칸, 네 칸 앞에 a가 있습니다. 이 중 가까운 것은 두 칸 앞이고, 이는 2로 표현합니다. 따라서 최종 결과물은 [-1, -1, -1, 2, 2, 2]가 됩니다. 문자열 s이 주어질 때, 위와 같이 정의된 연산을 수행하는 함수 solution을 완성해주세요.

제한사항

• 1 ≤ s의 길이 ≤ 10,000
  • s은 영어 소문자로만 이루어져 있습니다.

입출력 예

입출력 예 설명

입출력 예 #1 지문과 같습니다.

입출력 예 #2 설명 생략

💡풀이

class Solution {
    public int[] solution(String s) {
        int[] answer = new int[s.length()];
        answer[0] = -1;
        for(int i = 1; i < s.length(); i++){
            for(int j = i-1; j >= 0; j--){
                if(s.charAt(i) == s.charAt(j)){
                    answer[i] = i - j;
                    break;
                }
            }
            if(answer[i] == 0) answer[i] = -1;
        }
        return answer;
    }
}

당신은 폰켓몬을 잡기 위한 오랜 여행 끝에, 홍 박사님의 연구실에 도착했습니다. 홍 박사님은 당신에게 자신의 연구실에 있는 총 N 마리의 폰켓몬 중에서 N/2마리를 가져가도 좋다고 했습니다. 홍 박사님 연구실의 폰켓몬은 종류에 따라 번호를 붙여 구분합니다. 따라서 같은 종류의 폰켓몬은 같은 번호를 가지고 있습니다. 예를 들어 연구실에 총 4마리의 폰켓몬이 있고, 각 폰켓몬의 종류 번호가 [3번, 1번, 2번, 3번]이라면 이는 3번 폰켓몬 두 마리, 1번 폰켓몬 한 마리, 2번 폰켓몬 한 마리가 있음을 나타냅니다. 이때, 4마리의 폰켓몬 중 2마리를 고르는 방법은 다음과 같이 6가지가 있습니다.

1. 첫 번째(3번), 두 번째(1번) 폰켓몬을 선택
2. 첫 번째(3번), 세 번째(2번) 폰켓몬을 선택
3. 첫 번째(3번), 네 번째(3번) 폰켓몬을 선택
4. 두 번째(1번), 세 번째(2번) 폰켓몬을 선택
5. 두 번째(1번), 네 번째(3번) 폰켓몬을 선택
6. 세 번째(2번), 네 번째(3번) 폰켓몬을 선택 이때, 첫 번째(3번) 폰켓몬과 네 번째(3번) 폰켓몬을 선택하는 방법은 한 종류(3번 폰켓몬 두 마리)의 폰켓몬만 가질 수 있지만, 다른 방법들은 모두 두 종류의 폰켓몬을 가질 수 있습니다. 따라서 위 예시에서 가질 수 있는 폰켓몬 종류 수의 최댓값은 2가 됩니다. 당신은 최대한 다양한 종류의 폰켓몬을 가지길 원하기 때문에, 최대한 많은 종류의 폰켓몬을 포함해서 N/2마리를 선택하려 합니다. N마리 폰켓몬의 종류 번호가 담긴 배열 nums가 매개변수로 주어질 때, N/2마리의 폰켓몬을 선택하는 방법 중, 가장 많은 종류의 폰켓몬을 선택하는 방법을 찾아, 그때의 폰켓몬 종류 번호의 개수를 return 하도록 solution 함수를 완성해주세요.

제한사항

• nums는 폰켓몬의 종류 번호가 담긴 1차원 배열입니다.
• nums의 길이(N)는 1 이상 10,000 이하의 자연수이며, 항상 짝수로 주어집니다.
• 폰켓몬의 종류 번호는 1 이상 200,000 이하의 자연수로 나타냅니다.
• 가장 많은 종류의 폰켓몬을 선택하는 방법이 여러 가지인 경우에도, 선택할 수 있는 폰켓몬 종류 개수의 최댓값 하나만 return 하면 됩니다.

입출력 예

입출력 예 설명

입출력 예 #1 문제의 예시와 같습니다.

입출력 예 #2 6마리의 폰켓몬이 있으므로, 3마리의 폰켓몬을 골라야 합니다. 가장 많은 종류의 폰켓몬을 고르기 위해서는 3번 폰켓몬 한 마리, 2번 폰켓몬 한 마리, 4번 폰켓몬 한 마리를 고르면 되며, 따라서 3을 return 합니다.

입출력 예 #3 6마리의 폰켓몬이 있으므로, 3마리의 폰켓몬을 골라야 합니다. 가장 많은 종류의 폰켓몬을 고르기 위해서는 3번 폰켓몬 한 마리와 2번 폰켓몬 두 마리를 고르거나, 혹은 3번 폰켓몬 두 마리와 2번 폰켓몬 한 마리를 고르면 됩니다. 따라서 최대 고를 수 있는 폰켓몬 종류의 수는 2입니다.

💡풀이

import java.util.*;

class Solution {
    public int solution(int[] nums) {
        int n = nums.length / 2;

        HashSet<Integer> set = new HashSet<>();

        for(int i = 0; i < nums.length; i++){
            set.add(nums[i]);
        }

        return n < set.size() ? n : set.size();
    }
}

2016년 1월 1일은 금요일입니다. 2016년 a월 b일은 무슨 요일일까요? 두 수 a ,b를 입력받아 2016년 a월 b일이 무슨 요일인지 리턴하는 함수, solution을 완성하세요. 요일의 이름은 일요일부터 토요일까지 각각 SUN,MON,TUE,WED,THU,FRI,SAT입니다. 예를 들어 a=5, b=24라면 5월 24일은 화요일이므로 문자열 "TUE"를 반환하세요.

제한사항

• 2016년은 윤년입니다.
• 2016년 a월 b일은 실제로 있는 날입니다. (13월 26일이나 2월 45일같은 날짜는 주어지지 않습니다)

입출력 예

💡풀이

import java.time.*;

class Solution {
    public String solution(int a, int b) {
        return LocalDate.of(2016, a, b).getDayOfWeek().toString().substring(0,3);
    }
}

단어 s의 가운데 글자를 반환하는 함수, solution을 만들어 보세요. 단어의 길이가 짝수라면 가운데 두글자를 반환하면 됩니다.

제한사항

• s는 길이가 1 이상, 100이하인 스트링입니다.

입출력 예

💡풀이

class Solution {
    public String solution(String s) {
        String[] arr = s.split("");
        return arr.length % 2 == 0 ? arr[arr.length / 2 - 1] + arr[arr.length / 2] : arr[arr.length / 2];
    }
}

배열 arr가 주어집니다. 배열 arr의 각 원소는 숫자 0부터 9까지로 이루어져 있습니다. 이때, 배열 arr에서 연속적으로 나타나는 숫자는 하나만 남기고 전부 제거하려고 합니다. 단, 제거된 후 남은 수들을 반환할 때는 배열 arr의 원소들의 순서를 유지해야 합니다. 예를 들면,

• arr = [1, 1, 3, 3, 0, 1, 1] 이면 [1, 3, 0, 1] 을 return 합니다.
• arr = [4, 4, 4, 3, 3] 이면 [4, 3] 을 return 합니다. 배열 arr에서 연속적으로 나타나는 숫자는 제거하고 남은 수들을 return 하는 solution 함수를 완성해 주세요.

제한사항

• 배열 arr의 크기 : 1,000,000 이하의 자연수
• 배열 arr의 원소의 크기 : 0보다 크거나 같고 9보다 작거나 같은 정수

입출력 예

입출력 예 설명

입출력 예 #1,2 문제의 예시와 같습니다.

💡풀이

import java.util.*;

public class Solution {
    public int[] solution(int []arr) {
        ArrayList<Integer> list = new ArrayList<>();
        int n = -1;
        for(int i = 0; i < arr.length; i++){
            if(n != arr[i]){
                list.add(arr[i]);
                n = arr[i];
            }
        }
        return list.stream().mapToInt(Integer::intValue).toArray();
    }
}

array의 각 element 중 divisor로 나누어 떨어지는 값을 오름차순으로 정렬한 배열을 반환하는 함수, solution을 작성해주세요. divisor로 나누어 떨어지는 element가 하나도 없다면 배열에 -1을 담아 반환하세요.

제한사항

• arr은 자연수를 담은 배열입니다.
• 정수 i, j에 대해 i ≠ j 이면 arr[i] ≠ arr[j] 입니다.
• divisor는 자연수입니다.
• array는 길이 1 이상인 배열입니다.

입출력 예

입출력 예 설명

입출력 예#1 arr의 원소 중 5로 나누어 떨어지는 원소는 5와 10입니다. 따라서 [5, 10]을 리턴합니다.

입출력 예#2 arr의 모든 원소는 1으로 나누어 떨어집니다. 원소를 오름차순으로 정렬해 [1, 2, 3, 36]을 리턴합니다.

입출력 예#3 3, 2, 6은 10으로 나누어 떨어지지 않습니다. 나누어 떨어지는 원소가 없으므로 [-1]을 리턴합니다.

💡풀이

import java.util.*;

class Solution {
    public int[] solution(int[] arr, int divisor) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i = 0; i < arr.length; i++){
            if(arr[i] % divisor == 0){
                list.add(arr[i]);
            }
        }

        if(list.size() == 0){
            list.add(-1);
        }

        Collections.sort(list);

        return list.stream().mapToInt(Integer::intValue).toArray();
    }
}

두 정수 a, b가 주어졌을 때 a와 b 사이에 속한 모든 정수의 합을 리턴하는 함수, solution을 완성하세요. 예를 들어 a = 3, b = 5인 경우, 3 + 4 + 5 = 12이므로 12를 리턴합니다.

제한사항

• a와 b가 같은 경우는 둘 중 아무 수나 리턴하세요.
• a와 b는 -10,000,000 이상 10,000,000 이하인 정수입니다.
• a와 b의 대소관계는 정해져있지 않습니다.

입출력 예

💡풀이

class Solution {
    public long solution(int a, int b) {
        long answer = 0;

        for(int i = Math.min(a,b); i <= Math.max(a,b); i++){
            answer += (long)i;
        }
        return answer;
    }
}

문자열로 구성된 리스트 strings와, 정수 n이 주어졌을 때, 각 문자열의 인덱스 n번째 글자를 기준으로 오름차순 정렬하려 합니다. 예를 들어 strings가 ["sun", "bed", "car"]이고 n이 1이면 각 단어의 인덱스 1의 문자 "u", "e", "a"로 strings를 정렬합니다.

제한사항

• strings는 길이 1 이상, 50이하인 배열입니다.
• strings의 원소는 소문자 알파벳으로 이루어져 있습니다.
• strings의 원소는 길이 1 이상, 100이하인 문자열입니다.
• 모든 strings의 원소의 길이는 n보다 큽니다.
• 인덱스 1의 문자가 같은 문자열이 여럿 일 경우, 사전순으로 앞선 문자열이 앞쪽에 위치합니다.

입출력 예

입출력 예 설명

입출력 예 1 "sun", "bed", "car"의 1번째 인덱스 값은 각각 "u", "e", "a" 입니다. 이를 기준으로 strings를 정렬하면 ["car", "bed", "sun"] 입니다.

입출력 예 2 "abce"와 "abcd", "cdx"의 2번째 인덱스 값은 "c", "c", "x"입니다. 따라서 정렬 후에는 "cdx"가 가장 뒤에 위치합니다. "abce"와 "abcd"는 사전순으로 정렬하면 "abcd"가 우선하므로, 답은 ["abcd", "abce", "cdx"] 입니다.

💡풀이

import java.util.*;

class Solution {
    public String[] solution(String[] strings, int n) {
        String[] answer = new String[strings.length];

        ArrayList<String> list = new ArrayList<>();

        for(int i = 0; i < strings.length; i++){
            list.add(strings[i].charAt(n) + strings[i]);
        }

        Collections.sort(list);

        for(int i = 0; i < list.size(); i++) {
            answer[i] = list.get(i).substring(1);
        }
        return answer;
    }
}

대문자와 소문자가 섞여있는 문자열 s가 주어집니다. s에 'p'의 개수와 'y'의 개수를 비교해 같으면 True, 다르면 False를 return 하는 solution를 완성하세요. 'p', 'y' 모두 하나도 없는 경우는 항상 True를 리턴합니다. 단, 개수를 비교할 때 대문자와 소문자는 구별하지 않습니다. 예를 들어 s가 "pPoooyY"면 true를 return하고 "Pyy"라면 false를 return합니다.

제한사항

• 문자열 s의 길이 : 50 이하의 자연수
• 문자열 s는 알파벳으로만 이루어져 있습니다.

입출력 예

💡풀이

class Solution {
    boolean solution(String s) {
        int pCount = 0;
        int yCount = 0;

        String[] arr = s.toLowerCase().split("");
        for(int i = 0; i < arr.length; i++){
            if(arr[i].equals("p")){
                pCount++;
            }else if(arr[i].equals("y")){
                yCount++;
            }
        }
        return pCount == yCount ? true : false;
    }
}

문자열 s에 나타나는 문자를 큰것부터 작은 순으로 정렬해 새로운 문자열을 리턴하는 함수, solution을 완성해주세요. s는 영문 대소문자로만 구성되어 있으며, 대문자는 소문자보다 작은 것으로 간주합니다.

제한사항

• str은 길이 1 이상인 문자열입니다.

입출력 예

💡풀이

import java.util.*;

class Solution {
    public String solution(String s) {
        String answer = "";
        char[] arr = s.toCharArray();
        Arrays.sort(arr);

        for(int i = arr.length - 1; i >= 0; i--){
            answer += arr[i];
        }
        return answer;
    }
}

문자열 s의 길이가 4 혹은 6이고, 숫자로만 구성돼있는지 확인해주는 함수, solution을 완성하세요. 예를 들어 s가 "a234"이면 False를 리턴하고 "1234"라면 True를 리턴하면 됩니다.

제한사항

• s는 길이 1 이상, 길이 8 이하인 문자열입니다.
• s는 영문 알파벳 대소문자 또는 0부터 9까지 숫자로 이루어져 있습니다.

입출력 예

💡풀이

class Solution {
    public boolean solution(String s) {
        if (s.length() == 4 || s.length() == 6){
            if(s.matches("(^[0-9]*$)")){
                return true;
            }  
        } 
        return false;
    }
}

String형 배열 seoul의 element중 "Kim"의 위치 x를 찾아, "김서방은 x에 있다"는 String을 반환하는 함수, solution을 완성하세요. seoul에 "Kim"은 오직 한 번만 나타나며 잘못된 값이 입력되는 경우는 없습니다.

제한사항

• seoul은 길이 1 이상, 1000 이하인 배열입니다.
• seoul의 원소는 길이 1 이상, 20 이하인 문자열입니다.
• "Kim"은 반드시 seoul 안에 포함되어 있습니다.

입출력 예

💡풀이

class Solution {
    public String solution(String[] seoul) {
        int count = 0;
        for(int i = 0; i < seoul.length; i++){
            if(seoul[i].equals("Kim")){
                count += i;
                break;
            }
        }
        return "김서방은 " + count + "에 있다";
    }
}

1부터 입력받은 숫자 n 사이에 있는 소수의 개수를 반환하는 함수, solution을 만들어 보세요. 소수는 1과 자기 자신으로만 나누어지는 수를 의미합니다.(1은 소수가 아닙니다.)

제한사항

• n은 2이상 1000000이하의 자연수입니다.

입출력 예

입출력 예 설명

입출력 예 #1 1부터 10 사이의 소수는 [2,3,5,7] 4개가 존재하므로 4를 반환

입출력 예 #2 1부터 5 사이의 소수는 [2,3,5] 3개가 존재하므로 3를 반환

💡풀이

class Solution {
    public int solution(int n) {
        int answer = 0;

        int[] numbers = new int[n+1];

        for(int i = 2; i <= n; i++) numbers[i]=i;

        for(int i = 2; i < n; i++) {
            if(numbers[i] == 0) continue;
            for(int j = 2 * i; j <= n; j += i) numbers[j] = 0;
        }

        for(int i = 0; i < numbers.length; i++) {
            if(numbers[i] != 0) answer++;
        }

        return answer;
    }
}

길이가 n이고, "수박수박수박수...."와 같은 패턴을 유지하는 문자열을 리턴하는 함수, solution을 완성하세요. 예를들어 n이 4이면 "수박수박"을 리턴하고 3이라면 "수박수"를 리턴하면 됩니다.

제한사항

• n은 길이 10,000이하인 자연수입니다.

입출력 예

💡풀이

class Solution {
    public String solution(int n) {
        String answer = "";
        for(int i = 1; i <= n; i++){
            if(i % 2 != 0){
                answer += "수";
            }else{
                answer += "박";
            }
        }
        return answer;
    }
}