Skip to content

프로그래머스 Level 0 문제풀이

Jump to bottom
현이 edited this page Feb 16, 2023 · 10 revisions

🧑‍🏫 Intro

2023년 02월 16일 최종 수정

프로그래머스 Lv.0 100문제를 풀고 기록한 wiki 입니다.
검색 기능을 통해 원하는 문제를 찾으시면,
해당 문제에 대한 저의 문제 풀이와 참고할 만한 다른 풀이 등을 확인하실 수 있습니다 🙂
(쉬운 문제의 경우 문제 풀이 및 다른 사람의 풀이가 없을 수 있습니다.)


🔍 Solution

중복된 숫자 개수

나의 문제 풀이

문제 풀이에 필요한 개념

  • filter

머쓱이보다 키 큰 사람

나의 문제 풀이

문제 풀이에 필요한 개념

  • sort()
  • 배열의 lastIndex(of:)
  • count

다른 사람 풀이

// filter 사용
func solution(_ array: [Int], _ height: Int) -> Int { 
    array.filter { $0 > height }.count 
}

두 수의 합

나의 문제 풀이

문제 풀이에 필요한 개념

  • 덧셈 연산자 +

두 수의 차

나의 문제 풀이

문제 풀이에 필요한 개념

  • 뺄셈 연산자 -

두 수의 곱

나의 문제 풀이

문제 풀이에 필요한 개념

  • 곱셈 연산자 *

몫 구하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • 나눗셈 연산자 /

두 수의 나눗셈

나의 문제 풀이

문제 풀이에 필요한 개념

  • 나눗셈 연산자 /
  • 형변환

숫자 비교하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • 삼항 연산자

분수의 덧셈

나의 문제 풀이

func solution(
    _ denum1:Int,
    _ num1:Int,
    _ denum2:Int,
    _ num2:Int
) -> [Int] {
    // 분모를 공통으로 만들기 위해 각 분자에 다른 분모 값을 곱해줌
    let up = (denum1 * num2) + (denum2 * num1) // 분자끼리 더해준 값
    let down = num1 * num2 // 공통 분모 값
    var result = [up, down]
    
    // 기약분수로 만드는 단계 
    for i in (1...down) {
        if (up % i == 0) && (down % i == 0) {
            result[0] = up / i
            result[1] = down / i
        }
    }
    return result
}

문제 풀이에 필요한 개념

  • 논리 연산자
  • 사칙 연산자

다른 사람 풀이

// 최대공약수를 filter 사용해서 구함
func solution(_ denum1:Int, _ num1:Int, _ denum2:Int, _ num2:Int) -> [Int] {
    let boonja = denum1 * num2 + denum2 * num1
    let boonmo = num1 * num2
    let gcd = (1...min(boonja, boonmo)).filter { boonja % $0 == 0 && boonmo % $0 == 0 }.max()!
    return [boonja/gcd, boonmo/gcd]
}
// 최대공약수를 유클리드 호제법을 사용해서 구함
func solution(_ denum1: Int, _ num1: Int, _ denum2: Int, _ num2: Int) -> [Int] {
    func getGcd(_ biggerInt: Int, _ smallerInt: Int) -> Int {
        let mod: Int = biggerInt % smallerInt
        return 0 == mod ? min(biggerInt, smallerInt) : getGcd(smallerInt, mod)
    }
    var (denum, num) = (denum1 * num2 + denum2 * num1, num1 * num2)
    if denum == num {
        return [1, 1]
    } else if denum < num {
        let gcd = getGcd(num, denum)
        return [denum / gcd, num / gcd]
    } else {
        let gcd = getGcd(denum, num)
        return [denum / gcd, num / gcd]
    }
}

배열 두배 만들기

나의 문제 풀이

문제 풀이에 필요한 개념

  • map

나머지 구하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • 나머지 연산자%

중앙값 구하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • sorted()
  • count

최빈값 구하기

나의 문제 풀이

func solution(_ array:[Int]) -> Int {
    var dic = [Int: Int]() // [숫자: 나온 횟수] 
    var count = 0 // 최빈값이 몇개 인지 확인하는 변수
    var result = 0
    
    // array안에 든 숫자가 몇번 나왔는지 확인하는 단계
    for i in array {
        if var value = dic[i] {
            value += 1
            dic[i] = value
        } else {
            dic[i] = 1
        }
    }
    
    // dic안에 든 숫자(key) 중 어떤 값(value)이 가장 큰지 확인하는 단계  
    for i in dic {
        if i.value == dic.values.max()! {
            count += 1
            result = i.key
        }
    }   
    
    // count가 1개보다 많으면 최빈값이 여러개이므로 -1 출력, 아니면 result 출력
    return count > 1 ? -1 : result
}

