개발하는 자비스

[codility] Prefix Sums - CountDiv

jarvis_ — Fri, 24 Sep 2021 02:29:59 +0900

문제

Write a function:

public func solution(_ A : Int, _ B : Int, _ K : Int) -> Int

that, given three integers A, B and K, returns the number of integers within the range [A..B] that are divisible by K, i.e.:

{ i : A ≤ i ≤ B, i mod K = 0 }

For example, for A = 6, B = 11 and K = 2, your function should return 3, because there are three numbers divisible by 2 within the range [6..11], namely 6, 8 and 10.

Write an efficient algorithm for the following assumptions:

A and B are integers within the range [0..2,000,000,000];

K is an integer within the range [1..2,000,000,000];

A ≤ B.Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

문제 해설

A...B 범위내에 K로 나눌수 있는 정수의 합을 구하기

구현 해설

첫번째 : for 문을 돌면서 하나씩 구하다보니 시간복잡도 이슈 발생

두번째 : A가 0인경우 -> A:0 B:5 K:2 -> 5/2 = 2, -> 0은 모든 자연수의 배수이기 때문에 +1 해서 결과 3

A가 0이 아닌경우 -> A:1 B:5 K:2 -> 5/2 - (1-1) / 2 = 결과 2

https://app.codility.com/demo/results/trainingSGUDUU-4E6/

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ A : Int, _ B : Int, _ K : Int) -> Int {
    // write your code in Swift 4.2.1 (Linux)
    var sum = 0
    for index in A...B {
        if index % K == 0 {
            sum += 1
        }
    }
    return sum
}

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ A : Int, _ B : Int, _ K : Int) -> Int {
    // write your code in Swift 4.2.1 (Linux)
    if A == 0 {
        return B / K + 1
    } else {
        return B / K - (A - 1) / K
    }
}

[codility] Prefix Sums - PassingCars

jarvis_ — Fri, 24 Sep 2021 02:04:49 +0900

문제

A non-empty array A consisting of N integers is given. The consecutive elements of array A represent consecutive cars on a road.

Array A contains only 0s and/or 1s:

0 represents a car traveling east,

1 represents a car traveling west.

The goal is to count passing cars. We say that a pair of cars (P, Q), where 0 ≤ P < Q < N, is passing when P is traveling to the east and Q is traveling to the west.

For example, consider array A such that:

A[0] = 0 A[1] = 1 A[2] = 0 A[3] = 1 A[4] = 1

We have five pairs of passing cars: (0, 1), (0, 3), (0, 4), (2, 3), (2, 4).

Write a function:

public func solution(_ A : inout [Int]) -> Int

that, given a non-empty array A of N integers, returns the number of pairs of passing cars.

The function should return −1 if the number of pairs of passing cars exceeds 1,000,000,000.

For example, given:

A[0] = 0 A[1] = 1 A[2] = 0 A[3] = 1 A[4] = 1

the function should return 5, as explained above.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..100,000];

each element of array A is an integer that can have one of the following values: 0, 1.Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

문제 해설

A 배열이 0 1 1 0 1 -> 자동차의 쌍이 (0,1), (0,2), (0,4), (3,4) 4를 리턴

구현 해설

첫번째 : 하나씩 짝을 지어주려고 접근 -> 시간복잡도 이슈 발생

두번째 : 카운팅으로 변경했으나 filter에서 시간복잡도 이슈 발생

세번째 : [0, 1, 0, 1, 1] 인경우 0이 하나인경우에 1을 만나면 1증가, 0이 두개인경우에 1을 만나면 2증가로 해결

- 문제풀기 전에 고민을 더 해보고 접근해야겠다는 생각이 듦

https://app.codility.com/demo/results/trainingFAJWSU-49D/

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ A : inout [Int]) -> Int {
    // write your code in Swift 4.2.1 (Linux)
    
    var arr: [(Int,Int)] = []
    for (index, _) in A.enumerated() {
        if A[index] == 0 {
            for i in index..<A.count {
                if A[i] == 1 {
                    arr.append((0, 1))
                }
            }
        }
    }
    
    if arr.count > 1000000000 {
        return -1
    }
    
    return arr.count
}

시간복잡도 이슈

https://app.codility.com/demo/results/trainingTU9SBU-V6J/

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ A : inout [Int]) -> Int {
    // write your code in Swift 4.2.1 (Linux)
    var resultCount = 0
    for (index, _) in A.enumerated() {
        if A[index] == 0 {
            let size = A[index...A.count-1].filter { $0 == 1 }
            resultCount += size.count
        }
    }
    return resultCount
}

