import UIKit

var str = "Hello, playground"

var aString = "1";
var anInt = 1;
var aFloat = 1.001;

let constString: String = "2";
let constInt: Int = 2;
let constFloat: Float = 2.002;

let constStringConc1: String = "\(aString) \(constString) \(aFloat)";
let constStringConc2: String = aString + " " + constString + " " + String( aFloat );

var array = ["normal array"];
var associationDictionary = [Int]();

array.append("second argument");
associationDictionary.append(3);

var lottoRes = [String: [Int]]();
lottoRes["29-11-14"] = [4, 5, 21, 30, 31, 49];
lottoRes["27-11-14"] = [5, 8, 10, 19, 23, 40];

var associationDictionary2 = [Character: Int]();
associationDictionary2[Character("a")] = 1;
associationDictionary2["b"] = 2;
associationDictionary2["c"] = 3;

var przes: Int = 65;
var associationDictionary3 = [Character: Int]();

for i in 0...25 {
    associationDictionary3[Character(UnicodeScalar(UInt8(i+przes)))] = i;
}

print(associationDictionary3);

for (date, numbers) in lottoRes {
    print("Losowanie dnia \(date):");
    for number in numbers {
        print("- \(number)");
    }
}

func NWD(_ l1: Int, _ l2: Int) -> Int {
    let mod = l1 % l2;
    if( mod != 0 ) {
        return NWD(l2, mod);
    } else {
        return l2;
    }
}

let nwd1 = NWD(1, 2);
let nwd2 = NWD(10, 5);

func returnKrotka(_ l1: Int, _ l2: Int) -> (Int, Int, Int) {
    let nwd = NWD(l1, l2);
    return (nwd, l1/nwd, l2/nwd);
}

let krotka1 = returnKrotka(1, 2);
let krotka2 = returnKrotka(10, 5);
let krotka3 = returnKrotka(100, 50);

print( "\(returnKrotka(3, 9).0) \(returnKrotka(3, 9).1) \(returnKrotka(3, 9).2) " );
print( "\(krotka3.0) \(krotka3.1) \(krotka3.2) " );

func gaderyPoluki(_ inputChar: Character) -> Character {
    switch inputChar {
    case Character("G"):
        return Character("A");
    case Character("D"):
        return Character("E");
    case Character("R"):
        return Character("Y");
    case Character("P"):
        return Character("O");
    case Character("L"):
        return Character("U");
    case Character("K"):
        return Character("I");
    default:
        return inputChar;
    }
}

var res = gaderyPoluki("G");
res = gaderyPoluki("D");
res = gaderyPoluki("R");
res = gaderyPoluki("P");
res = gaderyPoluki("L");
res = gaderyPoluki("K");

func cipher(_ toCipher: String, _ cipherFunc: (Character) -> Character) -> String {
    var upper: String = toCipher.uppercased();
    var upperChars: [String]() = upper.split(separator: "");
    var ciphered: String = "";
    for i in 0...upperChars.count {
        var char = Character( upperChars[i] );
        ciphered.append( String( cipherFunc( char ) ) );
    }
    return ciphered;
}

var toCipher: String = "gaderypoluki";
var ciphered = cipher( toCipher, gaderyPoluki(_:));

extension String {

    var length: Int {
        return count
    }

    subscript (i: Int) -> String {
        return self[i ..< i + 1]
    }

    func substring(fromIndex: Int) -> String {
        return self[min(fromIndex, length) ..< length]
    }

    func substring(toIndex: Int) -> String {
        return self[0 ..< max(0, toIndex)]
    }

    subscript (r: Range<Int>) -> String {
        let range = Range(uncheckedBounds: (lower: max(0, min(length, r.lowerBound)),
                                            upper: min(length, max(0, r.upperBound))))
        let start = index(startIndex, offsetBy: range.lowerBound)
        let end = index(start, offsetBy: range.upperBound - range.lowerBound)
        return String(self[start ..< end])
    }

}