Calculadora con Swift

Modo consola

Primer número: 1
Operación: +
Segundo número: 4
Resultado: 5

Primer número: r
Error

Primer número: 4
Operación: m
Error

Primer número: 1
Operación: /
Segundo número: 0
No se puede dividir por cero

Primer número: 4
Operación: -
Segundo número: 6
Resultado: -2

Primer número: 
...
enum OperacionCalculadora {
    case sumar, restar, multiplicar, dividir
    
    init?(_ boton:String) {
        switch boton {
            case "+": self = .sumar
            case "-": self = .restar
            case "*": self = .multiplicar
            case "/": self = .dividir
            default: return nil
        }
    }
    
    func calcular(_ n1: Int, _ n2: Int) -> Int {
        switch self {
            case .sumar: return n1 + n2
            case .restar: return n1 - n2
            case .multiplicar: return n1 * n2
            case .dividir: return n1 / n2
        }
    }
}

var n1:Int? = 0, n2:Int? = 0
var operacion:OperacionCalculadora? = nil
var pantalla:String = "0"

func actualizaNumero(_ boton:String) -> Int? {
    n1 = Int(pantalla)
    n2 = Int(boton)
    if n2 != nil {
        pantalla = boton
    }
    return n2
}

func actualizaOperacion(_ boton:String) -> OperacionCalculadora? {
    operacion = OperacionCalculadora(boton)
    return operacion
}

func realizaCalculo() -> Bool {
    if n2 == 0 && operacion == .dividir {
        print("No se puede dividir por cero\n")
        return false
    }
    pantalla = String(operacion!.calcular(n1!, n2!))
    return true
}

repeat {
    print("Primer número: ", terminator:"")
    if actualizaNumero(readLine()!) == nil {
        print("Error\n")
        continue 
    }
    print("Operación: ", terminator:"")
    if actualizaOperacion(readLine()!) == nil {
        print("Error\n")
        continue
    }
    print("Segundo número: ", terminator:"")
    if actualizaNumero(readLine()!) == nil {
        print("Error\n")
        continue 
    }
    
    if realizaCalculo() == true {
        print("Resultado: " + pantalla + "\n")
    }
} while true

Aplicación iOS

//
//  ViewController.swift
//  Calculadora
//

import UIKit

class ViewController: UIViewController {
    
    @IBOutlet var pantalla: UILabel!
    
    override func viewDidLoad() {
        super.viewDidLoad()
    }
    
    enum OperacionCalculadora {
        case sumar, restar, multiplicar, dividir
        
        init?(_ boton:String) {
            switch boton {
                case "+": self = .sumar
                case "-": self = .restar
                case "*": self = .multiplicar
                case "/": self = .dividir
                default: return nil
            }
        }
        
        func calcular(_ n1: Int, _ n2: Int) -> Int {
            switch self {
                case .sumar: return n1 + n2
                case .restar: return n1 - n2
                case .multiplicar: return n1 * n2
                case .dividir: return n1 / n2
            }
        }
    }
    
    var n1:Int? = 0, n2:Int? = 0, borraNumero = false
    var operacion:OperacionCalculadora? = nil
    
    // Ejecutar al pulsar los botones del 0 al 9
    @IBAction func actualizaNumero(_ boton:UIButton) {
        if pantalla.text == "0" || borraNumero == true {
            pantalla.text = ""
            borraNumero = false
        }
        pantalla.text = pantalla.text! + boton.currentTitle!
    }
    
    // Ejecutar al pulsar los botones de +, -, *, /
    @IBAction func actualizaOperacion(_ boton:UIButton) {
        operacion = OperacionCalculadora(boton.currentTitle!)
        n1 = Int(pantalla.text!)!
        borraNumero = true
    }
    
    // Ejecutar al pulsar el botón de =
    @IBAction func realizaCalculo() {
        n2 = Int(pantalla.text!)!
        if n2 == 0 && operacion == .dividir {
            muestraError("No se puede dividir por cero")
        }
        else {
            pantalla.text = String(operacion!.calcular(n1!, n2!))
        }
        borraNumero = true
    }