https://app.codility.com/demo/results/trainingPNMNE5-H38/

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ A : inout [Int]) -> Int {
    // write your code in Swift 4.2.1 (Linux)
    var result = 0
    var sum = 0
    
    for (index, _) in A.enumerated() {
        if A[index] == 0 {
            sum += 1
        } else {
            result += sum
        }
    }
    
    if result > 1000000000 {
        return -1
    }
    
    return result
}

[codility] Counting Elements - MissingInteger

jarvis_ — Fri, 24 Sep 2021 00:39:40 +0900

문제

This is a demo task.

Write a function:

public func solution(_ A : inout [Int]) -> Int

that, given an array A of N integers, returns the smallest positive integer (greater than 0) that does not occur in A.

For example, given A = [1, 3, 6, 4, 1, 2], the function should return 5.

Given A = [1, 2, 3], the function should return 4.

Given A = [−1, −3], the function should return 1.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..100,000];

each element of array A is an integer within the range [−1,000,000..1,000,000].Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

문제 해설

가장 작은 양의 정수를 리턴

A 배열이 주어지면 순열이 아닌 형태 [1,2,3,4,6] 5를 리턴

[1,2,3] 4를 리턴

[-1, -3] 1을 리턴

구현 해설

set을 이용해서 순차적으로 배열을 순회하면서 값이 없으면 가장 작은 정수로 판단

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ A : inout [Int]) -> Int {
    // write your code in Swift 4.2.1 (Linux)
    let sets = Set<Int>(A)
    for index in 1...Int.max {
        if !sets.contains(index) {
            return index
        }
    }
    return -1
}

[codility] Counting Elements - MaxCounters

jarvis_ — Thu, 23 Sep 2021 23:41:12 +0900

문제

You are given N counters, initially set to 0, and you have two possible operations on them:

increase(X) − counter X is increased by 1,

max counter − all counters are set to the maximum value of any counter.

A non-empty array A of M integers is given. This array represents consecutive operations:

if A[K] = X, such that 1 ≤ X ≤ N, then operation K is increase(X),

if A[K] = N + 1 then operation K is max counter.

For example, given integer N = 5 and array A such that:

A[0] = 3 A[1] = 4 A[2] = 4 A[3] = 6 A[4] = 1 A[5] = 4 A[6] = 4

the values of the counters after each consecutive operation will be:

(0, 0, 1, 0, 0) (0, 0, 1, 1, 0) (0, 0, 1, 2, 0) (2, 2, 2, 2, 2) (3, 2, 2, 2, 2) (3, 2, 2, 3, 2) (3, 2, 2, 4, 2)

The goal is to calculate the value of every counter after all operations.

Write a function:

public func solution(_ N : Int, _ A : inout [Int]) -> [Int]

that, given an integer N and a non-empty array A consisting of M integers, returns a sequence of integers representing the values of the counters.

Result array should be returned as an array of integers.

For example, given:

A[0] = 3 A[1] = 4 A[2] = 4 A[3] = 6 A[4] = 1 A[5] = 4 A[6] = 4

the function should return [3, 2, 2, 4, 2], as explained above.

Write an efficient algorithm for the following assumptions:

N and M are integers within the range [1..100,000];

each element of array A is an integer within the range [1..N + 1].

Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

문제 해설

A[K] = X, 1 <= X <= N 카운트 증가

A[K] = N + 1 이면 최대 카운트값 전체적용

구현 해설

X값이 1보다 크거나 같고 N보다 작거나 같으면 해당 인덱스 카운팅 값 증가

큰값이나 예측하지 못한 데이터가 들어오는 경우가 발생

arr 에 현재 카운팅중 가장 큰값을 초기화하는 [Int](repeating: arr.max()!, count: N) 구문인듯 하다.

다른 방법으로 계속 풀어봤으나 100%는 힘들어서 검색을 해봄

https://app.codility.com/demo/results/trainingC62947-485/

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ N : Int, _ A : inout [Int]) -> [Int] {
    // write your code in Swift 4.2.1 (Linux)
    var arr = [Int](repeating: 0, count: N)
    for (index, _) in A.enumerated() {
        if 1 <= A[index] && A[index] <= N  {
            arr[A[index]-1] += 1
        } else if A[index] == N+1 {
            arr = [Int](repeating: arr.max()!, count: N)
        }
    }
    
    return arr
}