문제 풀이에 필요한 개념

  • 사전(Dictionary) 타입의 key, value(s)
  • max()
  • 삼항연산자

다른 사람 풀이

// Dictionary의 grouping을 이용해 문제를 품
func solution(_ array: [Int]) -> Int {
    let sorted = Dictionary(grouping: array) { $0 }.sorted { $0.value.count > $1.value.count }
    return sorted.count > 1 && sorted[0].value.count == sorted[1].value.count ? -1 : sorted[0].key
}

짝수는 싫어요

나의 문제 풀이

문제 풀이에 필요한 개념

  • filter

피자 나눠 먹기1

나의 문제 풀이

문제 풀이에 필요한 개념

  • 삼항연산자
  • 나머지 연산자 %

피자 나눠 먹기2

나의 문제 풀이

func solution(_ n:Int) -> Int {
    
    // 나눠먹는 사람의 수가 1인 경우
    if n == 1 {
        return 1
    }
    
    // 나눠먹는 사람의 수가 6의 배수인 경우
    if n % 6 == 0 {
        return n / 6
    }
    
    // 그 외 경우
    var sixDivisor = [1, 2, 3, 6] // 6의 약수
    var nDivisor = [n]
    
    // n의 약수 구하는 단계
    for i in 1...(n/2) {
       if n % i == 0 {
         nDivisor.append(i)
       }
    }
              
    // 6과 n의 최대 공약수 구하는 단계
    let gcd = nDivisor.filter {
        sixDivisor.contains($0)
    }.max() ?? 1
                
    return n / gcd
}

문제 풀이에 필요한 개념

  • 비교 연산자 ==
  • 나머지 연산자 %
  • 나눗셈 연산자 /
  • 병합 연산자 ??
  • filter
  • contains()
  • max()

다른 사람 풀이

func solution(_ n:Int) -> Int {
    var answer = 1
    while (answer * 6) % n != 0 {
        answer += 1
    }

    return answer
}

피자 나눠 먹기3

나의 문제 풀이

문제 풀이에 필요한 개념

  • 연산자

배열의 평균값

나의 문제 풀이

문제 풀이에 필요한 개념

  • reduce
  • 형변환

옷가게 할인 받기

나의 문제 풀이

문제 풀이에 필요한 개념

  • 범위 연산자
  • 할인률

아이스 아메리카노

나의 문제 풀이

문제 풀이에 필요한 개념

  • 연산자
  • 할인률

나이 출력

나의 문제 풀이

문제 풀이에 필요한 개념

  • 나이 계산

배열 뒤집기

나의 문제 풀이

import Foundation

// reverse() 사용 시, 배열을 변경시킴 (reverse()는 mutating임)
func solution(_ num_list:[Int]) -> [Int] {
    var result = num_list
    result.reverse()
    return result
}

문제 풀이에 필요한 개념

  • reverse()

다른 사람 풀이

// reversed()를 사용하면 매개변수로 받아오는 배열을 바꾸지 않고 새 배열을 반환함
func solution(_ numList: [Int]) -> [Int] { numList.reversed() }

문자열 뒤집기

나의 문제 풀이

import Foundation

func solution(_ my_string:String) -> String {
    // 문자열을 배열로 만들어 뒤집은 뒤, joined 메서드를 이용해 배열을 합쳐줌
    let result = my_string.map { String($0) }.reversed().joined(separator: "")

    return result
}

문제 풀이에 필요한 개념

  • map
  • reversed()
  • joined(separator:)

다른 사람 풀이

// string에서도 reversed() 사용 가능함
func solution(_ myString: String) -> String { String(myString.reversed()) }

직삼각형 출력하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • components(separatedBy:)

짝수 홀수 개수

나의 문제 풀이

문제 풀이에 필요한 개념

  • components(separatedBy:)

문자 반복 출력하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • String(repeating: , count:)

특정 문자 제거하기

나의 문제 풀이

다른 사람 풀이

import Foundation

func solution(_ my_string:String, _ letter:String) -> String {
    // 문자열을 배열로 바꾼 후 filter를 이용해 letter가 아닌 것만 추출함 
    var result = Array(my_string).filter{ String($0) != letter }
    
    // result는 ['String.Element' (aka 'Character')] 타입이라 joined()를 사용하기 위해 string 배열로 바꿔 줌
    return result.map {String($0)}.joined()
}

문제 풀이에 필요한 개념

  • filter
  • map
  • joined()

다른 사람 풀이

// string에서도 filter 사용 가능함
import Foundation

func solution(_ my_string:String, _ letter:String) -> String {
    return my_string.filter{String($0) != letter}
}
// 정규식 사용
import Foundation

