오늘치는 단 한문제!

1. 조건에 맞게 수열 변환하기 2

반복해서 배열에 대한 계산을 하는 문제인데...

  func arrProc(_ arr: [Int]) -> [Int] {
    
//    원소에 대해 값이 50보다 크거나 같은 짝수라면 2로 나누고, 50보다 작은 홀수라면 2를 곱하고 다시 1을 더합니다.
//    보다 크거나가 아니라 이상의 짝수라는건가?
    var result: [Int] = []
    for x in arr {
      let isEven: Bool = x % 2 == 0
      if x >= 50, isEven {
        result.append(x / 2)
        continue
      }
      if x < 50, !isEven {
        result.append(x * 2 + 1)
        continue
      }
      result.append(x)
    }
    return result
  }

  var befor: [Int] = arr
  
  for i in 0 ..< Int.max / 2 {
    let response = arrProc(befor)
    if befor == response {
      return i
    }
    befor = response
  }

  return -1

항상 타인답보면 이걸 이렇게나 줄일 수 있구나 하고 놀란다

for 조건문이 좀 마음에 걸리긴한데 문제에서 통과해버렸다

그리고 배열 비교를 == 로 했으나 이거는 좀 마음에 안든다 c스타일이였다면 이건 주소값 비교가 되서 무조건 false가 나오는거라 다르다는점은 인지하고 있고 오해를 방지하기위해 따로 다른걸로 비교하는게 좋지 않을까 하고있지만 귀찮아서 그냥 사용중이다 

그리고 타인답에 elementsEqual 라는게 사용되는걸 발견했다 이런 멋진게 있었다니 

반응형

오늘은 12,13일차

 

1. 배열 조각하기

  var copyArr: [Int] = arr
  for (i, target) in query.enumerated() {
    guard target < copyArr.count else {return []}
    let subArr =  i % 2 == 0 ? copyArr[...target] : copyArr[target...]
    copyArr = Array<Int>(subArr)
  }
  
  return copyArr

제목처럼 배열 깍아내는 문제

 

2. 리스트자르기

배열 순환문제

  func default_slicer(num_list:[Int], start s: Int, end e: Int, interval term: Int = 1) -> [Int] {
    guard s >= 0, e >= s, e < num_list.count, term < num_list.count else { return [] }
 
    let index_arr = Array(stride(from: s, through: e, by: term))
    return index_arr.map { index in
      num_list[index]
    }
  }
  
  guard slicer.count == 3 else { return [] }
  
  let a: Int = slicer[0], b: Int = slicer[1], c: Int = slicer[2]
  var result: [Int] = []
  
  switch n {
  case 1 : result = default_slicer(num_list: num_list, start: 0, end: b)
  case 2:  result = default_slicer(num_list: num_list, start: a, end: num_list.count - 1)
  case 3:  result = default_slicer(num_list: num_list, start: a, end: b)
  case 4:  result = default_slicer(num_list: num_list, start: a, end: b, interval: c)
  default: return []
  }
  
  return result

엄청 간단한 문제라고 생각했으나 문제를 잘못 생각해서 찾는데 몇 시간 걸린거같다.

아무리 생각해도 잘못된 부분이 없었는데 문제를 잘못 읽고 이해했다.

입력 제한을

  • 0 ≤ a ≤ b ≤ num_list의 길이 - 1

라는걸 a는 시작인덱스 b는 끝인덱스니 b는 항상 a보다 크겠지 라고 이해해버려서 s >= 0, e >s 라고 써버리고 이걸 찾지 못해서 고생많이했다.

입력제한을 따로 체크 하는게 영 귀찮아져서 대충했더니 이런 실수가 발생... 다음 문제부턴 입력제한을 바로 코드위 주석으로 달아두고 작성해야겠다.

아래는 내가 쓴 테스트 코드 공유.

print(solution(4,  [1, 5, 2], [1, 2, 3, 4, 5, 6, 7, 8, 9] ) ==  [2, 4, 6])
print(solution(4, [2, 7, 3], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) == [2, 5])
print(solution(4, [1, 5, 2], [4, 5, 6, 7, 8, 9]) == [5, 7, 9])
print(solution(1, [1, 5, 2], [1, 2, 3, 4, 5, 6, 7, 8, 9]) == [1, 2, 3, 4, 5, 6])
print(solution(2, [0, 1, 1], [10, 8, 6, 4, 2]) == [10, 8, 6, 4, 2])