    func muestraError(_ mensaje:String) {
        let alert = UIAlertController(title:"Error", message:mensaje, preferredStyle:.alert)
        
        let action = UIAlertAction(title:"OK", style:.default, handler:nil)
        
        alert.addAction(action)
        
        show(alert, sender:nil)
    }
}

Swift – Ejercicios resueltos (II)

Funciones y operadores aritméticos

Sumar dos números y devolver el resultado:

func suma(_ num1:Int, _ num2:Int) -> Int {
    return num1 + num2
}
let num1 = 5
let num2 = 8
print("\(num1) + \(num2) = \(suma(num1, num2))")

Calcular el número de segundos que suman en total un número determinado de años:

func segundosAnyo(_ anyos:Int) -> Int {
    let dias = 365
    let horas = 24
    let segundos = 3600
    return dias * horas * segundos * anyos
}
let anyos = 3
print("La cantidad de segundos en \(anyos) años es \(segundosAnyo(anyos))")

Calcular la cantidad total de píxeles que tiene una pantalla dada su altura y anchura en píxeles:

func pixeles(alto:Int, ancho:Int) -> Int {
    return(alto * ancho)
}
let alto = 720
let ancho = 480
print("La cantidad de píxeles de una pantalla de \(alto)x\(ancho) es \(pixeles(alto:720, ancho:480))")

Intercambiar el valor de dos variables:

func intercambiar(_ a:inout Int, _ b:inout Int) {
    let aux = a
    a = b
    b = aux
}
var num1 = 5
var num2 = 10
intercambiar(&num1, &num2)
print("El primer número es: \(num1) y el segundo es: \(num2)")

Dado un número, imprimir el último dígito:

func ultimo(_ num:Int) -> Int {
    return num % 10
}
let num = 2479
print("La última cifra de \(num) es \(ultimo(num))")

Dada la edad de un perro, calcular la edad equivalente en humanos, teniendo en cuenta que un año para una persona equivale a 7 años para un perro:

func edadHumano(_ edadPerro:Int) -> Int {
    return edadPerro * 7
}
let edadPerro = 7
print("\(edadPerro) años de un perro equivalen a \(edadHumano(edadPerro)) años de un humano")

Funciones y control de flujo

Dado un número, comprobar si es par o no:

func esPar(_ num:Int) -> Bool {
    return num % 2 == 0
}

let num = 24

// Con if
if esPar(num) {
    print("El numero \(num) es par")
}
else {
    print("El numero \(num) es impar")
}

// Con el operador ?
print("El numero \(num) es " + (esPar(num) ? "par" : "impar"))

Dados dos números, comprobar si el primero es divisible entre el segundo:

func esDivisible(_ num1:Int, _ num2:Int) -> Bool {
    return num2 != 0 && num1 % num2 == 0
}

let num1 = 3
let num2 = 1

// Con if
if esDivisible(num1, num2) {
    print("El número \(num1) es divisible entre \(num2)")
}
else {
    print("El número \(num1) no es divisible entre \(num2)")
}

// Con el operador ?
print("El número \(num1) \(esDivisible(num1, num2) ? "" : "no") es divisible entre \(num2)")

Funciones y tuplas

Dada una cantidad determinada de chicos y chicas, calcular el porcentaje de cada uno respecto al total:

func calcularPorcentajes(hombres:Int, mujeres:Int) -> (hombres:Int, mujeres:Int) {
    let total = hombres + mujeres
    let porcentajeHombres = (hombres * 100) / total
    let porcentajeMujeres = (mujeres * 100) / total

    return (porcentajeHombres, porcentajeMujeres)
}

let hombres = 12
let mujeres = 15
let porcentaje = calcularPorcentajes(hombres:12, mujeres:15)

print("De \(hombres + mujeres) personas, \(mujeres) son mujeres y \(hombres) son hombres, es decir, \(porcentaje.hombres)% de hombres y \(porcentaje.mujeres)% de mujeres")