해결 힌트는 return 시 maxCounter와 arr에 카운트값과 비교하여 작은 값에 초기화

https://app.codility.com/demo/results/trainingWYS26A-946/

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ N : Int, _ A : inout [Int]) -> [Int] {
    // write your code in Swift 4.2.1 (Linux)
    var arr = [Int](repeating: 0, count: N)
        
    var max = 0
    var maxCounter = 0
    for (index, _) in A.enumerated() {
        if A[index] > N {
            maxCounter = max
        } else {
            if arr[A[index]-1] < maxCounter {
                arr[A[index]-1] = maxCounter
            }
                
            arr[A[index]-1] += 1
                
            if max < arr[A[index]-1] {
                max = arr[A[index]-1]
            }
        }
    }
    return arr.map({ $0 < maxCounter ? maxCounter : $0 })
}

[codility] Counting Elements - PermCheck

jarvis_ — Thu, 23 Sep 2021 20:53:59 +0900

문제

A non-empty array A consisting of N integers is given.

A permutation is a sequence containing each element from 1 to N once, and only once.

For example, array A such that:

A[0] = 4 A[1] = 1 A[2] = 3 A[3] = 2

is a permutation, but array A such that:

A[0] = 4 A[1] = 1 A[2] = 3

is not a permutation, because value 2 is missing.

The goal is to check whether array A is a permutation.

Write a function:

public func solution(_ A : inout [Int]) -> Int

that, given an array A, returns 1 if array A is a permutation and 0 if it is not.

For example, given array A such that:

A[0] = 4 A[1] = 1 A[2] = 3 A[3] = 2

the function should return 1.

Given array A such that:

A[0] = 4 A[1] = 1 A[2] = 3

the function should return 0.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..100,000];

each element of array A is an integer within the range [1..1,000,000,000].

Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

문제 해설

A배열이 순열인지 아닌지 체크

순열이면 1 아니면 0 리턴

구현 해설

A 배열이 [3,1,2,4] 인경우에는 1 리턴

[1,2,4] 인 경우에는 순열이 아니기 때문에 0 리턴

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ A : inout [Int]) -> Int {
    // write your code in Swift 4.2.1 (Linux)

    A.sort()
    for (index, _) in A.enumerated() {
        if index+1 != A[index] {
            return 0
        }
    }
    return 1
}

[codility] Counting Elements - FrogRiverOne

jarvis_ — Thu, 23 Sep 2021 20:37:45 +0900

문제

A small frog wants to get to the other side of a river. The frog is initially located on one bank of the river (position 0) and wants to get to the opposite bank (position X+1). Leaves fall from a tree onto the surface of the river.

You are given an array A consisting of N integers representing the falling leaves. A[K] represents the position where one leaf falls at time K, measured in seconds.

The goal is to find the earliest time when the frog can jump to the other side of the river. The frog can cross only when leaves appear at every position across the river from 1 to X (that is, we want to find the earliest moment when all the positions from 1 to X are covered by leaves). You may assume that the speed of the current in the river is negligibly small, i.e. the leaves do not change their positions once they fall in the river.

For example, you are given integer X = 5 and array A such that:

A[0] = 1 A[1] = 3 A[2] = 1 A[3] = 4 A[4] = 2 A[5] = 3 A[6] = 5 A[7] = 4

In second 6, a leaf falls into position 5. This is the earliest time when leaves appear in every position across the river.

Write a function:

public func solution(_ X : Int, _ A : inout [Int]) -> Int

that, given a non-empty array A consisting of N integers and integer X, returns the earliest time when the frog can jump to the other side of the river.

If the frog is never able to jump to the other side of the river, the function should return −1.

For example, given X = 5 and array A such that:

A[0] = 1 A[1] = 3 A[2] = 1 A[3] = 4 A[4] = 2 A[5] = 3 A[6] = 5 A[7] = 4

the function should return 6, as explained above.

Write an efficient algorithm for the following assumptions:

N and X are integers within the range [1..100,000];

each element of array A is an integer within the range [1..X].Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

문제 해설

나뭇잎의 배열인 A [1,4,3,2,3,1,5,4], X = 5 가 주어지면 1부터 X까지 연속된 숫자가 도달되는 인덱스를 구하여 리턴, 없으면 -1 리턴

구현 해설