print(solution(1, [0, 3, 1], [1, 2, 3, 4, 5]) == [1, 2, 3, 4]); // [1, 2, 3, 4]
print(solution(1, [0, 2, 1], [10, 20, 30, 40]) == [10, 20, 30]); // [10, 20, 30]
print(solution(1, [0, 1, 1], [5, 10, 15]) == [5, 10]); // [5, 10]
print(solution(1, [0, 4, 1], [7, 14, 21, 28, 35, 42]) == [7, 14, 21, 28, 35]); // [7, 14, 21, 28, 35]
print(solution(1, [0, 5, 1], [2, 4, 6, 8, 10, 12]) == [2, 4, 6, 8, 10, 12]); // [2, 4, 6, 8, 10, 12]

print(solution(2, [1, 0, 0], [1, 2, 3, 4, 5]) == [2, 3, 4, 5]); // [2, 3, 4, 5]
print(solution(2, [2, 0, 0], [10, 20, 30, 40]) == [30, 40]); // [30, 40]
print(solution(2, [1, 0, 0], [5, 10, 15]) == [10, 15]); // [10, 15]
print(solution(2, [3, 0, 0], [7, 14, 21, 28, 35, 42]) == [28, 35, 42]); // [28, 35, 42]
print(solution(2, [4, 0, 0], [2, 4, 6, 8, 10, 12]) == [10, 12]); // [10, 12]

print(solution(3, [1, 3, 0], [1, 2, 3, 4, 5]) == [2, 3, 4]); // [2, 3, 4]
print(solution(3, [0, 2, 0], [10, 20, 30, 40]) == [10, 20, 30]); // [10, 20, 30]
print(solution(3, [1, 1, 0], [5, 10, 15]) == [10]); // [10]
print(solution(3, [2, 4, 0], [7, 14, 21, 28, 35, 42]) == [21, 28, 35]); // [21, 28, 35]
print(solution(3, [3, 5, 0], [2, 4, 6, 8, 10, 12]) == [8, 10, 12]); // [8, 10, 12]

print(solution(4, [1, 4, 2], [1, 2, 3, 4, 5]) == [2, 4]); // [2, 4]
print(solution(4, [0, 3, 2], [10, 20, 30, 40]) ==  [10, 30]); // [10, 30]
print(solution(4, [0, 2, 1], [5, 10, 15]) ==  [5, 10, 15]); // [5, 10, 15]
print(solution(4, [1, 5, 2], [7, 14, 21, 28, 35, 42]) == [14, 28, 42]); // [14, 28, 42]
print(solution(4, [2, 5, 2], [2, 4, 6, 8, 10, 12]) == [6, 10]); // [6, 10]

따로 입력, 테스트에 대한 함수를 안만들어놔서 적는데 고생좀 했다

이번 기회로 하나 만들어둬야할까? 그건또 귀찮아서 모르겠다

 

3. 왼쪽 오른쪽

배열에서 원소 인덱스 찾기

  //  1 ≤ str_list의 길이 ≤ 20
  //  str_list는 "u", "d", "l", "r" 네 개의 문자열로 이루어져 있습니다.
  guard (1...20) ~= str_list.count else { return ["-1"] }
  let copy_arr = Array(str_list)
  
  let lIndex = str_list.firstIndex { $0 == "l" }
  let rIndex = str_list.firstIndex { $0 == "r" }
  
  // "l"이나 "r"이 없다면 빈 리스트를 return
  guard lIndex != nil || rIndex != nil else { return [] }
  let lValue = lIndex ?? str_list.count
  let rValue = rIndex ?? str_list.count
  
  if lValue < rValue {
    return copy_arr[..<lValue].map { $0 }
  } else if rValue < lValue {
    return copy_arr[(rValue + 1)...].map { $0 }
  }
  return ["error"]

그냥 둘다 찾아서 값 비교해줬다

 

끝!

어제치를 안해서 한주로 안끝나버렸다.

할일없어서 심심하면 진도좀 빼야지

반응형

기존대로 라면 하루에 day가 2일씩 열릴텐데 9일을 그냥 넘겨버렸다

이전에 미리 풀어놨던 문제들로 가득 차버리면 해당날짜가 된다해도 그냥 넘어가버리는듯하다

그래서 한문제만 적어야지 했던 포스트가 늘어나버리고...

1. qr code