func solution(_ myString: String, _ letter: String) -> String {
    return try! NSRegularExpression(pattern: letter).stringByReplacingMatches(in: myString, range: NSMakeRange(0, myString.count), withTemplate: "")
}
// replacingOccurrences 메서드 사용
import Foundation

func solution(_ my_string:String, _ letter:String) -> String {
    return my_string.replacingOccurrences(of: letter, with: "")
}

각도기

나의 문제 풀이

문제 풀이에 필요한 개념

  • if-else

양꼬치

나의 문제 풀이

문제 풀이에 필요한 개념

  • 사칙 연산

짝수의 합

나의 문제 풀이

import Foundation

func solution(_ n:Int) -> Int {
    var sum = 0
    // 0부터 n까지 반복문을 돌려서 2로 나눈 나머지가 0이 아닌 것만 sum에 더해줌
    (0...n).forEach { num in
      if num % 2 == 0 {
         sum += num
      }
    }
    return sum
}

문제 풀이에 필요한 개념

  • forEach
  • 사칙 연산

다른 사람 풀이

// 고차함수 사용
func solution(_ n: Int) -> Int { (0...n).filter { $0 % 2 == 0 }.reduce(0, +) }
// where절 사용
import Foundation

func solution(_ n:Int) -> Int {
    var result = 0
    for i in 1...n where i % 2 == 0 {
        result += i
    }
    return result
}

배열 자르기

나의 문제 풀이

import Foundation

func solution(_ numbers:[Int], _ num1:Int, _ num2:Int) -> [Int] {
    var result = [Int]()
    // 범위만큼 for문 돌려서 result에 해당 요소 추가
    for index in (num1...num2) {
       result.append(numbers[index])
    }
    return result
}

문제 풀이에 필요한 개념

  • 배열의 append()

다른 사람 풀이

// map 이용
import Foundation

func solution(_ numbers:[Int], _ num1:Int, _ num2:Int) -> [Int] {
    return (num1...num2).map{numbers[$0]}
}
// Array SubSequence 이용
import Foundation

func solution(_ numbers:[Int], _ num1:Int, _ num2:Int) -> [Int] {
    return Array(numbers[num1...num2])
}

외계행성의 나이

나의 문제 풀이

import Foundation

func solution(_ age:Int) -> String {
    let alienAge = [
        "0": "a", 
        "1": "b", 
        "2": "c", 
        "3": "d", 
        "4": "e", 
        "5": "f", 
        "6": "g", 
        "7": "h", 
        "8": "i", 
        "9": "j"
    ]
    var result = ""
    
    // age 문자열에 요소를 하나씩 가져와 alienAge의 key 값으로 넣어줌
    for i in String(age) {
        result += alienAge[String(i)]! 
    }
    
    return result
}

문제 풀이에 필요한 개념

  • 사전(Dictionary) 타입

다른 사람 풀이

// asciiValue를 이용해 a의 아스키 번호 찾는 형태
import Foundation

func solution(_ age:Int) -> String {
    var result = ""
    let startAscii = Character("a").asciiValue!
    String(age).forEach { 
        result.append(String(UnicodeScalar(startAscii + UInt8(String($0))!)))
    }
    return result
}
// UnicodeScalar 이용
import Foundation

func solution(_ age:Int) -> String {
    return String(age).reduce("") { $0 + String(UnicodeScalar(97 + Int(String($1))!)!)
    }
}

진료 순서 정하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • sorted(by:)
  • 반복문

다른 사람 풀이

func solution(_ e: [Int]) -> [Int] { e.map { e.sorted(by: >).firstIndex(of: $0)! + 1 } }

순서쌍의 개수

나의 문제 풀이

문제 풀이에 필요한 개념

  • map
  • 사칙연산

개미군단

나의 문제 풀이

문제 풀이에 필요한 개념

  • 사칙연산

모스부호 1

나의 문제 풀이

문제 풀이에 필요한 개념

  • split(separator:)
  • map
  • joined(separator:)

가위 바위 보

나의 문제 풀이

문제 풀이에 필요한 개념

  • map
  • swift-case

구슬을 나누는 경우의 수

나의 문제 풀이

import Foundation

// n! 을 구해주는 메서드
func factorial(_ number: Int) -> Double {
    var result = 1.0
    for i in 1...number {
        result *= Double(i)
    }
    
    return result
}

func solution(_ balls:Int, _ share:Int) -> Int {
    // balls과 share의 개수가 같다면 경우의 수는 1가지 
    if balls == share {
        return 1
    }

    // 조합 공식 사용해서 경우의 수 구함
    return Int(round(factorial(balls) / (factorial(balls-share) * factorial(share))))
}

문제 풀이에 필요한 개념

  • round()
  • 조합

