Last active
October 22, 2017 10:53
-
-
Save NeoSPU/69bc08fcdd24b459b2da86c752e1c5aa to your computer and use it in GitHub Desktop.
HomeWork_7
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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()) | |
} |
- Player.init(Имя: "Alex") ---> Player(Имя: "Alex")
- Имя ---> имя
- настоятельно рекомендую все писать на англ
"static var cost: Int = 100 //так и не совсем понял для каких случаев статик к требуемым свойствам применяется" - когда свойство относится не к каждому конкретному объекту а ко всему типу данных, ко всем возможным объектам(общее для всех)
static var cost: Int = Car.cost - очень странная запись. Если работает - то удивительно. В любом случае так делать не нужно. Если хочешь использовать значение свойства по умолчанию - эту строку в реализации вообще нужно удалить
Aircraft.init() ---> нужно избавляться от init
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
func makeRandomMove():
Выполняет 10 перемещений, хотя называется сделать 1 шаг - не предполагаемое/очевидное поведение. Лучше разделить в 2 метода - первый делает 1 шаг, второй - принимает параметр количества шагов и вызывает первый метод.
Так как Direction содержит ассоциативные значение можно создать само значение при помощи конструктора: Direction(rawValue: 1)