문자열 순회

  var result: String = ""
  for (i, char) in Array<String.Element>(code).enumerated() {
    if i % q == r {
      result.append(String(char))
    }
  }
  return result
 

별 생각없이 배열로 만들고 돌렸는데

그냥 첫줄부터 filter로 빼서 반환해줬으면 두줄로 끝났을거같다

 

2. 문자 개수 세기

A~Z,a~z 의 알파벳 숫자 세는 문제

  let arr: [String.Element] = .init(my_string)
  var bigResult: [Int] = [], smallResult: [Int] = []
  let bigRange = UnicodeScalar("A").value...UnicodeScalar("Z").value
  for cValue in bigRange {
    let c: String = String(UnicodeScalar(cValue)!)
    let bigCount = arr.filter { String($0) == c }.count
    let smallCount = arr.filter { String($0) == c.lowercased()}.count
    bigResult.append(bigCount)
    smallResult.append(smallCount)
  }
  bigResult.append(contentsOf: smallResult)

알파벳의 범위를 만들어서 필터를 거치고 갯수를 해줬는데 그냥 배열을 미리 52개 만들고 문자열을 반복돌려서 count++ 해주는게 더 깔끔했을거같다

 

100여 문제가 반쯤 도전과제만 달성하고있는데 어느새 12문제만 남았다.

진행도로만 보면 이번주안에 기초트레이닝 문제는 다 끝나지 않을까?

끝나면 드디어 실 코딩 테스트 문제를!

반응형

24일날 시작한 기초 트레이닝이 27일까지 이어지고 day7,8의 란이 열렸다

1. 수열과 구간 쿼리 4

s,e,k 값이 주어질때 s~e 구간의 순회 문제.

  var copyArr = arr
  for query in queries {
    let s = query[0], e = query[1], k = query[2]
    for i in s...e {
      if i % k != 0 { continue }
      copyArr[i] += 1
    }
  }
  return copyArr

 

2. 배열 만들기 2

숫자 "0"과 "5"로만 이루어진 모든 정수를 오름차순으로 저장한 배열을 return

  let pattern: String = "^[0,5]*$"

  var result: [Int] = []
  for i in l ... r {
    let str: String = .init(i)
    if (str.range(of: pattern, options: .regularExpression) != nil) {
      result.append(i)
    }
  }
  return result.isEmpty ? [-1] : result

처음엔 5와 0으로된 이진법으로 계산해서 하려고했으나 잘 안풀려서 결국 그냥 모든 배열에서 필터하는 방법으로 변경

작성하고나니 필터함수로 썻으면 더 짧게 했을거같다

 

3. 배열 만들기 4

배열을 순회해서 필터링하기

var stk: [Int] = []
  var i: Int = 0
  
  while i < arr.count {
    if stk.isEmpty {
      stk.append(arr[i])
      i += 1
    } else if stk.last! < arr[i] {
      stk.append(arr[i])
      i += 1
    } else if stk.last! >= arr[i] {
      _ = stk.popLast()
    }
  }
  return stk

문제 지문 그대로 코드로 옴겼더니 좀 길어졌다 조건문 위 두개를 하나로 합칠수 있지않았을까

 

4. 주사위 게임 3

주사위 네개의 값이 주어졌을때 각각 계산하는게 달라지는 문제.

  var dice: [Int : Int] = [:]
  [a,b,c,d].forEach { num in
    if dice[num] == nil {
      dice[num] = 1
    } else {
      dice[num]! += 1
    }
  }
  
  if dice.count == 1 {
    return 1111 * a
  }
  
  if dice.count == 2 {
    var max: Int = 0, p: Int = 0, q: Int = 0
    
    for (key, value) in dice {
      if max < value {
        max = value
        p = key
      }
    }
    q = dice.keys.filter { key in
      key != p
    }.first!
    
    // 주사위가 3개가같을때와 2개가 같을때
    return max == 3 ? (10 * p + q) * (10 * p + q) : (p + q) * abs(p-q)
  }
  
  if dice.count == 3 {
    // 주사위 한쌍이 같고 나머지 달라
    var max: Int = 0, p: Int = 0
    
    for (key, value) in dice {
      if max < value {
        max = value
        p = key
      }
    }
    
    let res: [Int] =  dice.keys.filter { key in
      key != p
    }.map { $0 }
    
    guard res.count == 2 else { return -1 }
    return res[0] * res[1]
  }
  
  return min(a, b, c, d)