다른 사람 풀이

// 재귀함수 이용
import Foundation

func dfs(_ n : Int, _ r: Int) -> Int {
  if n == r { return 1 }

  if r == 1 { return n }

  return dfs(n-1, r-1) + dfs(n-1, r)
}

func solution(_ balls:Int, _ share:Int) -> Int {
    return dfs(balls, share)
}

점의 위치 구하기

나의 문제 풀이

import Foundation

func solution(_ dot:[Int]) -> Int {
    if dot[0] > 0 && dot[1] > 0 { // 1사분면에 있는지 구함
        return 1
    } else if dot[0] < 0 && dot[1] > 0 { // 2사분면에 있는지 구함
        return 2
    } else if dot[0] < 0 && dot[1] < 0 { // 3사분면에 있는지 구함
        return 3
    }
    return 4
}

문제 풀이에 필요한 개념

  • if-else
  • 논리, 비교 연산자

다른 사람 풀이

// swift-case 이용
import Foundation

func solution(_ dot:[Int]) -> Int {
    switch (dot[0], dot[1]) {
    case (0..., 0...): return 1
    case (...0, 0...): return 2
    case (...0, ...0): return 3
    case (0..., ...0): return 4
    default: return 0
    }
}

2차원으로 만들기

나의 문제 풀이

문제 풀이에 필요한 개념

  • stride(from:, through:, by:)
  • 배열의 SubSequence

공 던지기

나의 문제 풀이

import Foundation

func solution(_ numbers:[Int], _ k:Int) -> Int {
    var result = -1 // 아래 반복문에서 첫번째로 던지는 번호가 1이 되기 위해 시작을 -1로 함 
    
    for i in 0..<k {
        result += 2 // 공은 옆옆 사람에게 던지기 때문에, 현재 던지는 번호에서 +2를 해주면 다음에 공을 던지는 번호를 구할 수 있음 
        
        if result > numbers.count { // 공을 던져야하는 번호가 최대 번호(numbers.count)보다 클 경우 처리하는 부분
            result %= numbers.count
        } 
    }
    return result
}

문제 풀이에 필요한 개념

  • 반복문
  • 사칙연산

다른 사람 풀이

import Foundation

func solution(_ numbers:[Int], _ k:Int) -> Int {
    return numbers[((k-1)*2) % numbers.count]
}

배열 회전시키기

나의 문제 풀이

import Foundation

func solution(_ numbers:[Int], _ direction:String) -> [Int] {
     var nums = numbers
    
    // 오른쪽 방향으로 한 칸씩 움직이는 경우
    // - 맨 오른쪽에(배열의 마지막)에 있던 것이 맨 왼쪽으로(배열의 첫번째) 이동함
    // - `removeLast()`를 호출하면 배열의 마지막 요소를 지우고 지운 값을 반환해 줌
    // - 배열 연산을 통해 마지막 요소와 마지막 요소를 제한 배열을 더해줌
    if direction == "right" {
        return [nums.removeLast()] + nums
    }
    
    // 왼쪽 방향으로 한 칸씩 움직이는 경우
    // - 맨 왼쪽(배열의 첫번째)에 있던 것이 맨 오른쪽으로(배열의 마지막) 이동함
    // - `removeFirst()`를 호출하면 배열의 첫번째 요소를 지우고 지운 값을 반환해 줌
    // - 배열 연산을 통해 첫번째 요소를 제한 배열과 첫번째 요소를 더해줌
    let first = [nums.removeFirst()]
    return nums + first
}

문제 풀이에 필요한 개념

  • removeLast()
  • removeFirst()

다른 사람 풀이

import Foundation

func solution(_ numbers:[Int], _ direction:String) -> [Int] {
    var nums = numbers
    direction == "right" ? nums.insert(nums.removeLast(), at: 0) : nums.append(nums.removeFirst())
    return nums
}

주사위의 개수

나의 문제 풀이

// (가로/n) * (세로/n) * (높이/n) 하면 box에 들어갈 수 있는 최대 주사위 개수를 구할 수 있음
import Foundation

func solution(_ box:[Int], _ n:Int) -> Int {
    let result = box.reduce(1) { x, y in // x: 이전에 계산한 값, y: 현재 box의 요소  
        y/n * x
    }
    return result
}

문제 풀이에 필요한 개념

  • reduce

다른 사람 풀이

import Foundation

func solution(_ box:[Int], _ n:Int) -> Int {
    return box.map { $0 / n }.reduce(1, *)
}

합성수 찾기

나의 문제 풀이

문제 풀이에 필요한 개념

  • 반복문

최댓값 만들기 1

나의 문제 풀이

문제 풀이에 필요한 개념

  • sort(by:)

