---
# System prepended metadata

title: Max Min

---


# Max Min

### jm

```swift
// Complete the maxMin function below.
func maxMin(k: Int, arr: [Int]) -> Int {
    // 응 개쉬워~ 
    
    // 하지만 예외를 잘 생각해야함. 
    
    // 무조건 맨앞에 k개를 뽑는 게 아님. 
    // 맨앞 k개 보다 중간에 있는 k개의 차이가 더 적을 수 있음
    
    // [0, 1, 10]  [11, 12, 13]
    // 10 > 2

    var arrOrdered = arr.sorted() // 오름차순
    var min = arrOrdered[arr.count-1]
    for index in 0...arrOrdered.count - k { // 여기서 마지막꺼 포함되도록 범위 잘 설정해야함.
        let gap = arrOrdered[k - 1 + index] - arrOrdered[index]
        if min > gap {
            min = gap
        }
    }

    return min
}

```

### woongs
```swift
func maxMin(k: Int, arr: [Int]) -> Int {
    let ordered = arr.sorted()
    var unfairness = Int.max
    for i in k...arr.count {
        let target = ordered[i-k..<i]
        unfairness = min(target.last! - target.first!, unfairness)
    }
    return unfairness
}
```

# Greedy Florist

### jm


```swift
// Complete the getMinimumCost function below.
func getMinimumCost(k: Int, c: [Int]) -> Int {
    // 9 7 5 3 1
    // 1*9 + 1*7 + 1* 5 / 2*3 + 2*1 
    
    var orderedCosts = c.sorted(by: >) // 내림차순
    
    var sumOfCosts = 0
    for index in 0..<c.count {
        let factor = index / k + 1
        sumOfCosts += orderedCosts[index] * factor
    }

    return sumOfCosts
}

```

### JH
```swift
// Complete the getMinimumCost function below.
func getMinimumCost(k: Int, c: [Int]) -> Int {
    var tempK = k
    var multi = 1
    var answer = 0
    
    c.sorted(by: >).forEach {
        answer += multi * $0
        
        tempK -= 1
        if tempK == 0 {
            tempK = k
            multi += 1
        }
    }
    return answer
}
```

### SMK
```swift
// Complete the getMinimumCost function below.
func getMinimumCost(k: Int, c: [Int]) -> Int {
    return c.sorted(by: >)
        .enumerated()
        .map { (($0/k)+1) * $1 }
        .reduce(0, +)
}
```

### woongs
```swift
func getMinimumCost(k: Int, c: [Int]) -> Int {
    var before = 0
    var canBuy = k
    var total = 0
    
    for flo in c.sorted(by: >) {
        total += (before + 1) * flo
        if canBuy-1 == 0 {
            canBuy = k
            before += 1
        } else {
            canBuy -= 1
        } 
    }
    return total
}
```

# Luck Balance

### jm

```swift
func luckBalance(k: Int, contests: [[Int]]) -> Int {
    
    // 중요한 contest는 k개까지 질 수 있다. - 이 결과 luck 합이 최대여야 한다. 
    // luck의 크기가 최소인 contest를 이기면 된다.
    // 중요도가 0인 contest는 무조건 지면 된다. 
    
    
    // 애먹었던것들
        // 진 거는 빼줘야 한다. 
        // k가 importantContests.count보다 클 수 있다.

    var sumOfLuck = 0

    var noImportantContests = contests
                                .filter { $0[1] != 1 } // O(n)
    var importantContests = contests
                            .filter { $0[1] == 1 }
                            .sorted { $0[0] > $1[0] } // O(n)
    
    if k <= importantContests.count {
        for index in (0..<k) {
            sumOfLuck += importantContests.removeFirst()[0]
        }    
    } else {
        sumOfLuck += importantContests.reduce(0) { $0 + $1[0] }
        importantContests = []
    }

    return sumOfLuck + noImportantContests.reduce(0) { $0 + $1[0] }
                - importantContests.reduce(0) { $0 + $1[0] }
}


```


### JH
```swift
// Complete the luckBalance function below.
func luckBalance(k: Int, contests: [[Int]]) -> Int {
    let sorted = contests.sorted { lhs, rhs in
        return lhs[0] > rhs[0]
    }
    var tempK = k
    var answer = 0
    
    sorted.forEach { contest in
        if contest[1] == 0 {
            answer += contest[0]
        } else {
            if tempK == 0 {
                answer -= contest[0]
            } else {
                tempK -= 1
                answer += contest[0]
            }
        }
    }
    return answer 
}

```


### SMK
```swift
// Complete the luckBalance function below.
func luckBalance(k: Int, contests: [[Int]]) -> Int {
    var lucks = [Int]()
    var luckBalance = 0
    
    contests.forEach {
        guard $0[1] == 1 else {
            luckBalance += $0[0]
            return
        }
        lucks.append($0[0])
    }
    
    lucks = lucks.sorted()
    if lucks.count < k {
        luckBalance += lucks.reduce(0, +)
    } else {
        luckBalance += lucks.suffix(k).reduce(0, +)
        luckBalance -= lucks.prefix(lucks.count-k).reduce(0, +)
    }
    return luckBalance
}
```


### woongs
```swift
func luckBalance(k: Int, contests: [[Int]]) -> Int {
    let ordered = contests.sorted(by: { $0[0] > $1[0] })
    var saving = k
    var luck = 0
    for cont in ordered {
        guard cont[1] == 1 else { 
            luck += cont[0]
            continue
        }
        if saving == 0 {
            luck -= cont[0]
        } else {
            luck += cont[0]
            saving -= 1
        }
    }
    return luck
}

```

# Minimum Absolute Difference in an Array

### jm

```swift
func minimumAbsoluteDifference(arr: [Int]) -> Int {
    
    // 차이의 절대값은 좌표상 거리다. 
    // 오름차순 정렬 후, 바로 옆에 근접한 아이끼리의 차이만 구하면 된다. 
    // a b c (a < b < c )일 때, 항상  |a - c| > |a - b| 를 만족하기 때문! 
    // 그래서 그리디구나! 
    
    let sortedArr = arr.sorted()
    
    var diffSet = Set([Int]())
    
    for index in (1..<sortedArr.count) {
        diffSet.insert(abs(sortedArr[index-1] - sortedArr[index]))
    }
    
    return diffSet.min()!
}