문제 순서대로 쭉 적어서 겹치는 부분이 좀 보인다. 반은 줄일 수 있을거같다 하지만 귀찮다 점수는 받았으니 괜찮겠지

 

5. 문자열 여러 번 뒤집기

원본 문자열과 문자열 인덱스 범위가 배열로 주어지고 각 인덱스 범위를 뒤집어서 출력하는 문제

  func reverse(_ str: String, _ s: Int, _ e: Int) -> String {
    var copy_arr = Array(str).map { String($0) }
    let target = copy_arr[s...e].map { $0 }
    for i in s...e {
      copy_arr[i] = target[e - i]
    }
    return copy_arr.joined()
  }
  
  var copy_str: String = my_string
  
  for q in queries {
    copy_str = reverse(copy_str, q[0], q[1])
  }
  return copy_str

이전에 비슷한 문제가 있어서 해당 코드를 reverse로 함수화해서 그대로 사용.

답을 내고 보니 replaceSubrange 라는걸 사용해서 문자열 수정해본다는게 잊고있었다.

 

아무튼 이렇게 8일치까지 끝

9일치는 이미 달성되어있고 10일치는 한문제니 다음 포스트는 한문제가 될것같다. 오늘 더이상 문제를 안푼다면 말이다

반응형

어제 기초 트레이닝 문제를 전부 끝내려했으나 하다 결국 질려서 day5,6이 열려버렸다... 

1. 코드 처리하기

주어지는 mode에 따라 글자를 파싱하는 문제

  let copyCode: [String.Element] = Array(code)
  var mode: Int = 0
  var ret: [String.Element] = []
  
  for (idx, char) in copyCode.enumerated() {
    if mode == 0 {
      if char == "1" {
        mode = 1
        continue
      }
      
      if (idx % 2 == 0) {
        ret.append(char)
      }
    } else {
      // mode == 1
      if char == "1" {
        mode = 0
        continue
      }
      if (idx % 2 != 0) {
        ret.append(char)
      }
    }
  }
    
  let result: String = ret.reduce("") { partialResult, char in
    partialResult + String(char)
  }
  if result.isEmpty { return "EMPTY" }
  return result

문제에 적힌 순서대로 그대로 코드로 만들어 썻어니 라인이 길어졌다.... 

줄이면 반은 줄일수 있겠으나 귀찮으니 패스

 

2. 수열과 구간 쿼리 2

범위 필터 연산?

  var result: [Int] = []
  for query in queries {
    guard query.count == 3 else { return [] }
    let s = query[0], e = query[1], k = query[2]
    let filtered = arr[s...e].filter { num in
      num > k
    }
    let find = filtered.min() ?? -1
    result.append(find)
  }
   return result

프로그래머스는 타인의 답을 보는 기능이 있는데 항상 볼때마다 이걸 이렇게나 줄일수있네 라고 놀랍다.

값 체크는 항상 하고싶긴한데 주어진 문제에 일일이 하고있으면 재미가 없고 오래걸려서 그냥 넘기려한다.

그런데도 종종 아무 생각없이 값 검사하는게 추가된다

 

3. 수열과 구간 쿼리 3

배열 순환 스왑 문제

  var copyArr: [Int] = arr
  for query in queries {
    guard query.count == 2 else { return [] }
    let i = query[0], j = query[1]
    guard (0 ..< copyArr.count) ~= i ,  (0 ..< copyArr.count) ~= j else { return [] }
    let temp = copyArr[i]
    copyArr[i] = copyArr[j]
    copyArr[j] = temp
  }
  return copyArr

그냥 적힌 그대로 쭉쭉 코드로 작성했으나 타인 답을 보니  swapAt 라는 함수가 따로 있었다..... 아마 이문제는 swapAt이라는 함수 기능을 사용해보는 문제였겠지싶다

 

 
반응형

총 124문제가 기초 트레이닝 문제로 주어졌고 이 문제를 미리 다 풀어버리면 그날짜가 되서 체크가 완료되는거같다.

우선 다 채우지 않아 바로 day3,4가 완료되지 않아서 아쉽.

다채워진 날짜도 있으나 날짜가 되지 않아서 그런가 "마지막문제를 푼날이 체크됩니다!" 라고 써진것과 다르게 날짜가 체크되어 있지 않다