팩토리얼

나의 문제 풀이

문제 풀이에 필요한 개념

  • 팩토리얼

모음 제거

나의 문제 풀이

문제 풀이에 필요한 개념

  • filter
  • contains()

문자열 정렬하기 1

나의 문제 풀이

import Foundation

func solution(_ my_string:String) -> [Int] {
    // Int형으로 변환할 수 없는 String은 nil값이 되는데 compactMap은 nil값을 제외한 걸 반환해줌 (숫자만 추출 가능)
    let result = my_string.compactMap { Int(String($0)) }.sorted() 
    return result
}

문제 풀이에 필요한 개념

  • compactMap
  • sorted()

다른 사람 풀이

import Foundation

func solution(_ myString: String) -> [Int] {
    return try! NSRegularExpression(pattern: "[A-Z|a-z]").stringByReplacingMatches(in: myString, range: NSMakeRange(0, myString.count), withTemplate: "").map { Int(String($0)) ?? 0 }.sorted()
}

숨어있는 숫자의 덧셈 1

나의 문제 풀이

import Foundation

func solution(_ my_string:String) -> Int {
    var result = 0
    
    // my_string에서 숫자인것만 추출하는 과정
    let numbers = my_string.filter { 
        $0.isNumber //isNumber: 숫자면 true, 아니면 false 반환함
    }
    
    // 숫자를 더하는 과정
    numbers.forEach {
        result += Int(String($0))!
    }
    return result
}

문제 풀이에 필요한 개념

  • filter
  • isNumber
  • forEach

다른 사람 풀이

import Foundation

func solution(_ my_string:String) -> Int {
     return my_string.compactMap{Int(String($0))}.reduce(0,+)
}

소인수분해

나의 문제 풀이

문제 풀이에 필요한 개념

  • 소인수 구하는 법

컨트롤 제트

나의 문제 풀이

문제 풀이에 필요한 개념

  • components(separatedBy:)

배열 원소의 길이

나의 문제 풀이

문제 풀이에 필요한 개념

  • map
  • count

직사각형 넓이 구하기

나의 문제 풀이

import Foundation

func solution(_ dots:[[Int]]) -> Int {
    let dot = dots[0] // 기준점
    var width = 0 // 가로
    var height = 0 // 세로
    for i in (0..<dots.count) {
        if i != 0 {
            // 기준점과 x좌표가 같은 점을 찾아서 높이를 구함
            if dot[0] == dots[i][0] {
                height = abs(dot[1] - dots[i][1])
            }
            
            // 기준점과 y좌표가 같은 점을 찾아서 가로를 주함
            if dot[1] == dots[i][1] {
                width = abs(dot[0] - dots[i][0])
            }
        }
    }
    return width * height
}

문제 풀이에 필요한 개념

  • 좌표평면 읽는 법

다른 사람 풀이

import Foundation

func solution(_ dots:[[Int]]) -> Int {
    let dots = dots.sorted(by: { ($0[0], $0[1]) < ($1[0], $1[1]) })
    return (dots.last![0] - dots.first![0]) * (dots.last![1] - dots.first![1])
}

캐릭터의 좌표

나의 문제 풀이

문제 풀이에 필요한 개념

  • if-esle
  • 논리연산자

최댓값 만들기 2

나의 문제 풀이

import Foundation

func solution(_ numbers:[Int]) -> Int {
    // 음수가 있을 경우를 대비해, 음수 중 가장 작은 값(절댓값이 가장 큰) 2개를 곱함
    var nums = numbers.sorted()
    let n1 = nums[0] * nums[1]
    
    // 양수 중 가장 큰 값 2개를 곱함
    nums.reverse()
    let n2 = nums[0] * nums[1]
    
    // 음수의 곱셈과 양수의 곱셈 중 큰 값을 반환
    return max(n1, n2)
}

문제 풀이에 필요한 개념

  • sorted()
  • reverse()

다른 사람 풀이

// sorted 한번만 사용
import Foundation

func solution(_ numbers:[Int]) -> Int {
    var numbers = numbers.sorted()
    return max(numbers[0] * numbers[1], numbers[numbers.count-1] * numbers[numbers.count - 2])
}

다항식 더하기

나의 문제 풀이

import Foundation