set을 이용하여 중복제거

set에 A 배열의 값을 인서트

set 사이즈와 X값과 같으면 리턴

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ X : Int, _ A : inout [Int]) -> Int {
    // write your code in Swift 4.2.1 (Linux)

    var sets = Set<Int>()
    for (index, _) in A.enumerated() {
        sets.insert(A[index])
        if sets.count == X {
            return index
        }
    }
    return -1
}

[codility] Time Complexity - TapeEquilibrium

jarvis_ — Thu, 23 Sep 2021 00:48:52 +0900

문제

A non-empty array A consisting of N integers is given. Array A represents numbers on a tape.

Any integer P, such that 0 < P < N, splits this tape into two non-empty parts: A[0], A[1], ..., A[P − 1] and A[P], A[P + 1], ..., A[N − 1].

The difference between the two parts is the value of: |(A[0] + A[1] + ... + A[P − 1]) − (A[P] + A[P + 1] + ... + A[N − 1])|

In other words, it is the absolute difference between the sum of the first part and the sum of the second part.

For example, consider array A such that:

A[0] = 3 A[1] = 1 A[2] = 2 A[3] = 4 A[4] = 3

We can split this tape in four places:

P = 1, difference = |3 − 10| = 7

P = 2, difference = |4 − 9| = 5

P = 3, difference = |6 − 7| = 1

P = 4, difference = |10 − 3| = 7

Write a function:

public func solution(_ A : inout [Int]) -> Int

that, given a non-empty array A of N integers, returns the minimal difference that can be achieved.

For example, given:

A[0] = 3 A[1] = 1 A[2] = 2 A[3] = 4 A[4] = 3

the function should return 1, as explained above.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [2..100,000];

each element of array A is an integer within the range [−1,000..1,000].Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

문제 해설

구현 해설

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ A : inout [Int]) -> Int {
    // write your code in Swift 4.2.1 (Linux)
    //[3, 1, 2, 4, 3]
    
    let total = A.reduce(0, {$0+$1})
    var P = 0
    var arr: [Int] = []
    for (index, _) in A.enumerated() {
        
        if index == A.count-1 { break }
        
        P += A[index]
        
        let diff = abs(P - (total - P))
        arr.append(diff)
    }
    arr.sort()
    return arr[0]
}

[codility] Time Complexity- PermMissingElem

jarvis_ — Wed, 22 Sep 2021 23:47:35 +0900

문제

An array A consisting of N different integers is given. The array contains integers in the range [1..(N + 1)], which means that exactly one element is missing.

Your goal is to find that missing element.

Write a function:

function solution(A: array of longint; N: longint): longint;

that, given an array A, returns the value of the missing element.

For example, given array A such that:

A[0] = 2 A[1] = 3 A[2] = 1 A[3] = 5

the function should return 4, as it is the missing element.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [0..100,000];

the elements of A are all distinct;

each element of array A is an integer within the range [1..(N + 1)].Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

문제 해설

N개의 서로 다른 정수로 구성된 배열 A 제공

[1..(N+1)] 누락된 값을 구하기

구현 해설

- 정렬

- 배열 순회하면서 $0, $1 비교해서 값이 다르면 순차값이 아니기때문에 해당 인덱스+1로 틀린값을 반환

- 인덱스+1과 0번째 배열값을 비교해서 다르면 인덱스 + 1로 누락값을 리턴

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ A : inout [Int]) -> Int {
    // write your code in Swift 4.2.1 (Linux)

	A.sort()

    for (index, _) in A.enumerated() {
        if index+1 != A[index] {
            return index+1
        }
    }

    return A.count+1
}

[codility] Time Complexity - FrogJmp

jarvis_ — Wed, 22 Sep 2021 22:49:49 +0900

문제

A small frog wants to get to the other side of the road. The frog is currently located at position X and wants to get to a position greater than or equal to Y. The small frog always jumps a fixed distance, D.

Count the minimal number of jumps that the small frog must perform to reach its target.

Write a function:

public func solution(_ X : Int, _ Y : Int, _ D : Int) -> Int

that, given three integers X, Y and D, returns the minimal number of jumps from position X to a position equal to or greater than Y.

For example, given:

X = 10 Y = 85 D = 30

the function should return 3, because the frog will be positioned as follows:

after the first jump, at position 10 + 30 = 40

after the second jump, at position 10 + 30 + 30 = 70