아무튼 프로그래머스의 기초 트레이닝 도전과제를 계속 이어 나가자.

기존에 다 풀지 않은 부분만 쭉 써나갈것이다.

기초 라는 단어가 들어가서인지 대부분 문법문제였다.

현재 62 문제가 남았으나 3,4일차 도전과제는 3개뿐이라 이글에서 끝내버릴거다. 그리고 오늘 남은 60개정도의 문제를 끝내고 다음 5번글은 같은 사이트의 다른 서비스를 찾아볼까한다.

 

1. 문자열 섞기

두 문자열의 각 문자가 앞에서부터 서로 번갈아가면서 한 번씩 등장하는 문자열을 만들어 return

  //  1 ≤ str1의 길이 = str2의 길이 ≤ 10
  guard str1.count > 0, str2.count > 0, str1.count < 11, str2.count < 11, str1.count == str2.count else { return "" }
  //  return (0..<str1.count).map { i in
  //    let index = str1.index(str1.startIndex, offsetBy: i)
  //    return "\(str1[index])\(str2[index])"
  //  }.joined()
  
  let resultArry: [String] = Array<Int>( 0..<str1.count ).map { i in
      let index = str1.index(str1.startIndex, offsetBy: i)
      return "\(str1[index])\(str2[index])"
  }
  return resultArry.joined()

같은 길이라 그냥 맵으로 반복 돌려서 합치면 끝 인데 이상하게 런타임 에러가 발생해서 joined 하는 부분을 나눠주고 타입추론이 생략을 해주려고 타입을 지정해줌.

 

2. 문자 리스트를 문자열로 변환하기

return arr.joined()

joined를 아느냐 또는 문자열 병합을 아는가를 묻는 문제

 

3. 조건문자열

">", "=" : n >= m

"<", "=" : n <= m

">", "!" : n > m

"<", "!" : n < m

앞 두개 부호가 주어지고 n과 m을 비교한 값을 반환하는 문제

enum으로 부호를 나눠서 해볼까 생각했더니 라인이 너무 많아졌다

  enum CalcStr {
    // <, > ,<=, >=
    case left, right, leftEqual, rightEqual
  }
  
  func boolToInt(_ b: Bool) -> Int {b ? 1 : 0}
  
  //  1 ≤ n, m ≤ 100
  guard n >= 1, n <= 100, m >= 1, m <= 100 else { return -1 }
  guard ineq == ">" || ineq == "<", eq == "=" || eq == "!" else { return -1 }
  /**
   ">", "=" : n >= m
   "<", "=" : n <= m
   ">", "!" : n > m
   "<", "!" : n < m
   */
  var calcStr: CalcStr
  if ineq == ">" {
    calcStr = eq == "!" ? .right : .rightEqual
  } else {
    calcStr = eq == "!" ? .left : .leftEqual
  }
  
  switch calcStr {
  case .left: return boolToInt(n < m)
  case .right: return boolToInt(n > m)
  case .leftEqual: return boolToInt(n <= m)
  case .rightEqual: return boolToInt(n >= m)
  }

사실은 ineq 와 eq를 문자열로 합해서 그대로 case문으로 돌리면 10라인도 안되서 끝날 문제....

 

뭐 아무튼 이거로 day4일치까지 끝이 났다

 

day5~25까지 있는데 남은 문제가 59문제라 오늘 좀 하면 대부분 끝나지 않을까 싶다 기한이 넘으면 day5,6에 대한 포스트를하겠다.

반응형

'iOS > 프로그래머스 - 코딩테스트 문제' 카테고리의 다른 글

6. day7 반복문, day8 조건문, 문자열  (0) 2024.06.27
5. day5 조건문, day6 조건문 반복문  (0) 2024.06.26
3. day2 출력,연산  (0) 2024.06.24
2. day1 출력  (0) 2024.06.24
1-1. 잡담  (0) 2024.06.24

day1이 너무 빨리 끝나서 day2를 바로 시작

1. 덧셈식 출력하기

print(a, "+", b, "=", a+b)

입력 엔 출력 ~

 

2. 문자열 붙여서 출력

print(s1,s2, separator: "", terminator: "")

그냥 변수 하나로 붙여서 출력하는게 더 빨랐겠다 싶다

 

3. 문자열 돌리기

let s1 = readLine()!
for c in s1 {
    print(c)
}

이건 뭘 테스트하는지 모르겠다

 