func solution(_ polynomial:String) -> String {
    var num = 0
    var xNum = 0
    let str = polynomial.components(separatedBy: " + ")

    // x의 계수를 더해주는 과정
    str.filter {
        $0.contains("x")
    }.forEach {
        if $0.count > 1 {
            // `(숫자)x` 는 count가 1보다 크므로 x를 제외한 숫자만 추출하여 더함
            xNum += Int(Array($0.map {String($0)}[0..<$0.count-1]).joined())!
        } else {
            // `x` 는 count 가 1이고, 1이 생략된 형태이므로 그냥 1을 더함 
            xNum += 1
        }
    }

    // 상수항을 더해주는 과점
    str.filter {
        !$0.contains("x")
    }.forEach {
        num += Int($0)!
    }
    
    // 경우의 수에 따른 수식을 반환함
    if xNum == 0 {
        // 일차항이 없고 상수항만 있는 경우
        return "\(num)"
    } else if num == 0 {
        // 상수항이 없고 일차항의 계수가 1인 경우
        if xNum == 1 {
            return "x"
        }
        // 상수항이 없고 일차항의 계수가 1보다 큰 경우
        return "\(xNum)x"
    } else {
        // 상수항이 있고 일차항의 계수가 1인 경우
        if xNum == 1 {
            return "x + \(num)"
        }
        // 상수항이 있고 일차항의 계수가 1보다 큰 경우
        return "\(xNum)x + \(num)"
    }
}

문제 풀이에 필요한 개념

-filter -contains()

다른 사람 풀이

func solution(_ polynomial: String) -> String {
    var xCount = 0
    var num = 0

    for s in polynomial.split(separator: " ") {
        if s.contains("x") {
            xCount += (s == "x" ? 1 : (Int(s.replacingOccurrences(of: "x", with: "")) ?? 0))
        } else if s != "+" {
            num += Int(s) ?? 0
        }
    }
    return (xCount != 0 ? xCount > 1 ? "\(xCount)x" : "x" : "") + (num != 0 ? "\((xCount != 0 ? " + " : ""))\(num)" : xCount == 0 ? "0" : "")
}

숨어있는 숫자의 덧셈 2

나의 문제 풀이

import Foundation

func solution(_ my_string:String) -> Int {
    var result = 0
    
    // 연속된 숫자를 판별하기 위해 문자는 공백(" ")으로 처리한 후 없앰
    // ex) "aAb1B2cC34oOp"
    //   -> 문자 공백 처리 : [" ", " ", " ", "1", " ", "2", " ", " ", "3", "4", " ", " ", " "]
    //   -> 배열에서 문자열로 만들기 :"   1 2  34   " (joined 과정안하면 splited 할때 문자열이 아닌 ArraySlice 타입이 됨)
    //   -> 공백으로 잘라 줌 : ["1", "2", "34"]
    let numbers = my_string.map { s -> String in
        if s.isNumber {
            return String(s)
        }
        return " "
    }.joined(separator: "").split(separator: " ")

    numbers.forEach({
        result += Int($0)!
    })
    
    return result
}

문제 풀이에 필요한 개념

  • isNumber
  • joined(separator:)
  • split(separator:)

다른 사람 풀이

import Foundation

func solution(_ my_string:String) -> Int {
    let pattern = #"\d+"#
    let regex = try! NSRegularExpression(pattern: pattern)
    let range = NSRange(my_string.startIndex..<my_string.endIndex, in: my_string)
    let matches = regex.matches(in: my_string, range: range)

    return matches.reduce(0) { $0 +
        Int(NSString(string: my_string).substring(with: $1.range))!
    }
}
import Foundation

func solution(_ my_string:String) -> Int {
    return my_string.replacingOccurrences(of: "[a-zA-Z]", with: " ", options: .regularExpression).split(separator: " ", omittingEmptySubsequences: true).map { Int($0) ?? 0 }.reduce(0, +)
}

안전지대

나의 문제 풀이

문제 풀이에 필요한 개념

  • 논리연산자

삼각형의 완성조건 2

나의 문제 풀이

import Foundation

func solution(_ sides:[Int]) -> Int {
    var result = 0 
    
    // 가장 긴 변이 sides안에 있는 경우 
    for _ in (sides.max()! - sides.min()! + 1)..<(sides.max()!) {
        result += 1
    }

    // 가장 긴 변이 sides안에 없는 경우
    for _ in (sides.max()!)..<(sides.max()! + sides.min()!) {
        result += 1
    }
    
    return result
}

문제 풀이에 필요한 개념

  • max()
  • min()

다른 사람 풀이

import Foundation

func solution(_ sides:[Int]) -> Int {
    return sides[0]+sides[1]-abs(sides[0]-sides[1])-1
}

외계어 사전

나의 문제 풀이

문제 풀이에 필요한 개념

  • filter
  • contains()
  • sorted()
  • joined(separator:)

저주의 숫자 3

나의 문제 풀이

문제 풀이에 필요한 개념

  • 반복문
  • 논리 연산자
  • contains()

평행

나의 문제 풀이

문제 풀이에 필요한 개념

  • abs()
  • 사칙 연산자
  • 기울기 공식

