๋ฌธ์์ด S๋ฅผ ์ ๋ ฅ๋ฐ์ ํ์, ๊ฐ ๋ฌธ์๋ฅผ R๋ฒ ๋ฐ๋ณตํด ์ ๋ฌธ์์ด P๋ฅผ ๋ง๋ ํ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์ฆ, ์ฒซ ๋ฒ์งธ ๋ฌธ์๋ฅผ R๋ฒ ๋ฐ๋ณตํ๊ณ , ๋ ๋ฒ์งธ ๋ฌธ์๋ฅผ R๋ฒ ๋ฐ๋ณตํ๋ ์์ผ๋ก P๋ฅผ ๋ง๋ค๋ฉด ๋๋ค. S์๋ QR Code "alphanumeric" ๋ฌธ์๋ง ๋ค์ด์๋ค.
QR Code "alphanumeric" ๋ฌธ์๋ 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ$%*+-./: ์ด๋ค.
์ฒซ์งธ ์ค์ ํ ์คํธ ์ผ์ด์ค์ ๊ฐ์ T(1 โค T โค 1,000)๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ํ ์คํธ ์ผ์ด์ค๋ ๋ฐ๋ณต ํ์ R(1 โค R โค 8), ๋ฌธ์์ด S๊ฐ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค. S์ ๊ธธ์ด๋ ์ ์ด๋ 1์ด๋ฉฐ, 20๊ธ์๋ฅผ ๋์ง ์๋๋ค.
๊ฐ ํ ์คํธ ์ผ์ด์ค์ ๋ํด P๋ฅผ ์ถ๋ ฅํ๋ค.
2
3 ABC
5 /HTP
AAABBBCCC
/////HHHHHTTTTTPPPPP
let n = Int(readLine()!)!
for _ in 0..<n {
let input = readLine()!.split(separator:" ")
let num = Int(String(input[0]))!
let string = input[1]
var result = ""
for char in string {
let repeated = String(repeating: char, count: num)
result += repeated
}
print(result)
}
init(repeating: count: )
๊ตฌ๋ฌธ์ผ๋ก ๋ฌธ์์ด๊ณผ ๋ฐฐ์ด์ ์ด๊ธฐํํ ์ ์๋ค.
// a๋ฅผ 4๋ฒ ๋ฐ๋ณตํ๋ ๋ฌธ์์ด์ ๋ง๋ค์ด๋ณด์
let tmp = String(repeating: "a", count: 4)
print(tmp) // aaaa
// 0์ 10๋ฒ ๋ฐ๋ณตํ๋ ๋ฐฐ์ด์ ๋ง๋ค์ด๋ณด์
let dict = [Int](repeating: 0, count: 10)
print(dict) // [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
์ํ๋ฒณ ๋์๋ฌธ์๋ก ๋ ๋จ์ด๊ฐ ์ฃผ์ด์ง๋ฉด, ์ด ๋จ์ด์์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋ ์ํ๋ฒณ์ด ๋ฌด์์ธ์ง ์์๋ด๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋จ, ๋๋ฌธ์์ ์๋ฌธ์๋ฅผ ๊ตฌ๋ถํ์ง ์๋๋ค.
์ฒซ์งธ ์ค์ ์ํ๋ฒณ ๋์๋ฌธ์๋ก ์ด๋ฃจ์ด์ง ๋จ์ด๊ฐ ์ฃผ์ด์ง๋ค. ์ฃผ์ด์ง๋ ๋จ์ด์ ๊ธธ์ด๋ 1,000,000์ ๋์ง ์๋๋ค.
์ฒซ์งธ ์ค์ ์ด ๋จ์ด์์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋ ์ํ๋ฒณ์ ๋๋ฌธ์๋ก ์ถ๋ ฅํ๋ค. ๋จ, ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋ ์ํ๋ฒณ์ด ์ฌ๋ฌ ๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ์๋ ?๋ฅผ ์ถ๋ ฅํ๋ค.
Mississipi
?
zZa
Z
z
Z
baaa
A
var word = readLine()!.uppercased()
var dict = [Character:Int]()
var max = 0
var maxWord = [Character]()
for i in word {
if dict[i] == nil {
dict[i] = 1
} else {
dict[i]! += 1
}
}
for (key, value) in dict {
if value > max {
max = value
maxWord = [key]
} else if value == max {
maxWord.append(key)
}
}
if maxWord.count > 1 {
print("?")
} else {
print(String(maxWord))
}
๋๋ฌด,, ํ์ด์ฌ๊ฐ์ด ํ์๋ค,,^^
๋ฐฐ์ด์ ์ ๋ ฌํ๋ ๊ฒ์ ์ฝ๋ค. ์๊ฐ ์ฃผ์ด์ง๋ฉด, ๊ทธ ์์ ๊ฐ ์๋ฆฌ์๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํด๋ณด์.
์ฒซ์งธ ์ค์ ์ ๋ ฌํ๋ ค๊ณ ํ๋ ์ N์ด ์ฃผ์ด์ง๋ค. N์ 1,000,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค.
์ฒซ์งธ ์ค์ ์๋ฆฌ์๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ ์๋ฅผ ์ถ๋ ฅํ๋ค.
2143
4321
999998999
999999998
61423
64321
500613009
965310000
var n = readLine()!.map { Int(String($0))! }
n.sort(by: >)
for i in n {
print(i, terminator: "")
}
map ๊ณ ์ฐจํจ์๋ฅผ ํตํด Int ํ์ ์ ๋ฐฐ์ด๋ก ์ ๋ ฅ์ ๋ฐ๊ณ , ์ ๋ ฌ์ ์ํด sort๋ฅผ ์ฌ์ฉํ๋ค.
n.sort(by: <)
n.sort(by: >)
print(terminator: "")
๋ฅผ ์ฌ์ฉํ๋ฉด ์ถ๋ ฅ ๋๋ถ๋ถ์ ์ค๋ฐ๊ฟ์ด ์ ๊ฑฐ๋๋ค.
print(terminator: " ")
์๋ ๊ฒ ์ฐ๋ฉด ์ถ๋ ฅ ๋๋ถ๋ถ์ด ์ค๋ฐ๊ฟ ๋์ ๋์ด์ฐ๊ธฐ๊ฐ ๋๋ค.
์ด๋ ๋ , ๋ฏธ๋ฅด์ฝ๋ ์ฐ์ฐํ ๊ธธ๊ฑฐ๋ฆฌ์์ ์์ N์ ๋ณด์๋ค. ๋ฏธ๋ฅด์ฝ๋ 30์ด๋ ์๋ฅผ ์กด๊ฒฝํ๊ธฐ ๋๋ฌธ์, ๊ทธ๋ ๊ธธ๊ฑฐ๋ฆฌ์์ ์ฐพ์ ์์ ํฌํจ๋ ์ซ์๋ค์ ์์ด 30์ ๋ฐฐ์๊ฐ ๋๋ ๊ฐ์ฅ ํฐ ์๋ฅผ ๋ง๋ค๊ณ ์ถ์ดํ๋ค.
๋ฏธ๋ฅด์ฝ๋ฅผ ๋์ ๊ทธ๊ฐ ๋ง๋ค๊ณ ์ถ์ดํ๋ ์๋ฅผ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.
N์ ์ ๋ ฅ๋ฐ๋๋ค. N๋ ์ต๋ 10^5๊ฐ์ ์ซ์๋ก ๊ตฌ์ฑ๋์ด ์์ผ๋ฉฐ, 0์ผ๋ก ์์ํ์ง ์๋๋ค.
๋ฏธ๋ฅด์ฝ๊ฐ ๋ง๋ค๊ณ ์ถ์ดํ๋ ์๊ฐ ์กด์ฌํ๋ค๋ฉด ๊ทธ ์๋ฅผ ์ถ๋ ฅํ๋ผ. ๊ทธ ์๊ฐ ์กด์ฌํ์ง ์๋๋ค๋ฉด, -1์ ์ถ๋ ฅํ๋ผ.
30
30
102
210
2931
-1
80875542
88755420
let n = readLine()!.sorted(by: >)
let array = n.map { Int(String($0))! }
let sum = array.reduce(0, +)
if n.contains("0") && sum%3 == 0 {
print(String(n))
} else {
print(-1)
}
30์ ๋ฐฐ์๊ฐ ๋๋ ค๋ฉด 10์ ๋ฐฐ์์ด์ 3์ ๋ฐฐ์์ด๋ฉด ๋๋ค.
์์ ๋ ์กฐ๊ฑด์ ๋ชจ๋ ์ถฉ์กฑํ๋ค๋ฉด
์๋ณธ ์ซ์๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ฉด ์ ๋ต์ด ๋๋ค.
๊ฐ ์๋ฆฌ์ ์์ ํฉ์ recude
๊ณ ์ฐจํจ์๋ก ๊ตฌํ๋ค.
์๋ณธ ์ซ์์ 0์ด ์๋์ง๋ contains
๋ก ๊ตฌํ๋ค.
import Foundation
์ ํด์ฃผ์ด์ผ ๋์ํ๋ค.์ํ๋ฒณ ์๋ฌธ์์ ๋๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ง ๊ธธ์ด๊ฐ N์ธ ๋จ์ด๊ฐ ์ฃผ์ด์ง๋ค.
ํ ์ค์ 10๊ธ์์ฉ ๋์ด์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ฒซ์งธ ์ค์ ๋จ์ด๊ฐ ์ฃผ์ด์ง๋ค. ๋จ์ด๋ ์ํ๋ฒณ ์๋ฌธ์์ ๋๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ๊ธธ์ด๋ 100์ ๋์ง ์๋๋ค. ๊ธธ์ด๊ฐ 0์ธ ๋จ์ด๋ ์ฃผ์ด์ง์ง ์๋๋ค.
์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋จ์ด๋ฅผ ์ด ๊ฐ์ฉ ๋์ด์ ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅํ๋ค. ๋จ์ด์ ๊ธธ์ด๊ฐ 10์ ๋ฐฐ์๊ฐ ์๋ ๊ฒฝ์ฐ์๋ ๋ง์ง๋ง ์ค์๋ 10๊ฐ ๋ฏธ๋ง์ ๊ธ์๋ง ์ถ๋ ฅํ ์๋ ์๋ค.
BaekjoonOnlineJudge
BaekjoonOn
lineJudge
OneTwoThreeFourFiveSixSevenEightNineTen
OneTwoThre
eFourFiveS
ixSevenEig
htNineTen
var string = readLine()!
var cnt = 0
for char in string {
if cnt < 10 {
cnt += 1
} else if cnt == 10 {
cnt = 1
print("")
}
print(char, terminator: "")
}
ํ ์ค์ ์์์ cnt๊ฐ 1์ด ๋๊ณ , ํ ๊ธ์ ์ถ๋ ฅํ ๋๋ง๋ค cnt๋ฅผ ๋๋ฆฌ๋ค๊ฐ ํ ์ค์ 10๊ฐ๊ฐ ๋ชจ๋ ์ถ๋ ฅ๋์ผ๋ฉด print("")๋ก ์ค๋ฐ๊ฟํด ๋ค์ ์ค๋ก ๋์ด๊ฐ๋ค.
๋ฌธ์ฅ์ ์ฝ์ ๋ค, ์ค์ ์ฒซ ๊ธ์๋ฅผ ๋๋ฌธ์๋ก ๋ฐ๊พธ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ฒซ์งธ ์ค์ ์ค์ ์ N์ด ์ฃผ์ด์ง๋ค. ๋ค์ N๊ฐ์ ์ค์๋ ๋ฌธ์ฅ์ด ์ฃผ์ด์ง๋ค. ๊ฐ ๋ฌธ์ฅ์ ๋ค์ด์๋ ๊ธ์์ ์๋ 30์ ๋์ง ์๋๋ค. ๋ชจ๋ ์ค์ ์ฒซ ๋ฒ์งธ ๊ธ์๋ ์ํ๋ฒณ์ด๋ค.
๊ฐ ์ค์ ์ฒซ๊ธ์๋ฅผ ๋๋ฌธ์๋ก ๋ฐ๊พผ๋ค ์ถ๋ ฅํ๋ค.
5
powdered Toast Man
skeletor
Electra Woman and Dyna Girl
she-Ra Princess of Power
darth Vader
Powdered Toast Man
Skeletor
Electra Woman and Dyna Girl
She-Ra Princess of Power
Darth Vader
let n = Int(String(readLine()!))!
for _ in 0..<n {
var input = readLine()!
let upper = input[input.startIndex].uppercased()
input.removeFirst(1)
print(upper + input)
}
ํ์ด์ฌ์ผ๋ก ๋ฌธ์์ด ๋ฌธ์ ํ๋ค๊ฐ ์ค์ํํธ๋ก ๋ฌธ์์ด ํ๋ผ๋๊น ๋๋ฌด ํ๋ค์ด -.-
์ค์ํํธ์์๋ ๋ฌธ์์ด input์ input[0]
์ด๋ฐ ์์ผ๋ก ์ธ๋ฑ์ฑํ๋ ๊ฒ์ด ๋ถ๊ฐ๋ฅํ๋ค.
๋ฐ๋ผ์ ์ฒซ๋ฒ์งธ ๋ฌธ์๋ฅผ ๊ตฌํ๊ธฐ ์ํด input[input.startIndex]
๋ฅผ ์ฌ์ฉํ๋ค.
uppercased()
๋ก ์๋ณธ ๋ฌธ์์ด์ ์ฒซ๋ฒ์งธ ๋ฌธ์๋ฅผ ๋๋ฌธ์๋ก ๋ฐ๊ฟ์ฃผ๊ณ upper๋ผ๋ ์๋ก์ด ๋ณ์์ ๊ฐ์ ์ ์ฅํ๋ค.
removeFirst(1)
๋ก ์๋ณธ ๋ฌธ์์ด์ ์์์๋ถํฐ 1๊ฐ์ ๋ฌธ์, ์ฆ ์ฒซ๋ฒ์งธ ๋ฌธ์๋ฅผ ์ญ์ ํ๋ค. ์ด ๋ฉ์๋๋ ๋ฐฐ์ด์ ๋ํด์๋ ์ฌ์ฉํ ์ ์๋ค.
๊ทธ๋ผ ์ด์ upper์ ์๋ณธ ๋ฌธ์์ด์ ์ด์ด๋ถ์ฌ ์ถ๋ ฅํ๋ฉด ์ ๋ต์ด ๋๋ค.
๋ฐฉ๊ธ ๋ง ํ๋ก๊ทธ๋๋ฐ์ ๋ฐฐ์ฐ๊ธฐ ์์ํ ์ฐฌ์ฐ๋ acmicpc.net์ ์๋ ํ์๋ค์ด ๋ชจ๋ ์ ๊ฐ์ด ๋ณด์๋ค. ๊ทธ๋์ ์ฐฌ์ฐ๋ ๋ชจ๋ ํ์์ ๋๋ค์ ์์ โ๊ฐโ์ ๋ถ์ด๋ ค๊ณ ํ๋ค.
์ฐฌ์ฐ๊ฐ โkoosagaโ๋ผ๋ ๋๋ค์์ ๊ฐ์ง ํ์์ ๊ฐ์ผ๋ก ๋ฐ๊ฟ ๋ถ๋ฅธ๋ค๋ฉด โgodsagaโ๊ฐ ๋๋ค. ๋, ์ฐฌ์ฐ๊ฐ โackaโ๋ผ๋ ๋๋ค์์ ๊ฐ์ง ํ์์ ๊ฐ์ผ๋ก ๋ฐ๊ฟ ๋ถ๋ฅธ๋ค๋ฉด โgodkaโ๊ฐ ๋ ๊ฒ์ด๋ค. ์ฐฌ์ฐ๋ ๋๋ค์์ ๊ฐ์ผ๋ก ๋ฐ๊พธ๋ ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐํ๋ค๊ฐ, ์๋์ ๊ฐ์ด 2๋จ๊ณ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ฉด ๋ ๊ฒ์ผ๋ก ์๊ฐํ๋ค.
์ฐฌ์ฐ๋ ์์์ ์ผ๋ก N๋ช ์ ๋๋ค์์ ๋ชจ๋ ์์ ๋จ์๋ก ์ชผ๊ฐฐ๋ค. ์ฐฌ์ฐ๋ฅผ ๋์ ์ด ๋๋ค์๋ค์ ๊ฐ์ ๋ถ์ด๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์.
์ฒซ ๋ฒ์งธ ์ค์๋ ๋๋ค์์ ์ N(1 โค N โค 100)์ด ์ฃผ์ด์ง๋ค. ๋ ๋ฒ์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ์์ ๋จ์๋ก ์ชผ๊ฐ ๋๋ค์์ด ์ฃผ์ด์ง๋ค. ๊ฐ ์ค์ ์ํ๋ฒณ ์๋ฌธ์์ ๊ณต๋ฐฑ๋ง์ผ๋ก ์ด๋ฃจ์ด์ง๋ฉฐ, ์ชผ๊ฐ ๋๋ค์์ ์ด ๊ธธ์ด(๊ณต๋ฐฑ ํฌํจ)๋ 100์ ๋์ง ์๋๋ค. ์ชผ๊ฐ ๋๋ค์์๋ 1๊ฐ ์ด์์ ๊ณต๋ฐฑ์ด ์กด์ฌํ๋ค.
๊ฐ ์ค์ ํ๋์ฉ ๊ฐ์ ๋ถ์ธ ๋๋ค์์ ์ถ๋ ฅํ๋ค.
5
baek joon
koo sa ga
ac ka
yu ka ri ko
ke sa ki yo
godjoon
godsaga
godka
godkariko
godsakiyo
for _ in 0..<Int(String(readLine()!))! {
let nickname = readLine()!.split(separator: " ")
print("god\(nickname.dropFirst().joined())")
}
์ง์ ๋ฌธ์ ์์ ์ฌ์ฉํ๋ removeFirst
๋ ๋ฐฐ์ด์ ์์ ํ์ง๋ง, dropFirst
๋ ๋ฐฐ์ด์ ์์ ํ์ง ์๋๋ค. ์๋ณธ ๋ฐฐ์ด์ ์ฒซ๋ฒ์งธ ์์๊ฐ ์ญ์ ๋ ๋ชจ์์ ๋ฐฐ์ด์ ๋ฆฌํดํ๋ค. ๊ทธ๋์ nickname ๋ฐฐ์ด์ let์ผ๋ก ์ ์ธํด๋ ๋ฌธ์ ์์ด ๋์ํ๋ ๊ฒ์ด๋ค.
๋ฐฐ์ด์ ๋ค์ joined
๋ฅผ ๋ถ์ด๋ฉด ๋ฐฐ์ด์ ์์๋ค์ ๊ฒฐํฉํด ๋ฌธ์์ด๋ก ๋ง๋ค ์ ์๋ค.
๊ฟ์ ๋ง์ฌ๊ฐ ๊ท์ฐฎ์์ ๋ง์ ํ๊ธฐ๋ ๊ท์ฐฎ์ ํ๋ค. ๊ทธ๋์ ํ๋ ค๋ ๋ง์ ๋์ ํด์ค ์ค์๋ง์ ๋ง๋ค๋ ค๊ณ ํ๋๋ฐ ๋๋ฆ ๊ท์น์ ๋ง๋ค์๋ค.
ํ๋ ค๋ ๋ง์ ์ต์ ํ๋ ์ด์์ ๋จ์ด๋ฅผ ํฌํจํ๋๋ฐ ๊ฐ ๋จ์ด๋ค์ ์ ํํ ํ์นธ์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ์ด ๋๋ค. ์ค์๋ง์ ๋ง๋ค๋๋ ๊ฐ ๋จ์ด์ ์๊ธ์๋ฅผ ๋ฐ์ ๋ง๋ค์ด์ง๋๋ฐ ๋ค์์ ๋จ์ด๋ค์ ์ธ๋ชจ์๋ ๋จ์ด๋ค์ด๋ฏ๋ก ๋ฌด์ํ๋ค.
ํ์ง๋ง ์ด ๋จ์ด๋ค์ด ํ๋ ค๋ ๋ง์ ๋งจ ์์ ์ฌ๊ฒฝ์ฐ ๋งค์ฐ ์ค์ํ๋ค๊ณ ํ๋จ๋์ด ๋ฌด์ํ๋ฉด ์๋๊ณ ์ค์๋ง์ ํฌํจํ์ฌ์ผ ํ๋ค.
์ค์๋ง์ ๋ง๋ค๊ธฐ๋ ๊ท์ฐฎ์์ง ๊ฟ์ ์ํด ์ค์๋ง์ ๋ง๋ค์ด์ฃผ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.
๋จ, ์ค์๋ง์ ๋ชจ๋ ๋๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ์๋ค.
์ ๋ ฅ์ ์ ์ผํ๊ฒ ํ ์ค๋ง ์ฃผ์ด์ง๋ฉฐ ํ๋ ค๋ ๋ง์ด ํฌํจ๋์ด ์๋ค.
๋ฌธ์ฅ์ ์ํ๋ฒณ ์๋ฌธ์์ ๊ณต๋ฐฑ์ผ๋ก๋ง ์ด๋ฃจ์ด์ ธ ์๋ค.
๋ฌธ์ฅ์ ์ต๋๊ธธ์ด๋ 100์ด๋ค.
๋ง๋ค์ด์ง ์ค์๋ง์ ์ถ๋ ฅํ๋ผ.
micro soft
MS
biti ali i ne biti
BNB
ali ja sam i jucer jeo
AJSJJ
var input = readLine()!.split(separator: " ")
let skip = ["i", "pa", "te", "ni", "niti", "a", "ali", "nego", "no", "ili"]
var idx = 0
for str in input {
if skip.contains(String(str)) && idx > 0 {
continue
} else {
print(str[str.startIndex].uppercased(), terminator: "")
}
idx += 1
}