after the third jump, at position 10 + 30 + 30 + 30 = 100

Write an efficient algorithm for the following assumptions:

X, Y and D are integers within the range [1..1,000,000,000];

X ≤ Y.Copyright 2009–2021 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

문제 해설

개구리 초기 위치 X, 도착 지점 Y, 점프 값 D, X<=Y

구현 해설

초기 위치값X가 Y보다 크거나 같으면 이동하지 않아도 도착지점 예외처리

도착지점 - 초기지점 = 이동해야 할 거리

이동해야 할 거리 / 점프 한번 당 이동거리 = 이동횟수

이동해야 할 거리 % 점프 한번 당 이동거리의 나머지 몫이 0보다 크면 한번 카운트 추가

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ X : Int, _ Y : Int, _ D : Int) -> Int {
    // write your code in Swift 4.2.1 (Linux)

    if X >= Y {
        return 0
    }

    var count = (Y-X) / D
    if (Y-X) % D > 0 {
        count += 1
    }

    return count
}

[codility] Arrays - OddOccurrencesInArray 문제풀이

jarvis_ — Wed, 22 Sep 2021 21:44:16 +0900

문제 원본

O(N) or O(N*log(N))

A non-empty array A consisting of N integers is given. The array contains an odd number of elements, and each element of the array can be paired with another element that has the same value, except for one element that is left unpaired.

For example, in array A such that:

A[0] = 9 A[1] = 3 A[2] = 9 A[3] = 3 A[4] = 9 A[5] = 7 A[6] = 9

the elements at indexes 0 and 2 have value 9,

the elements at indexes 1 and 3 have value 3,

the elements at indexes 4 and 6 have value 9,

the element at index 5 has value 7 and is unpaired.

Write a function:

public func solution(_ A : inout [Int]) -> Int

that, given an array A consisting of N integers fulfilling the above conditions, returns the value of the unpaired element.

For example, given array A such that:

A[0] = 9 A[1] = 3 A[2] = 9 A[3] = 3 A[4] = 9 A[5] = 7 A[6] = 9

the function should return 7, as explained in the example above.

Write an efficient algorithm for the following assumptions:

N is an odd integer within the range [1..1,000,000];

each element of array A is an integer within the range [1..1,000,000,000];

all but one of the values in A occur an even number of times.Copyright 2009–2021 by Codility Limited. All

Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

문제 해설

N개의 정수가 담긴 비어있지 않은 배열 A가 제공

값이 동일하면 짝을 이룰수 있고, 동일한 값이 없는 값을 리턴

정리하면 배열 [1,2,3,4,5,2,3,4,1] 이 주어질때 짝이 없는 5를 검출

구현 해설

- 주어진 배열 정렬

case1. [2,5,3,4,5,2,1,3,5] -> [1,1,2,2,3,3,4,5,5]

case1. [2,5,3,4,4,2,1,3,1] -> [1,1,2,2,3,3,4,4,5]

case2. [2,1,4,3,5,5,4,2,3] -> [1,2,2,3,3,4,4,5,5]

case3. [1, 3, 2, 2, 5, 5, 3] -> [1,2,2,3,3,5,5]

case4. [1, 1, 2, 2, 5, 5, 3] -> [1,1,2,2,3,5,5]

case5. [1, 1, 2, 2, 3, 5, 3] -> [1,1,2,2,3,3,5]

2칸씩 이동하면서 값 비교하여 짝이없는 값 찾기

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ A : inout [Int]) -> Int {
    // write your code in Swift 4.2.1 (Linux)
    var resultValue = 0
    let list = A.sorted()
    for index in stride(from: 0, to: list.count - 1, by: 2) {
        if list[index] != list[index + 1] {
            resultValue = list[index]
            break
        }   
        if index == list.count - 3 {
            resultValue = list[list.count - 1]
        }
    }
    return resultValue
}

결과

88% 예외처리 부족

예외 처리 추가

import Foundation
import Glibc

// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")

public func solution(_ A : inout [Int]) -> Int {
    // write your code in Swift 4.2.1 (Linux)
    if A.count == 1 {
        return A[0]
    }
    var resultValue = 0
    let list = A.sorted()
    for index in stride(from: 0, to: list.count - 1, by: 2) {
        if list[index] != list[index + 1] {
            resultValue = list[index]
            break
        }   
        if index == list.count - 3 {
            resultValue = list[list.count - 1]
        }
    }
    return resultValue
}