Disponemos de dos tuplas de tipo (Int,Int) que representan dos fracciones. El primer valor en cada tupla representa el numerador y el segundo valor representa el denominador. Utilizando una función, crear una nueva tupla también de tipo (Int,Int) que contenga el resultado de sumar las dos fracciones:

func suma(_ fraccion1:(Int, Int), _ fraccion2:(Int, Int)) -> (Int, Int) {
    let numerador = fraccion1.0 * fraccion2.1 + fraccion2.0 * fraccion1.1
    let denominador = fraccion1.1 * fraccion2.1 

    return (numerador, denominador)
}

let fraccion1 = (1, 2)
let fraccion2 = (2, 3)
print("La suma de \(fraccion1) y \(fraccion2) es \(suma(fraccion1, fraccion2)))

Escribir el código necesario para jugar a piedra, papel, tijeras, cumpliendo las siguientes especificaciones:

  • Se debe definir una enumeración con tres posibles casos:  .piedra.papel.tijeras.
  • Se debe definir una segunda enumeración con tres posibles casos:  .gana.empata.pierde.
  • Escribir una función que reciba la elección de cada jugador y devuelva el resultado correspondiente al primer jugador.
enum Mano {
    case piedra, papel, tijeras
}

enum Resultado {
    case gana, empata, pierde
}

func jugar(jugador1:Mano, jugador2:Mano) -> Resultado {
    if jugador1 == jugador2 { return .empata }

    if jugador1 == .piedra  && jugador2 == .tijeras || 
       jugador1 == .papel   && jugador2 == .piedra  ||
       jugador1 == .tijeras && jugador2 == .papel { return .gana }

    return .pierde
}

print(jugar(jugador1:.papel, jugador2:.tijeras))

Parámetros variádicos

Calcular la suma de un número indeterminado de fracciones:

func suma(_ fracciones:(Int, Int)...) -> (Int, Int) {
    var resultado = (0, 1)

    for fraccion in fracciones {
        resultado.1 *= fraccion.1
    }
    for fraccion in fracciones {
        resultado.0 += (resultado.1 / fraccion.1) * fraccion.0
    }    

    return resultado
}

print(suma((1,2), (3,4), (5,2), (4,3)))

Swift – Ejercicios resueltos (I)

Variables, constantes y operadores aritméticos

Dadas dos variables, calcular la suma, almacenar el resultado en otra variable e imprimir el resultado:

let num1 = 5
let num2 = 8
let suma = num1 + num2
print("\(num1) + \(num2) = \(suma)")

Calcular el número de segundos en un año almacenando dicho valor en una variable:

let dias = 365
let horas = 24
let segundos = 3600
let segundosAnyo = dias * horas * segundos
print("La cantidad de segundos en un año es \(segundosAnyo)")

Partiendo de la anchura y la altura de una pantalla en píxeles, calcular el número total de píxeles de dicha pantalla guardando el resultado en otra variable:

let alto = 720
let ancho = 480
let pixeles = alto * ancho
print("La cantidad de pixeles es \(pixeles)")

Dadas dos variables, intercambiar sus valores:

var num1 = 4
var num2 = 8

let aux = num2
num2 = num1
num1 = aux

print("El primer numero es: \(num1) y el segundo es: \(num2)")

Dado un número, imprimir el último dígito:

let num = 2479
print("La última cifra de \(num) es \(num % 10)")

Dada la edad de un perro, imprimir la edad equivalente en humanos, teniendo en cuenta que un año para una persona equivale a 7 años para un perro:

let edadPerro = 7
let edadHumano = edadPerro * 7
print("\(edadPerro) años de un perro equivalen a \(edadHumano) años de un humano")

Dada una cantidad determinada de chicos y chicas, imprimir el porcentaje de cada uno respecto al total:

let hombres = 12
let mujeres = 15
let total = hombres + mujeres

let porcentajeHombres = (hombres * 100) / total
let porcentajeMujeres = (hombres * 100) / total

print("De \(total) alumnos, \(mujeres) son mujeres y \(hombres) son hombres, es decir, \(porcentajeHombres)% de hombres y \(mujeres)% de mujeres")

Control de flujo

Dados dos números, compararlos e imprimir el mayor de ellos:

let num1 = 3
let num2 = 4
if num1 > num2 {
    print("El número \(num1) es mayor que \(num2)")
}
else if num2 > num1 {
    print("El número \(num2) es mayor que \(num1)")
}

Dado un número, imprimir un mensaje indicando si es par o impar:

let num = 23

// Con if
if num % 2 == 0 {
    print("El numero \(num) es par")
}
else {
    print("El numero \(num) es impar")
}

// Con el operador ?
print("El numero \(num) es " + (num % 2 == 0 ? "par" : "impar"))

Dados dos números, imprimir un mensaje diciendo si el primero es divisible entre el segundo o no:

let num1 = 3
let num2 = 1

if num2 != 0 && num1 % num2 == 0  {
    print("El número \(num1) es divisible entre \(num2)")
}
else if num2 != 0 && num1 % num2 != 0 {
    print("El número \(num1) no es divisible entre \(num2)")
}
else {
    print("No se puede dividir entre 0")
}

Dadas tres variables, comparar el valor que contienen e indicar si todas ellas son diferentes, o si por el contrario, dos variables o las tres contienen el mismo valor:

var a = 2
var b = 2
var c = 2

if (a == b) || (a == c) || (b == c) {
    print("Al menos dos variables tienen el mismo valor")
} else {
    print("Todas las variables tienen valores diferentes")
}

Disponemos de dos variables que indican los días que hace que hemos comprado leche y huevos respectivamente. Si hace más de 2 días que compramos la leche deberemos imprimir que ya está caducada, y si hace más de 7 días que compramos los huevos, imprimiremos que están caducados. Si la leche y los huevos no estén caducados, se deberá imprimir un mensaje indicando que ambos están en buen estado:

var diasLeche = 6
var diasHuevos = 12

if diasLeche <= 2 && diasHuevos <= 7 {
    print("La leche y los huevos están en buen estado")
} else {
    if diasLeche > 2 {
        print("La leche está caducada")
    }
    if diasHuevos > 7 {
        print("Los huevos están caducados")
    }
}

Dado un entero que indique un año cualquiera, indicar si dicho año es bisiesto o no, teniendo en cuenta que un año es bisiesto si es divisible entre 4 y no es divisible entre 100, y también si es divisible entre 400 (2000 y 2400 sí son bisiestos. 2100, 2200 y 2300 no lo son):

let anyo = 2018

let divisibleEntre4 = anyo % 4 == 0
let divisibleEntre100 = anyo % 100 == 0
let divisibleEntre400 = anyo % 400 == 0

if divisibleEntre4 && (!divisibleEntre100 || divisibleEntre400) {
    print("El año \(anyo) es bisiesto")    
}
else {
    print("El año \(anyo) no es bisiesto") 
}

Generar un número aleatorio entre 1 y 3 (ambos incluidos) simulando que lanzamos una moneda, de forma que se imprima uno de los tres posibles valores (cara, cruz o canto). Se puede utilizar la función random de la siguiente forma: Int.random(in:1...3)

let moneda = Int.random(in:1...3)

if      moneda == 1 { print("Cara")  } 
else if moneda == 2 { print("Cruz")  } 
else                { print("Canto") }

Dados cuatro valores numéricos, imprimir el más pequeño:

let a = 7, b = 4, c = 2, d = 6

var min = a

if b < min { min = b }

if c < min { min = c }

if d < min { min = d }

print(min)

Imprimir si un número es divisible entre 3 y 5 al mismo tiempo:

let numero = 135

// Con if
if numero % 3 == 0 && numero % 5 == 0 {
    print("\(numero) es divisible entre 3 y 5")
} else {
    print("\(numero) no es divisible entre 3 y 5")
}

// Con el operador ?
print("\(numero) \(numero % 3 == 0 && numero % 5 == 0 ? "" : "no") es divisible entre 3 y 5")

Escribir un switch que imprima las siguientes cadenas utilizando los siguientes intervalos dependiendo de una variable que contiene una distancia:

  1. «Aquí» si la distancia es 0.
  2. «Bastante cerca» si la distancia es mayor que 0 y menor que 5.
  3. «Cerca» si la distancia está entre 5 y 15.
  4. «Más o menos cerca» si la distancia está entre 15 y 40, ambos incluidos.
  5. «Lejos» si la distancia es mayor que 40.
let distancia:UInt = 15

switch distancia {
    case 0:
        print("Aquí")
    case 1..<5:
        print("Bastante cerca")
    case 5..<15:
        print("Cerca")
    case 15...40:
        print("Más o menos cerca")
    default:
        print("Lejos")
}

Tenemos una cadena que indica la descripción de un animal. Si el animal es un «gato» debemos imprimir un mensaje indicándolo. Si es un «gato muy grande», debemos decir que el animal tal vez sea un tigre, y en caso contrario indicaremos que es otro tipo de animal:

let animal = "gato muy grande"

switch animal {
    case "gato":
        print("El animal es un gato")
    case "gato muy grande":
        print("El animal tal vez es un tigre")
    default:
        print("El animal no es ni un gato ni un tigre")
}

Utilizando un switch imprimir la cadena «Eres un superhéroe» si tu nombre es «Clark Kent» o «Bruce Wayne», y «Eres una persona normal» en caso contrario:

let nombre = "Bruce Wayne"

switch nombre {
    case "Clark Kent", "Bruce Wayne":
        print("Eres un superhéroe")
    default:
        print("Eres una persona normal")
}

Arrays

Crear de dos formas diferentes un array que contenga los siguientes enteros 5, 8, 10, 16, 23, 40:

var array1: [Int] = [5, 8, 10, 16, 23, 40]
var array2 = [5, 8, 10, 16, 23, 40]
print(array1)
print(array2)

Crear de dos formas diferentes un array que no pueda ser modificado y que contenga los siguientes enteros: 5, 8, 10, 16, 23, 40

let array1: [Int] = [5, 8, 10, 16, 23, 40]
let array2 = [5, 8, 10, 16, 23, 40]
print(array1)
print(array2)

Añade de dos formas diferentes los valores 118, 137, y 5615 al final del siguiente array: [5, 8, 10, 16, 23, 40]

var array1 = [5, 8, 10, 16, 23, 40]
var array2 = [5, 8, 10, 16, 23, 40]
let array3 = [118, 137, 5615]

array1.append(contentsOf: array3)
array2 += array3

print(array1)
print(array2)

Reemplazar el valor 16 con el valor 45 en el siguiente array: [5, 8, 10, 16, 23, 40]

var array = [5, 8, 10, 16, 23, 40]

array[3] = 45 

print(array)

Reemplaza los valores 8, 10, y 16 con los valores 1, 2, 3, 4, 5 y 6 en el siguiente array: [5, 8, 10, 16, 23, 40]

var array = [5, 8, 10, 16, 23, 40]

array[1...3] = [1, 2, 3, 4, 5, 6]

print(array)

Enumeraciones y tuplas

Definir un array de tuplas que tengan 2 campos cada una, para guardar el nombre y primer apellido de 5 personas:

var personas = [(nombre: "Juan", apellido: "Rubio"),
                (nombre: "Pepe", apellido: "García"),
                (nombre: "Luis Enrique", apellido: "Peinado"),
                (nombre: "Álvaro", apellido: "Sánchez"),
                (nombre: "Pablo", apellido: "Ruiz")]                          

for persona in personas { print(persona) }

Partiendo de dos valores cualesquiera, formar una tupla indicando cuál de esos dos valores es el menor y cuál el mayor:

let a = 5, b = 6
let resultado = a < b ? (menor:a, mayor:b) : (menor:b, mayor:a)
print(resultado)

Definir una enumeración para tener un listado de varios tipos de dispositivos de Apple:

enum DispositivoApple {
    case iPhone
    case iPad
    case iWatch
}

let miDispositivo = DispositivoApple.iPhone
print(miDispositivo)

Disponemos de un array que indica los movimientos del personaje de un videojuego, y también conocemos su posición original. Un paso .arriba incrementará la coordenada y en 1. Un paso .abajo decrementará la coordenada y en 1. Un paso a la  .derecha incrementará la coordenada x en 1. Un paso a la .izquierda decrementará la coordenada x en 1. Se debe imprimir la ubicación final del personaje después de realizar los movimientos indicados:

enum Direccion {
    case arriba, abajo, izquierda, derecha
}

var ubicacion = (x: 0, y: 0)
let pasos:[Direccion] = [.abajo, .abajo, .derecha, .arriba]

for paso in pasos {
    switch paso {
        case .arriba:    ubicacion.y += 1
        case .abajo:     ubicacion.y -= 1
        case .derecha:   ubicacion.x += 1
        case .izquierda: ubicacion.x -= 1
    }
}

print(ubicacion)

Escribir el código necesario para jugar a piedra, papel, tijeras, utilizando una enumeración con los tres posibles casos:  .piedra.papel.tijeras:

enum Mano {
    case piedra, papel, tijeras
}

let jugador1 = Mano.papel
let jugador2 = Mano.tijeras

if jugador1 == jugador2 { 
    print("Empate") 
}
else if jugador1 == .piedra  && jugador2 == .tijeras || 
        jugador1 == .papel   && jugador2 == .piedra  ||
        jugador1 == .tijeras && jugador2 == .papel { 
    print("Gana jugador 1") 
}
else { 
    print("Pierde jugador 1") 
}

Utilizando una enumeración de tipos de monedas y un array de tuplas que especifique el número de monedas que tenemos de cada tipo, calcular e imprimir el cantidad total de dinero:

enum TipoMoneda {
    case cents5, cents10, cents20, cents50, euro1, euro2
}

let monedas:[(cantidad:Int,tipo:TipoMoneda)] = [(2,.cents10), (5,.euro1), (3,.euro2)]

var total = 0

for (cantidad, tipo) in monedas {
    switch tipo {
        case .cents5:
            print("\(cantidad) monedas de 5 céntimos")
            total += cantidad * 5
        case .cents10:
            print("\(cantidad) monedas de 10 céntimos")
            total += cantidad * 10
        case .cents20:
            print("\(cantidad) monedas de 20 céntimos")
            total += cantidad * 20
        case .cents50:
            print("\(cantidad) monedas de 50 céntimos")
            total += cantidad * 50
        case .euro1:
            print("\(cantidad) monedas de 1 euro")
            total += cantidad * 100
        case .euro2:
            print("\(cantidad) monedas de 2 euros")
            total += cantidad * 200
    }
}

print("Total: \(Double(total)/100.0) euros")

Disponemos de un array con los bocadillos que quieren pedir unos amigos en un bar. Antes de llamar al camarero se debe crear otro array que contenga tuplas indicando el tipo de bocadillo y el número de bocadillos que quieren pedir de ese tipo:

enum TipoBocadillo {
    case tortilla, calamares, queso
}

let bocadillos:[TipoBocadillo] = [.tortilla, .tortilla, .calamares, .queso, .calamares, .calamares, .queso]

var listaCamarero:[(tipo:TipoBocadillo, cantidad:Int)] = []

for bocadillo in bocadillos {
    var i = 0
    while i < listaCamarero.count {
        if (listaCamarero[i].tipo == bocadillo) {
            listaCamarero[i].cantidad += 1
            break
        }
        i += 1
    } 
    if i >= listaCamarero.count {
        listaCamarero += [(bocadillo, 1)]        
    }
}

for bocadillo in listaCamarero {
    print("\(bocadillo.cantidad) bocadillos de \(bocadillo.tipo)")
}