Author: root

            
            import Foundation

            func sortCards(cards: [String]) -> [String] {
                var letters: [String] = []
                var numbers: [Int] = []

                // Separate cards
                for card in cards {
                    if let number = Int(card) {
                        numbers.append(number)
                    } else {
                        letters.append(card)
                    }
                }

                // Sort
                letters.sort()
                numbers.sort()

                // Combine results
                let sortedNumbers = numbers.map { String($0) }
                return letters + sortedNumbers
            }

            // Example
            let cards = ["A", "3", "B", "1", "2"]
            let sortedCards = sortCards(cards: cards)
            print(sortedCards) // ["A", "B", "1", "2", "3"]
            
        

Additional Learning Resources

• Swift Collection Types
• Sorting in Swift
• Understanding Time Complexity

In this course, we will tackle an algorithm problem to implement a card game using Swift. Through this problem, you can enhance your understanding of Swift and learn about approaches to algorithm problems.

Problem Description

In the card game, two players start with N cards each. Each player draws one card at a time to compare, and the player with the higher-numbered card takes both cards. Your task is to calculate the total sum of the cards taken by Player 1 at the end.

Input

• The first line contains the number of cards N for Player 1 (1 ≤ N ≤ 1000).
• The second line contains the N cards of Player 1, separated by spaces.
• The third line contains the N cards of Player 2, separated by spaces.

Output

Output the total sum of the cards taken by Player 1.

Example Problem

Input

3
3 5 6
2 4 3

Output

14

Solution Process

To solve the problem, we first need to compare the cards of Player 1 and Player 2 to determine who wins each round. If Player 1 wins, they take both players’ cards. Here is a step-by-step approach to solving the problem.

Step 1: Handling Input

let n = Int(readLine()!)!
let player1Cards = readLine()!.split(separator: " ").map { Int($0)! }
let player2Cards = readLine()!.split(separator: " ").map { Int($0)! }

The code above processes the number of cards and the cards for Player 1 and Player 2. First, it receives the number of cards N, then stores each player’s cards in an array.

Step 2: Comparing Cards and Calculating Scores

To compare the cards, we use a for loop to check each pair of cards from both players. For each turn, if Player 1’s card is larger, we add the values of both cards to Player 1’s score; if Player 2’s card is larger, no value is added.

var player1Score = 0

for i in 0.. player2Cards[i] {
        player1Score += player1Cards[i] + player2Cards[i]
    }
}

Step 3: Outputting the Result

After comparing all the cards, we output Player 1’s total score.

print(player1Score)

Complete Code

let n = Int(readLine()!)!
let player1Cards = readLine()!.split(separator: " ").map { Int($0)! }
let player2Cards = readLine()!.split(separator: " ").map { Int($0)! }

var player1Score = 0

for i in 0.. player2Cards[i] {
        player1Score += player1Cards[i] + player2Cards[i]
    }
}

print(player1Score)

Considerations

This problem can be simply solved by iterating through the array and performing the necessary calculations, resulting in a time complexity of O(N). Of course, the way cards are added and the rules for winning may vary depending on the game’s rules, but the basic structure will be similar.

Conclusion

In this course, we solved a card game problem using Swift. Well-defined game rules and designing the appropriate algorithm are very useful practice for actual coding tests. Other algorithm problems can also be approached similarly, so I encourage you to practice and tackle various problems!

Problem Description

This problem is related to graphs, which often appear in coding tests, and it will focus on understanding friendships.
Friendships can be represented as ‘bidirectional edges’, and in this problem, we will implement an algorithm to output
the friends of a specific friend based on given friendships.

Problem

Problem Description: There are N friends. Each friend considers each other a friend, and the friendships
are given in pairs. Given these friendships, write a program that outputs the friend list of a specific friend.
However, duplicate friends should be excluded.

Input Format:
– The first line contains two integers N (1 ≤ N ≤ 100) and M (1 ≤ M ≤ 1000).
– The next M lines consist of two integers A and B that represent the friendships.
– A and B are the numbers denoting friends, and A ≠ B always holds.

Output Format:
– Output the friend list of a specific friend K (1 ≤ K ≤ N) separated by spaces.

Example Input

5 5
1 2
1 3
2 4
3 4
4 5
3

Example Output

2 4

Problem Solving Process

Step 1: Understanding the Problem

To understand the problem, let’s think about how we can represent the given friendships.
Friendships can be represented as a graph, where ‘friends’ are ‘nodes’ and friendships are ‘edges’.
This allows us to easily find each friend’s friend list.

Step 2: Choosing a Data Structure

An ‘adjacency list’ is appropriate for representing friendships.
We can use a dictionary or an array to store each friend’s friend list.
In this problem, we will use an array with friend numbers as indices.

Step 3: Implementation

Now, let’s implement the code in Swift to solve the problem.
First, we will take the input and build an adjacency list to represent friendships, then write a program
that outputs the friend list of a specific friend K.

import Foundation

func main() {
    // Input
    let firstLine = readLine()!.split(separator: " ").map { Int($0)! }
    let N = firstLine[0] // Number of friends
    let M = firstLine[1] // Number of friendships
    
    // Array to store friendships (adjacency list)
    var friends = [[Int]](repeating: [], count: N + 1)
    
    // Input friendships
    for _ in 0..

5 5
1 2
1 3
2 4
3 4
4 5
3

2 4

4 4
1 2
2 3
3 4
4 1
1

2 4

4 4
1 2
3 4
2 3
1 4
2

1 3