-
-
Save NeoSPU/69bc08fcdd24b459b2da86c752e1c5aa to your computer and use it in GitHub Desktop.
import UIKit | |
import PlaygroundSupport | |
//1 | |
print("=============== # 1 ===============\n") | |
enum Rank: Int { | |
case ace = 1, two, three, four, five | |
case six, seven, eight, nine, ten | |
case jack, queen, king | |
func description() -> String { | |
switch self { | |
case .ace: | |
return "ace" | |
case .two: | |
return "2" | |
case .three: | |
return "3" | |
case .four: | |
return "4" | |
case .five: | |
return "5" | |
case .six: | |
return "6" | |
case .seven: | |
return "7" | |
case .eight: | |
return "8" | |
case .nine: | |
return "9" | |
case .ten: | |
return "10" | |
case .jack: | |
return "jack" | |
case .queen: | |
return "queen" | |
case .king: | |
return "king" | |
} | |
} | |
} | |
enum Suit: String { | |
case spade = "\u{2664}" | |
case heart = "\u{2661}" | |
case diamond = "\u{2662}" | |
case club = "\u{2667}" | |
func description() -> String { | |
switch self { | |
case .spade: | |
return rawValue | |
case .heart: | |
return rawValue | |
case .diamond: | |
return rawValue | |
case .club: | |
return rawValue | |
} | |
} | |
} | |
struct Card { | |
var rank: Rank | |
var suit: Suit | |
func description() -> String { | |
return "The \(rank.description()) of \(suit.description())" | |
} | |
} | |
struct CardInDeck { | |
var randomCard: String = "" | |
var rank: String = "" | |
mutating func findRandomCardToDeck() -> String { | |
let suitsIndex: [String] = [Suit.diamond.description(), Suit.club.description(), Suit.spade.description(), Suit.heart.description()] | |
randomCard = String(suitsIndex[Int(arc4random_uniform(4))]) | |
let r = Rank(rawValue: Int(arc4random_uniform(14))) | |
if let r1 = r?.description() { | |
rank = r1 | |
} | |
randomCard = rank + randomCard | |
return randomCard.capitalized | |
} | |
} | |
struct CardsInHand { | |
var hendCard = [String]() | |
var c = CardInDeck() | |
var cardsInHand: String = "" | |
var ExpectedNumberOfCards = 5 | |
mutating func takeCards() -> String { | |
while ExpectedNumberOfCards != 0 { | |
let count = c.findRandomCardToDeck() | |
ExpectedNumberOfCards -= 1 | |
if hendCard.contains(count) { | |
ExpectedNumberOfCards += 1 | |
} | |
else { | |
hendCard.append(count) | |
} | |
} | |
for item in hendCard { | |
cardsInHand = cardsInHand + item + " " | |
} | |
print(cardsInHand) | |
return cardsInHand | |
} | |
} | |
var h = CardsInHand() | |
h.takeCards() | |
// mutating func description2() -> String { | |
// print("Ваша раздача #2 из \(numberOfCard) карт:\n") | |
// var indexSuit: Int = 0 | |
// var indexRank: Int = 0 | |
// var returnRandomCard: String = "" | |
// var distributionOfCards = [String]() | |
// | |
// while numberOfCard != 0 { | |
// numberOfCard -= 1 | |
// indexSuit = Int(arc4random_uniform(4)) | |
// indexRank = Int(arc4random_uniform(14)) | |
// | |
// var suitArrayUnicodIndex: [String] = ["\u1F0A", "\u1F0B", "\u1F0C", "\u1F0D"] | |
// var rankedArrayUnicodIndex: [String] = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"] | |
// | |
// returnRandomCard = suitArrayUnicodIndex[indexSuit] + rankedArrayUnicodIndex[indexRank] | |
// | |
// if distributionOfCards.contains(returnRandomCard) { | |
// numberOfCard += 1 | |
// } | |
// else { | |
// distributionOfCards.append(returnRandomCard) | |
// } | |
// } | |
// returnRandomCard = "" | |
// | |
// for item in distributionOfCards.sorted() { | |
// returnRandomCard = returnRandomCard item | |
// | |
// } | |
// | |
// | |
// return returnRandomCard | |
// } | |
//2 | |
print("=============== # 2 ===============\n") | |
class Player { | |
enum Direction: Int { | |
case up = 0 | |
case down = 1 | |
case left = 2 | |
case right = 3 | |
} | |
let name: String | |
var position: (x: Int, y: Int) | |
init(Name name: String) { | |
self.name = name | |
self.position = (0, 0) | |
} | |
func newDirection(_ direction: Direction) -> (x: Int, y: Int) { | |
let moveDirect = direction | |
switch moveDirect { | |
case .up: | |
position.y = position.y - 1 | |
case .down: | |
position.y = position.y + 1 | |
case .left: | |
position.x = position.x - 1 | |
case .right: | |
position.x = position.x + 1 | |
} | |
print(position) | |
return position | |
} | |
func randomChangeOldCoordinat() -> (Direction){ | |
let indexDirection = arc4random_uniform(4) | |
let cross: Direction | |
if indexDirection == 0 { | |
cross = Direction.up | |
} | |
else if indexDirection == 1 { | |
cross = Direction.down | |
} | |
else if indexDirection == 2 { | |
cross = Direction.left | |
} | |
else { | |
cross = Direction.right | |
} | |
return cross | |
} | |
func move(steps: Int) { | |
for _ in 1...steps { | |
let newCoordinat = randomChangeOldCoordinat() | |
let newPosition = newDirection(newCoordinat) | |
print("\(newPosition)") | |
} | |
} | |
} | |
let player1 = Player(Name: "Alex") | |
player1.move(steps: 5) | |
//3 | |
print("=============== # 3 ===============\n") | |
protocol Wallpost { | |
var mailNumber: Int { get set } | |
var mailStatus: String { get set } | |
func messageForSharing() -> String | |
} | |
class Status: Wallpost { | |
var mailNumber: Int | |
var mailStatus: String | |
init(number1: Int) { | |
mailNumber = number1 | |
mailStatus = "Check" | |
} | |
func messageForSharing() -> String { | |
if mailNumber != 0 { | |
mailStatus = "Received" | |
} | |
return self.mailStatus | |
} | |
} | |
class Post: Wallpost { | |
var mailNumber: Int | |
var mailStatus: String | |
init(number2: Int) { | |
mailNumber = number2 | |
mailStatus = "Is published" | |
} | |
func messageForSharing() -> String { | |
if mailNumber == 10 { | |
mailStatus = "Mail is On The Wall" | |
} | |
return mailStatus | |
} | |
} | |
let wall = Post(number2: 10) | |
wall.messageForSharing() | |
let statusMail = Status(number1: 0) | |
statusMail.messageForSharing() | |
4 | |
print("=============== # 4 ===============\n") | |
protocol Vehicle { | |
var speed: Int { get } | |
var capacity: Int { get } | |
static var cost: Int { get } | |
func priceFromTime() -> (time: Int, cost: Int) | |
} | |
extension Vehicle { | |
static var cost: Int { | |
return 10 | |
} | |
} | |
class Aircraft: Vehicle { | |
var speed: Int = 850 | |
var capacity: Int = 150 | |
var cost: Int = 100 | |
var distance: Int = 0 | |
var passengers: Int = 0 | |
init(distance: Int, passengers: Int) { | |
self.distance = distance | |
self.passengers = passengers | |
} | |
func priceFromTime() -> (time: Int, cost: Int) { | |
let time = distance * speed | |
let calculation = cost * distance * passengers | |
let price: (time: Int, cost: Int) = (time: time, cost: calculation) | |
return price | |
} | |
} | |
//let boing1 = Aircraft.cost | |
class Ship: Vehicle { | |
var speed: Int = 40 | |
var capacity: Int = 5500 | |
var cost: Int = 20 | |
var distance: Int = 0 | |
var passengers: Int = 0 | |
init(distance: Int, passengers: Int) { | |
self.distance = distance | |
self.passengers = passengers | |
} | |
func priceFromTime() -> (time: Int, cost: Int) { | |
let time = distance * speed | |
let calculation = Ship.cost * distance * passengers | |
let price: (time: Int, cost: Int) = (time: time, cost: calculation) | |
return price | |
} | |
} | |
class Helicopter: Vehicle { | |
var speed: Int = 330 | |
var capacity: Int = 20 | |
static var cost: Int = 100 | |
var distance: Int = 0 | |
var passengers: Int = 0 | |
init(distance: Int, passengers: Int) { | |
self.distance = distance | |
self.passengers = passengers | |
} | |
func priceFromTime() -> (time: Int, cost: Int) { | |
let time = distance * speed | |
let calculation = Helicopter.cost * distance * passengers | |
let price: (time: Int, cost: Int) = (time: time, cost: calculation) | |
return price | |
} | |
} | |
class Car: Vehicle { | |
var speed: Int = 120 | |
var capacity: Int = 4 | |
var distance: Int = 0 | |
var passengers: Int = 0 | |
init(distance: Int, passengers: Int) { | |
self.distance = distance | |
self.passengers = passengers | |
} | |
func priceFromTime() -> (time: Int, cost: Int) { | |
let time = distance * speed | |
let calculation = Car.cost * distance * passengers | |
let price: (time: Int, cost: Int) = (time: time, cost: calculation) | |
return price | |
} | |
} | |
let boeing = Aircraft(distance: 1200, passengers: 300) | |
let mirage = Ship(distance: 2000, passengers: 300) | |
let mi8 = Helicopter(distance: 300, passengers: 15) | |
let bmw = Car(distance: 430, passengers: 7) | |
let differentVenchil: [Vehicle] = [boeing, mirage, mi8, bmw] | |
for value in differentVenchil { | |
print(value.priceFromTime()) | |
} |
SuitOfCards: лучше присвоить ассоц. значения "\u{2664}" напрямую .
case heart = "\u{2664}"
CardInDeck: numberOfCard - хорошо, но в такое случае при втором вызове description1() будет результат что у пользователя 0 карт.
Лучше разделить отдельно 2 объекта - карта и пользователь с набором карт в руке. В таком случае у пользователя будет массив карт которые можно отобразить
func makeRandomMove():
Выполняет 10 перемещений, хотя называется сделать 1 шаг - не предполагаемое/очевидное поведение. Лучше разделить в 2 метода - первый делает 1 шаг, второй - принимает параметр количества шагов и вызывает первый метод.
Так как Direction содержит ассоциативные значение можно создать само значение при помощи конструктора: Direction(rawValue: 1)
- Player.init(Имя: "Alex") ---> Player(Имя: "Alex")
- Имя ---> имя
- настоятельно рекомендую все писать на англ
"static var cost: Int = 100 //так и не совсем понял для каких случаев статик к требуемым свойствам применяется" - когда свойство относится не к каждому конкретному объекту а ко всему типу данных, ко всем возможным объектам(общее для всех)
static var cost: Int = Car.cost - очень странная запись. Если работает - то удивительно. В любом случае так делать не нужно. Если хочешь использовать значение свойства по умолчанию - эту строку в реализации вообще нужно удалить
Aircraft.init() ---> нужно избавляться от init
Избегать явных вызовов init