겹치는 선분의 길이

나의 문제 풀이

문제 풀이에 필요한 개념

  • 반복문
  • 논리 연산자
  • 삼항 연산자

유한소수 판별하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • 형변환
  • 삼항 연산자
  • 유한소수 특징

특이한 정렬

나의 문제 풀이

문제 풀이에 필요한 개념

  • 반복문
  • 논리 연산자

다른 사람 풀이

import Foundation

func solution(_ numlist:[Int], _ n:Int) -> [Int] {
    return numlist.sorted(by: { (abs($0 - n), -$0) < (abs($1 - n), -$1) })
}

등수 매기기

나의 문제 풀이

문제 풀이에 필요한 개념

  • compactMap
  • contains()

다른 사람 풀이

import Foundation

func solution(_ score:[[Int]]) -> [Int] {
    var answer: [Int] = []
    let total = score.map { $0.reduce(0, +) }
    for tmp in total {
        answer.append(total.filter { $0 > tmp }.count + 1)
    }

    return answer
}

로그인 성공

나의 문제 풀이

문제 풀이에 필요한 개념

  • 반복문
  • 논리 연산자

다른 사람 풀이

import Foundation

func solution(_ id_pw:[String], _ db:[[String]]) -> String {
    return db.contains(id_pw) ? "login"
    : db.map{$0[0]}.contains(id_pw[0]) ? "wrong pw"
    : "fail"
}

치킨 쿠폰

나의 문제 풀이

문제 풀이에 필요한 개념

  • 반복문
  • 조건문
import Foundation

func solution(_ chicken:Int) -> Int {
    var chicken = chicken
    var service = 0
    var coupon = 0

    while chicken != 0 {
        coupon += chicken
        service += coupon / 10
        chicken = coupon / 10
        coupon %= 10
    }

    return service
}

이진수 더하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • init(_:radix:)

A로 B 만들기

나의 문제 풀이

문제 풀이에 필요한 개념

  • map
  • sorted()

k의 개수

나의 문제 풀이

문제 풀이에 필요한 개념

  • filter

중복된 문자 제거

나의 문제 풀이

문제 풀이에 필요한 개념

  • forEach
  • cotains()

삼각형의 완성조건 1

나의 문제 풀이

문제 풀이에 필요한 개념

-sorted


가까운 수

나의 문제 풀이

문제 풀이에 필요한 개념

  • sorted()
  • abs()

다른 사람 풀이

import Foundation

func solution(_ array:[Int], _ n:Int) -> Int {
    return array.min(by: { (abs($0 - n), $0) < (abs($1 - n), $1) })!
}

369게임

나의 문제 풀이

문제 풀이에 필요한 개념

  • filter
  • contains()

암호 해독

나의 문제 풀이

문제 풀이에 필요한 개념

  • map

대문자와 소문자

나의 문제 풀이

문제 풀이에 필요한 개념

  • map
  • lowercased()
  • uppercased()

영어가 싫어요

나의 문제 풀이

문제 풀이에 필요한 개념

  • map
  • joined(separator:)
  • switch-case

다른 사람 풀이

import Foundation

func solution(_ numbers:String) -> Int64 {
    let result = numbers
        .replacingOccurrences(of: "zero", with: "0")
        .replacingOccurrences(of: "one", with: "1")
        .replacingOccurrences(of: "two", with: "2")
        .replacingOccurrences(of: "three", with: "3")
        .replacingOccurrences(of: "four", with: "4")
        .replacingOccurrences(of: "five", with: "5")
        .replacingOccurrences(of: "six", with: "6")
        .replacingOccurrences(of: "seven", with: "7")
        .replacingOccurrences(of: "eight", with: "8")
        .replacingOccurrences(of: "nine", with: "9")

    return Int64(result)!
}
import Foundation

func solution(_ numbers:String) -> Int64 {
    let alphabet = ["zero":0, "one":1, "two":2, "three":3, "four":4, "five":5, "six":6, "seven":7, "eight":8, "nine":9]
    var result = ""
    var number = ""
    for n in numbers {
        number += String(n)
        if alphabet.keys.contains(number) {
            result += String(alphabet[number]!)
            number = ""
        }
    }
    return Int64(result)!
}

인덱스 바꾸기

나의 문제 풀이

문제 풀이에 필요한 개념

  • map

다른 사람 풀이

func solution(_ myString: String, _ num1: Int, _ num2: Int) -> String {
    var array = ArraySlice(myString)

    array.swapAt(num1, num2)
    return array.map { String($0) }.joined()
}

한 번만 등장한 문자

나의 문제 풀이

문제 풀이에 필요한 개념

  • map
  • filter
  • joined(separator:)
  • sorted()