4. 홀짝 구분하기

let a = Int(readLine()!)!

print(a,"is \(a%2 == 0 ? "even" : "odd")")

이번엔 나머지 연산자 문법 문제

 

5. 문자열 겹쳐쓰기

주어진 문자열에 지정한 인덱스부터 문자 변경하기

func solution(_ my_string:String, _ overwrite_string:String, _ s:Int) -> String {
  //my_string와 overwrite_string은 숫자와 알파벳으로 이루어져 있습니다.
  //1 ≤ overwrite_string의 길이 ≤ my_string의 길이 ≤ 1,000
  let regexPattern = "^[0-9a-zA-Z]*${1,1000}"
  guard let _ = my_string.range(of: regexPattern, options: .regularExpression) else {return ""}
  guard let _ = overwrite_string.range(of: regexPattern, options: .regularExpression) else {return ""}
  //0 ≤ s ≤ my_string의 길이 - overwrite_string의 길이
  guard my_string.count - overwrite_string.count >= 0 else { return "" }
  
  let overwrite_start_index = my_string.index(my_string.startIndex, offsetBy: s)
  let overwrite_end_index = my_string.index(overwrite_start_index, offsetBy: overwrite_string.count)
  
  let suffix = my_string[my_string.startIndex..<overwrite_start_index]
  let prefix = my_string[overwrite_end_index...]

  return String(suffix + overwrite_string + prefix)
}

처음 문제를 봤을때 덮어쓰는 단어의 시작과 끝 인덱스를 구해서 그대로 더하면 되겠다해서 제출했고 앞부분의 제한사항은 그냥 넣어봤다 문제 자체답에는 없어도 무방.

타인의 답으로는 replaceSubrange라는걸 이용한 엄청간단해보이는것과 prefix(s),suffix(x) 라는 걸로 제출되어있다

내가 하려던게 이미 구현되어있구나하고 모르는게 많았구나 싶다.

 

반응형

'iOS > 프로그래머스 - 코딩테스트 문제' 카테고리의 다른 글

5. day5 조건문, day6 조건문 반복문  (0) 2024.06.26
4. day3 연산, day4 연산 조건문  (0) 2024.06.25
2. day1 출력  (0) 2024.06.24
1-1. 잡담  (0) 2024.06.24
1. [PCCE 기출문제] 1번 / 출력  (0) 2024.06.24

프로그래머스 사이트에는 도전과제 서비스가 있었고 해당 내용으로 재활활동을 해볼까한다

시작은 역시 출력

 

 

 

 

 

 

1.  그대로 출력

let s1 = readLine()!
print(s1)

 

2. 한줄 숫자 두개입력 및 출력 형식 지정

let n = readLine()!.components(separatedBy: [" "]).map { Int($0)! }

let (a, b) = (n[0], n[1])

 

print("a =", a)

print("b =", b)

 

3.한줄에 단어와 숫자가 주어질때 숫자만큼 반복 출력하기

let inp = readLine()!.components(separatedBy: [" "]).map { $0 }
let (s1, a) = (inp[0], Int(inp[1])!)

for _ in 0..<a {
  print(s1, terminator: "")
}

 

4. 영단어를 입력받고 대문자면 소문자로 소문자면 대문자로 출력하기

let s1 = readLine()!
let bigEndValue = "Z".unicodeScalars.first!.value

for unicode in s1.unicodeScalars {
  let printValue = String(unicode)
  if unicode.value > bigEndValue {
    print(printValue.uppercased(), terminator: "")
  } else {
    print(printValue.lowercased(), terminator: "")
  }
}

제출하고 타 사람의 답변을 볼 수 있는데 

isUppercase, isLowercase 가 있었다. 솔직히 잊고있었다.

이거로 출력했으면 출력문은 한두줄로 할 수 있었을텐데 역시 타 제출답보기는 좋은 기능이다 

 

5. 특수문자 출력

print("!@#$%^&*(\\'\"<>?:;")

문법 관련문제

 

반응형

'iOS > 프로그래머스 - 코딩테스트 문제' 카테고리의 다른 글

4. day3 연산, day4 연산 조건문  (0) 2024.06.25
3. day2 출력,연산  (0) 2024.06.24
1-1. 잡담  (0) 2024.06.24
1. [PCCE 기출문제] 1번 / 출력  (0) 2024.06.24
0. 시작  (0) 2024.06.24

+ Recent posts