수웅이는매달주어진음식을빨리먹는푸드파이트대회를개최합니다. 이대회에서선수들은 1대 1로대결하며, 매대결마다음식의종류와양이바뀝니다. 대결은준비된음식들을일렬로배치한뒤, 한선수는제일왼쪽에있는음식부터오른쪽으로, 다른선수는제일오른쪽에있는음식부터왼쪽으로순서대로먹는방식으로진행됩니다. 중앙에는물을배치하고, 물을먼저먹는선수가승리하게됩니다.
이때, 대회의공정성을위해두선수가먹는음식의종류와양이같아야하며, 음식을먹는순서도같아야합니다. 또한, 이번대회부터는칼로리가낮은음식을먼저먹을수있게배치하여선수들이음식을더잘먹을수있게하려고합니다. 이번대회를위해수웅이는음식을주문했는데, 대회의조건을고려하지않고음식을주문하여몇개의음식은대회에사용하지못하게되었습니다.
구조체와 클래스의 정의 구문은 비슷합니다.struct키워드로 구조를 소개하고 키워드로 클래스를소개합니다class.둘 다 한 쌍의 중괄호 안에 전체 정의를 배치합니다.
struct SomeStructure {
// structure definition goes here
}
class SomeClass {
// class definition goes here
}
EX)
struct Resolution {
var width = 0
var height = 0
}
class VideoMode {
var resolution = Resolution()
var interlaced = false
var frameRate = 0.0
var name: String?
}
인스턴스를 생성하는 구문은 구조체와 클래스 모두 매우 유사합니다.
let someResolution = Resolution()
let someVideoMode = VideoMode()
모든 구조체에는 자동으로 생성된멤버 단위 초기화가있으며 이를 사용하여 새 구조체 인스턴스의 멤버 속성을 초기화할 수 있습니다.새 인스턴스의 속성에 대한 초기 값은 이름으로 멤버별 이니셜라이저에 전달될 수 있습니다.
let vga = Resolution(width: 640, height: 480)
구조체와 달리 클래스 인스턴스는 기본 멤버 단위 초기화를 받지 않습니다. (초기화 initialization)
클래스는 참조 유형입니다.
값 유형과 달리참조 유형은변수나 상수에 할당되거나 함수에 전달될 때 복사되지않습니다.복사본이 아니라 동일한 기존 인스턴스에 대한 참조가 사용됩니다.
let tenEighty = VideoMode()
tenEighty.resolution = hd
tenEighty.interlaced = true
tenEighty.name = "1080i"
tenEighty.frameRate = 25.0
frameRate를 30으로 바꿈
let alsoTenEighty = tenEighty
alsoTenEighty.frameRate = 30.0
import UIKit
struct Town{
//프로퍼티
let name = "Angelaland"
var citizens = ["Angela", "Jack Bauer"]
var resources = ["Gain" : 100, "Ore" :42, "Wool" : 75]
//구조체 안의 리턴값 없는 메서드(구조체나 클래스 안에서의 정의)
//독립실행형이고 어디선가 자유롭게 사용된다면 함수라고 정의 따라서 fortify는 메서드
func fortify(){
print ("Defences increased!")
}
}
var myTown = Town() //Town개체를 myTown으로 사용
print(myTown.name) // 구조체의 name 출력
print("\(myTown.name) has \(myTown.resources["Gain"]!) bags of grain.")
myTown.citizens.append("Smith") //moTown의 citizens에 Smith추가
print(myTown.citizens.count) //citizens의 개수 출력
myTown.fortify()
//init사용
struct Town_initCase{
//프로퍼티
let name : String
var citizens : [String]
var resources : [String : Int]
init(name : String, citizens : [String], resources : [String:Int]){
self.name = name
self.citizens = citizens
self.resources = resources
}
//구조체 안의 리턴값 없는 메서드(구조체나 클래스 안에서의 정의)
//독립실행형이고 어디선가 자유롭게 사용된다면 함수라고 정의 따라서 fortify는 메서드
func fortify(){
print ("Defences increased!")
}
}
//init으로 Town_initCase 구조체 초기화
var anotherTown = Town_initCase(name: "Nameless Island", citizens: ["Tom"], resources: ["Coconuts" : 100])
anotherTown.citizens.append("Wilson")
print(anotherTown.citizens)
스택 (stack)은 기본적인 자료구조 중 하나로, 컴퓨터 프로그램을 작성할 때 자주 이용되는 개념이다. 스택은 자료를 넣는 (push) 입구와 자료를 뽑는 (pop) 입구가 같아 제일 나중에 들어간 자료가 제일 먼저 나오는 (LIFO, Last in First out) 특성을 가지고 있다.
1부터 n까지의 수를 스택에 넣었다가 뽑아 늘어놓음으로써, 하나의 수열을 만들 수 있다. 이때, 스택에 push하는 순서는 반드시 오름차순을 지키도록 한다고 하자. 임의의 수열이 주어졌을 때 스택을 이용해 그 수열을 만들 수 있는지 없는지, 있다면 어떤 순서로 push와 pop 연산을 수행해야 하는지를 알아낼 수 있다. 이를 계산하는 프로그램을 작성하라.
입력
첫 줄에 n (1 ≤ n ≤ 100,000)이 주어진다. 둘째 줄부터 n개의 줄에는 수열을 이루는 1이상 n이하의 정수가 하나씩 순서대로 주어진다. 물론 같은 정수가 두 번 나오는 일은 없다.
출력
입력된 수열을 만들기 위해 필요한 연산을 한 줄에 한 개씩 출력한다. push연산은 +로, pop 연산은 -로 표현하도록 한다. 불가능한 경우 NO를 출력한다.
예제 입력 1복사
8
4
3
6
8
7
5
2
1
예제 출력 1복사
+
+
+
+
-
-
+
+
-
+
+
-
-
-
-
-
예제 입력 2복사
5
1
2
5
3
4
예제 출력 2복사
NO
힌트
1부터 n까지에 수에 대해 차례로 [push, push, push, push, pop, pop, push, push, pop, push, push, pop, pop, pop, pop, pop] 연산을 수행하면 수열 [4, 3, 6, 8, 7, 5, 2, 1]을 얻을 수 있다.
import Foundation
public struct Stack<T>{
private var elements = [T]()
public init() {}
public mutating func push(_ element: T){
self.elements.append(element)
}
public mutating func pop() -> T? {
let pop = self.elements.popLast()
self.elements.removeLast()
return pop
}
public mutating func poplast() {
self.elements.removeLast()
}
public func top() -> T? {
return self.elements.last
}
}
var myStack = Stack<Int>()
var ansArr : [String] = []
var cnt = 1
let input = Int(readLine()!)!
for _ in 0 ..< input {
let num = Int(readLine()!)!
while cnt <= num{
myStack.push(cnt)
ansArr.append("+")
cnt += 1
}
if myStack.top() == num{
myStack.poplast()
ansArr.append("-")
}else{
print("NO")
exit(0)
}
}
print(ansArr.joined(separator: "\n"))
// 빈 Int Array 생성
var integers: Array<Int> = Array<Int>()
// 같은 표현
// var integers: Array<Int> = [Int]()
// var integers: Array<Int> = []
// var integers: [Int] = Array<Int>()
// var integers: [Int] = [Int]()
// var integers: [Int] = []
// var integers = [Int]()
Array 활용
integers.append(1)
integers.append(100)
// Int 타입이 아니므로 Array에 추가할 수 없습니다
//integers.append(101.1)
print(integers) // [1, 100]
// 멤버 포함 여부 확인
print(integers.contains(100)) // true
print(integers.contains(99)) // false
// 멤버 교체
integers[0] = 99
// 멤버 삭제
integers.remove(at: 0)
integers.removeLast()
integers.removeAll()
// 멤버 수 확인
print(integers.count)
// 인덱스를 벗어나 접근하려면 익셉션 런타임 오류발생
//integers[0]
let을 이용하여 Array를 선언하면 불변 Array가 됩니다.
let immutableArray = [1, 2, 3]
// 수정이 불가능한 Array이므로 멤버를 추가하거나 삭제할 수 없습니다
//immutableArray.append(4)
//immutableArray.removeAll()
Dictionary
-Dictionary는 키 와 값 의 쌍으로 이루어진 컬렉션 타입입니다.
// Key가 String 타입이고 Value가 Any인 빈 Dictionary 생성
var anyDictionary: Dictionary<String, Any> = [String: Any]()
// 같은 표현
// var anyDictionary: Dictionary <String, Any> = Dictionary<String, Any>()
// var anyDictionary: Dictionary <String, Any> = [:]
// var anyDictionary: [String: Any] = Dictionary<String, Any>()
// var anyDictionary: [String: Any] = [String: Any]()
// var anyDictionary: [String: Any] = [:]
// var anyDictionary = [String: Any]()
숫자 카드는 정수 하나가 적혀져 있는 카드이다. 상근이는 숫자 카드 N개를 가지고 있다. 정수 M개가 주어졌을 때, 이 수가 적혀있는 숫자 카드를 상근이가 몇 개 가지고 있는지 구하는 프로그램을 작성하시오.
입력
첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.
셋째 줄에는 M(1 ≤ M ≤ 500,000)이 주어진다. 넷째 줄에는 상근이가 몇 개 가지고 있는 숫자 카드인지 구해야 할 M개의 정수가 주어지며, 이 수는 공백으로 구분되어져 있다. 이 수도 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.
출력
첫째 줄에 입력으로 주어진 M개의 수에 대해서, 각 수가 적힌 숫자 카드를 상근이가 몇 개 가지고 있는지를 공백으로 구분해 출력한다.
func sequencial(_ array: [Int], num: Int) -> Int {
var a = 0
for element in array {
if num == element {
a += 1
}
}
return a
}
var N = Int(readLine()!)!
var input_N = readLine()!.split(separator: " ").map{Int(String($0))!}
var M = Int(readLine()!)!
let input_M = readLine()!.split(separator: " ").map{Int(String($0))!}
input_N.sort()
var arr = [Int]()
for i in 0..<M{
arr.append(sequencial(input_N, num: input_M[i]))
}
print(arr.map{String($0)}.joined(separator: " "))
이진탐색으로 어떻게 해야할지 잘모르겠어서 완전탐색으로 하였다..
-> 당연히 시간초과 ㅋㅋㅌ ㅆ,,
실패코드 2트
func binarySearch(_ left: Int,_ right: Int , _ target: Int) -> Int{
let mid = Int((left + right) / 2)
var count = 0
if target == input_N[mid]{
var midLeft = mid - 1
count += 1
while midLeft >= 0 && target == input_N[midLeft]{
count += 1
midLeft -= 1
}
var midRight = mid + 1
while midRight < input_N.count && target == input_N[midRight]{
count += 1
midRight += 1
}
return count
}
if left > right || target < input_N[left] || target > input_N[right]{
return count
}
if target > input_N[mid]{
return binarySearch(mid + 1, right, target)
}else if target<input_N[mid]{
return binarySearch(left, mid - 1, target)
}
return count
}
var N = Int(readLine()!)!
var input_N = readLine()!.split(separator: " ").map{Int(String($0))!}
var M = Int(readLine()!)!
let input_M = readLine()!.split(separator: " ").map{Int(String($0))!}
input_N.sort()
var arr : [Int] = []
for i in input_M{
arr.append(binarySearch(0 , N-1 , i))
}
print(arr.map{String($0)}.joined(separator: " "))
나름 이분탐색 사용하였지만 다시나는 시간초과,,, 무엇이 문제일까..?
다음에 알아보도록 하자....
실패코드 3트
import Foundation
final class FileIO {
private let buffer:[UInt8]
private var index: Int = 0
init(fileHandle: FileHandle = FileHandle.standardInput) {
buffer = Array(try! fileHandle.readToEnd()!)+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
}
@inline(__always) private func read() -> UInt8 {
defer { index += 1 }
return buffer[index]
}
@inline(__always) func readInt() -> Int {
var sum = 0
var now = read()
var isPositive = true
while now == 10
|| now == 32 { now = read() } // 공백과 줄바꿈 무시
if now == 45 { isPositive.toggle(); now = read() } // 음수 처리
while now >= 48, now <= 57 {
sum = sum * 10 + Int(now-48)
now = read()
}
return sum * (isPositive ? 1:-1)
}
@inline(__always) func readString() -> String {
var now = read()
while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
let beginIndex = index-1
while now != 10,
now != 32,
now != 0 { now = read() }
return String(bytes: Array(buffer[beginIndex..<(index-1)]), encoding: .ascii)!
}
@inline(__always) func readByteSequenceWithoutSpaceAndLineFeed() -> [UInt8] {
var now = read()
while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
let beginIndex = index-1
while now != 10,
now != 32,
now != 0 { now = read() }
return Array(buffer[beginIndex..<(index-1)])
}
}
func binarySearch(_ left: Int,_ right: Int , _ target: Int) -> Int{
let mid = Int((left + right) / 2)
var count = 0
if target == input_N[mid]{
var midLeft = mid - 1
count += 1
while midLeft >= 0 && target == input_N[midLeft]{
count += 1
midLeft -= 1
}
var midRight = mid + 1
while midRight < input_N.count && target == input_N[midRight]{
count += 1
midRight += 1
}
return count
}
if left > right || target < input_N[left] || target > input_N[right]{
return count
}
if target > input_N[mid]{
return binarySearch(mid + 1, right, target)
}else if target<input_N[mid]{
return binarySearch(left, mid - 1, target)
}
return count
}
let fileIO = FileIO()
var input_N: [Int] = []
var input_M: [Int] = []
let N = fileIO.readInt()
for _ in 0..<N {
input_N.append(fileIO.readInt())
}
let M = fileIO.readInt()
for _ in 0..<M {
input_M.append(fileIO.readInt())
}
input_N.sort(by: <)
var result = ""
for i in input_M{
let count = binarySearch(0 , N-1 , i)
result += "\(count) "
}
print(result)
시간..초,,ㄱ..ㅘ....
딱알았다.. sort때문인거같으 이것만 다시해서 올려보겠습니다..ㅎ
4트ㅎㅎ
//import Foundation
//
//final class FileIO {
// private let buffer:[UInt8]
// private var index: Int = 0
//
// init(fileHandle: FileHandle = FileHandle.standardInput) {
//
// buffer = Array(try! fileHandle.readToEnd()!)+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
// }
//
// @inline(__always) private func read() -> UInt8 {
// defer { index += 1 }
//
// return buffer[index]
// }
//
// @inline(__always) func readInt() -> Int {
// var sum = 0
// var now = read()
// var isPositive = true
//
// while now == 10
// || now == 32 { now = read() } // 공백과 줄바꿈 무시
// if now == 45 { isPositive.toggle(); now = read() } // 음수 처리
// while now >= 48, now <= 57 {
// sum = sum * 10 + Int(now-48)
// now = read()
// }
//
// return sum * (isPositive ? 1:-1)
// }
//
// @inline(__always) func readString() -> String {
// var now = read()
//
// while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
// let beginIndex = index-1
//
// while now != 10,
// now != 32,
// now != 0 { now = read() }
//
// return String(bytes: Array(buffer[beginIndex..<(index-1)]), encoding: .ascii)!
// }
//
// @inline(__always) func readByteSequenceWithoutSpaceAndLineFeed() -> [UInt8] {
// var now = read()
//
// while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
// let beginIndex = index-1
//
// while now != 10,
// now != 32,
// now != 0 { now = read() }
//
// return Array(buffer[beginIndex..<(index-1)])
// }
//}
func binarySearch(_ left: Int,_ right: Int , _ target: Int) -> Int{
let mid = Int((left + right) / 2)
var count = 0
if target == input_N[mid]{
var midLeft = mid - 1
count += 1
while midLeft >= 0 && target == input_N[midLeft]{
count += 1
midLeft -= 1
}
var midRight = mid + 1
while midRight < input_N.count && target == input_N[midRight]{
count += 1
midRight += 1
}
return count
}
if left > right || target < input_N[left] || target > input_N[right]{
return count
}
if target > input_N[mid]{
return binarySearch(mid + 1, right, target)
}else if target<input_N[mid]{
return binarySearch(left, mid - 1, target)
}
return count
}
func quickSort(numArr : [Int]) -> [Int]{
if numArr.count < 2{
return numArr
}
let pivot = numArr[0]
var left :[Int] = []
var right :[Int] = []
for i in 1..<numArr.count{
if pivot > numArr[i]{
left.append(numArr[i])
}else if pivot < numArr[i] {
right.append(numArr[i])
}else if pivot == numArr[i]{
left.insert(numArr[i], at: 0)
}
}
return quickSort(numArr: left) + [pivot] + quickSort(numArr: right)
}
//let fileIO = FileIO()
//var input_N: [Int] = []
//var input_M: [Int] = []
//let N = fileIO.readInt()
let N = Int(readLine()!)!
//for _ in 0..<N {
// input_N.append(fileIO.readInt())
//}
var input_N = readLine()!.split(separator: " ").map{Int(String($0))!}
//let M = fileIO.readInt()
let M = Int(readLine()!)!
//for _ in 0..<M {
// input_M.append(fileIO.readInt())
//}
var input_M = readLine()!.split(separator: " ").map{Int(String($0))!}
input_N = quickSort(numArr: input_N)
var result = ""
for i in input_M{
let count = binarySearch(0 , N-1 , i)
result += "\(count) "
}
print(result)
이렇게 해보니 1트와 2트는 그냥 틀린것 같네요? ㅎㅎ (말로만 1트 2트지 수많은 트라이들이...)
다른분들은 lower upper 나눠서 하길래 나는 다른길을 걷고자 악바리로 한번에 해보려했지만 안되는것같네요?ㅎㅎ
아직 의지는 꺾이지 않았습니다.
제출코드 5트..
import Foundation
final class FileIO {
private let buffer:[UInt8]
private var index: Int = 0
init(fileHandle: FileHandle = FileHandle.standardInput) {
buffer = Array(try! fileHandle.readToEnd()!)+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
}
@inline(__always) private func read() -> UInt8 {
defer { index += 1 }
return buffer[index]
}
@inline(__always) func readInt() -> Int {
var sum = 0
var now = read()
var isPositive = true
while now == 10
|| now == 32 { now = read() } // 공백과 줄바꿈 무시
if now == 45 { isPositive.toggle(); now = read() } // 음수 처리
while now >= 48, now <= 57 {
sum = sum * 10 + Int(now-48)
now = read()
}
return sum * (isPositive ? 1:-1)
}
@inline(__always) func readString() -> String {
var now = read()
while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
let beginIndex = index-1
while now != 10,
now != 32,
now != 0 { now = read() }
return String(bytes: Array(buffer[beginIndex..<(index-1)]), encoding: .ascii)!
}
@inline(__always) func readByteSequenceWithoutSpaceAndLineFeed() -> [UInt8] {
var now = read()
while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
let beginIndex = index-1
while now != 10,
now != 32,
now != 0 { now = read() }
return Array(buffer[beginIndex..<(index-1)])
}
}
func lowerBound(_ left: inout Int,_ right: inout Int , _ target: Int) -> Int{
while left < right{
let mid = Int((left + right) / 2)
if input_N[mid] < target {
left = mid + 1
}else if target <= input_N[mid] {
right = mid
}
}
return left
}
func upperBound(_ left: inout Int,_ right: inout Int , _ target: Int) -> Int{
while left < right{
let mid = Int((left + right) / 2)
if input_N[mid] <= target{
left = mid + 1
}else if target < input_N[mid]{
right = mid
}
}
return right
}
func binarySearch(_ left: Int,_ right: Int , _ target: Int) -> Int{
let mid = Int((left + right) / 2)
var count = 0
if target == input_N[mid]{
var midLeft = mid - 1
count += 1
while midLeft >= 0 && target == input_N[midLeft]{
count += 1
midLeft -= 1
}
var midRight = mid + 1
while midRight < input_N.count && target == input_N[midRight]{
count += 1
midRight += 1
}
return count
}
if left > right || target < input_N[left] || target > input_N[right]{
return count
}
if target > input_N[mid]{
return binarySearch(mid + 1, right, target)
}else if target<input_N[mid]{
return binarySearch(left, mid - 1, target)
}
return count
}
func quickSort(numArr : [Int]) -> [Int]{
if numArr.count < 2{
return numArr
}
let pivot = numArr[0]
var left :[Int] = []
var right :[Int] = []
for i in 1..<numArr.count{
if pivot > numArr[i]{
left.append(numArr[i])
}else if pivot < numArr[i] {
right.append(numArr[i])
}else if pivot == numArr[i]{
left.insert(numArr[i], at: 0)
}
}
return quickSort(numArr: left) + [pivot] + quickSort(numArr: right)
}
let fileIO = FileIO()
var input_N: [Int] = []
var input_M: [Int] = []
var N = fileIO.readInt()
//var N = Int(readLine()!)!
for _ in 0..<N {
input_N.append(fileIO.readInt())
}
//var input_N = readLine()!.split(separator: " ").map{Int(String($0))!}
var M = fileIO.readInt()
//var M = Int(readLine()!)!
for _ in 0..<M {
input_M.append(fileIO.readInt())
}
//var input_M = readLine()!.split(separator: " ").map{Int(String($0))!}
//input_N = quickSort(numArr: input_N)
input_N.sort()
var result = ""
var zero = 0
var N_real = N
for i in input_M{
//let count = binarySearch(0 , N-1 , i)
let up = upperBound(&zero, &N, i)
zero = 0
N = N_real
let lo = lowerBound(&zero, &N, i)
zero = 0
N = N_real
let count = up - lo
//print(String((upperBound(&zero, &N, i)) - (lowerBound(&zero, &N, i))), terminator: " ")
result += "\(count) "
}
print(result)
someString = """
여러줄 문자열을
사용할 수 있습니다.
첫 줄에 겹따옴표 세 개,
마지막 줄에 겹따옴표 세 개를
사용하면 됩니다.
"""
someString = """
겹따옴표 세 개인 줄(첫줄, 끝줄)에서
줄 바꿈을 하지 않으면 오류가 발생합니다.
"""
/*
someString = """오류발생
오류발생"""
*/
생각해보기
let integer = 100 //정수형 Int Type
let floatingPoint = 12.34 // 실수형 Double Type
let apple = "A" // String
print(type(of: integer)) //Int
print(type(of: floatingPoint)) // Double
print(type(of: apple)) //String
Any
-swift의 모든 타입을 지칭하는 키워드
var someAny: Any = 100
someAny = "어떤 타입도 수용 가능합니다"
someAny = 123.12
Any 타입에 Double 자료를 넣어두었더라도 Any는 Double 타입이 아니기 때문에 할당할 수 없습니다.
명시적으로 타입을 변환해 주어야 합니다.
타입 변환은 차후에~
let someDouble: Double = someAny // 컴파일 오류발생
AnyObject
모든 클래스 타입을 지칭하는 프로토콜(클래스와 프로토콜은 차후에~)
class SomeClass {}
var someAnyObject: AnyObject = SomeClass()
AnyObject는 클래스의 인스턴스만 수용 가능하기 때문에 클래스의 인스턴스가 아니면 할당할 수 없습니다.
someAnyObject = 123.12 // 컴파일 오류발생
nil
없음을 의미하는 키워드
다른 언어의 NULL, Null, null 등과 유사한 표현입니다.
아래 코드에서 someAny는 Any타입이고, someAnyObject는 AnyObject타입 이기 때문에