다른 사람 풀이

func solution(_ s: String) -> String {
    return Dictionary(grouping: Array(s).map(String.init), by: { $0 }).filter { $0.value.count <= 1 }
        .map { $0.key }
        .sorted(by: <)
        .joined()
}

약수 구하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • filter
  • sorted()

편지

나의 문제 풀이

문제 풀이에 필요한 개념

  • Array

가장 큰 수 찾기

나의 문제 풀이

문제 풀이에 필요한 개념

  • max()
  • firstIndex(of:)

다른 사람 풀이

import Foundation

func solution(_ array:[Int]) -> [Int] {
    let max = array.enumerated().max(by: { $0.element < $1.element })!
    return [max.element, max.offset]
}

문자열 계산하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • stride(from:, to:, by:)

다른 사람 풀이

func solution(_ myString: String) -> Int {
    return myString.replacingOccurrences(of: "- ", with: "-")
        .replacingOccurrences(of: "+", with: "")
        .trimmingCharacters(in: .whitespacesAndNewlines)
        .split(separator: " ")
        .map { Int($0)! }
        .reduce(0, +)
}

배열의 유사도

나의 문제 풀이

문제 풀이에 필요한 개념

  • intersection()

숫자 찾기

나의 문제 풀이

문제 풀이에 필요한 개념

  • map
  • contains

다른 사람 풀이

func solution(_ num: Int, _ k: Int) -> Int { Array("-\(num)").firstIndex(of: Character(String(k))) ?? -1 }

n의 배수 고르기

나의 문제 풀이

문제 풀이에 필요한 개념

  • filter

자릿수 더하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • 반복문

다른 사람 풀이

import Foundation

func solution(_ n:Int) -> Int {
    return String(n).map{Int(String($0))! }.reduce(0,+)
}

OX퀴즈

나의 문제 풀이

문제 풀이에 필요한 개념

  • split(separator:)

다른 사람 풀이

import Foundation

func solution(_ quiz:[String]) -> [String] {
    var answer: [String] = []

    for quiz in quiz {
        let qArray = quiz.trimmingCharacters(in: .whitespaces).components(separatedBy: " ").map{String($0)}
        let X = Int(qArray[0])!
        let op = qArray[1]
        let Y = Int(qArray[2])!
        let Z = Int(qArray[4])!

        let result = op == "+" ? X + Y : X - Y

        answer.append(result == Z ? "O" : "X")
    }
    return answer
}

문자열안에 문자열

나의 문제 풀이

문제 풀이에 필요한 개념

  • components(separatedBy:)
  • joined()

다른 사람 풀이

func solution(_ str1: String, _ str2: String) -> Int { str1.contains(str2) ? 1 : 2 }

제곱수 판별하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • 반복문
  • 사칙연산

다른 사람 풀이

import Foundation

func solution(_ n: Int) -> Int { sqrt(Double(n)) == floor(sqrt(Double(n))) ? 1 : 2 }

세균 증식

나의 문제 풀이

문제 풀이에 필요한 개념

  • forEach

다른 사람 풀이

import Foundation

func solution(_ n:Int, _ t:Int) -> Int {
    n*Int(pow(Float(2) , Float(t)))
}

문자열 정렬하기 (2)

나의 문제 풀이

문제 풀이에 필요한 개념

  • lowercased()
  • sorted(by:)

7의 개수

나의 문제 풀이

문제 풀이에 필요한 개념

  • map
  • filter

잘라서 배열로 저장하기

나의 문제 풀이

문제 풀이에 필요한 개념

  • 사칙연산
  • ArraySlice

문자열 밀기

나의 문제 풀이

문제 풀이에 필요한 개념

  • joined(separator:)
  • removeLast()
  • insert(, at:)

다른 사람 풀이

import Foundation

func solution(_ A:String, _ B:String) -> Int {
    let arr = (A+A).components(separatedBy: B)
    return arr.count == 1 ? -1 : arr[1].count
}

종이 자르기

나의 문제 풀이


연속된 수의 합

나의 문제 풀이

문제 풀이에 필요한 개념

  • map

다음에 올 숫자

나의 문제 풀이

문제 풀이에 필요한 개념

  • 사칙연산
  • 등비,등차 수열

다른 사람 풀이

import Foundation

func solution(_ common:[Int]) -> Int {
    return common.last! == common.first! + (common[1] - common[0]) * (common.count - 1)
    ? common.last! + common[1] - common[0]
    : Int(Double(common.last!) * (Double(common[1]) / Double(common[0])))
}

옹알이(1)

나의 문제 풀이

문제 풀이에 필요한 개념

  • reduce
  • components(separatedBy:)
  • trimmingCharacters
Clone this wiki locally