12Diccionario1.py

# Primer ejemplo de uso de diccionarios
# Un diccionario es como una lista, solo que en lugar de tener
# un índice numérico, puede ser de casi cualquier tipo
# De forma más técnica, se trata de una tabla de Hash (Hash Table)

# Creo un diccionario para traducir números de español a inglés
espanolAIngles = dict()     # Crea un diccionario vacío

# Agrego unos cuantos elementos al diccionario:
# (no se pueden repetir los índices)
espanolAIngles["uno"] = "one"
espanolAIngles["dos"] = "two"
espanolAIngles["tres"] = "three"
espanolAIngles["cuatro"] = "four"
espanolAIngles["cinco"] = "five"

# Muestro lo que tiene el diccionario hasta ahorita
print("Contenido del diccionario\n",espanolAIngles)

# Con el mismo formato de salida, puedo inicializar el diccionario
estados = {"jal":"Jalisco","mich":"Michoacán","cdmx":"Ciudad de México","ver":"Veracruz","coah":"Coahuila"}
estados["son"] = "Sonora"
print("Diccionario de estados:")
print(estados)

# El índice me permite buscar un valor
print("El estado jal es",estados["jal"])

# len me da el número de valores en la lista (clave y valor)
print("La cantidad de estados almacenados es de",len(estados))

# El in nos permite ver si algo está en un diccionario
if "mich" in estados:
    print(estados["mich"],"está en la lista de estados")
else:
    print("Michoacán no está en la lista")
if "chih" not in estados:
    print("Chihuahua no está en la lista")
else:
    print(estados["chih"],"está en la lista")

# Para buscar un valor en la lista, sin conocer la llave (índice), uso values
# Aquí creo una lista con los valores
if "Veracruz" in list(estados.values()):
    print("Veracruz está en la lista")
# Ejemplo del uso de diccionario para contar la cantidad
# de cada letra en un texto
# En estadística diríamos que estamos creando un histograma

palabra = input("Escribe un texto:")    # Pido un texto
dicc = dict()                           # Creo un diccionario vacío
for c in palabra:                       # Hago un ciclo yendo letra por letra de la palabra dada
    if c not in dicc:                   # Si la letra no está en el diccionario...
        dicc[c] = 1                     # ...lo agrego con un valor de 1
    else:                               # Si ya está...
        dicc[c] = dicc[c] + 1           # ...le sumo 1

print("Conteo de palabras:",dicc)       # Muestro el diccionario
# Aquí muestro cómo usar ciclos con un diccionario

# Creo el diccionario con 6 elementos
edades = {"tony":51,"cesar":16,"diego":17,"francisco":18,"erika":15,"mariana":16}

print("Gente menores a 30:")
# uso el for para recorrer la lista y mostrarla al usuario
for llave in edades:
    if edades[llave] < 30:              # Con esto solo muestro los elementos cuya edad es menor a 30
        print(llave,edades[llave])

print("\nMostrando todo en orden:")
# Si quiero mostrar en orden, creo una lista de las llaves en el diccionario
# con el método keys
listaLlaves = list(edades.keys())
# Luego ordeno esta lista
listaLlaves.sort()
# Luego muestro el diccionario en orden
for llave in listaLlaves:
    print(llave,edades[llave])
# Se pueden importar librerías para algunas funciones adicionales
# math tiene funciones matemáticas
import math

# Prueba con funciones que son predeterminadas en Python
# max devuelve el valor máximo de una lista (incluyendo cadenas)
print("Letra más grande: ",max("Buenos días"))
# min devuelve el valor más pequeño
print("Valor menor: ", min([1,6,8,-1,1000,0]))
# len devuelve la longitud de una lista
print("La cadena tiene ",len("Texto de prueba")," letras")
print("Hay ",len([5,9,1,4,2,3,6]), " elementos en la lista")
# Pido un ángulo en grados, convierto a radianes y devuelvo el seno
grados = input("Escribe los grados de un ángulo: ")
radianes = float(grados) * math.pi / 180       # math.pi devuelve el valor de PI
seno = math.sin(radianes)
print("Seno de ", grados, "°  = ", seno)
num = float(input("Escribe un numero: "))
raiz = math.sqrt(num)
print("La raíz cuadrada de", num, " = ", raiz)
# Genero números al azar
# Este import me deja usar el objeto random
import random

print('10 números al azar entre 5 y 30...')
i = 0
while i < 10:
    # random.randint de devuelve un número al azar entre...
    # ...los números que le diga, en este caso, entre 5 y 30.
    print(random.randint(5,30))
    i = i + 1
input('Fin del programa, presione ENTER para salir')
# Ejemplo donde creo mis propias funciones
# def sirve para definir una función
# dentro de los paréntesis pueden ir (o no) parámetros
# Éste no empeza a ejecutarse porque es una definición
def muestraPoema():
    print("EL FUTURO\n\tJulio Cortázar\n\nY sé muy bien que no estarás.\nNo estarás en la calle")
    print("en el murmullo que brota de la noche\nde los postes de alumbrado,")
    print("ni en el gesto de elegir el menú,\nni en la sonrisa que alivia los completos en los subtes")
    print("ni en los libros prestados,\nni en el hasta mañana.")

# Aquí empieza el flujo de la ejecución del programa
muestraPoema()      # Aquí llamo a la función
# Ejemplo #2 de funciones
# Las funciones pueden llevar parámetros
def suma(a,b):
    return a + b    # return es la instrucción que devuelve un valor

# Puedo definir valores default para uno o más parámetros
def multiplica(a,b=2):
    return a * b

num1 = float(input("Escribe un número: "))
num2 = float(input("Escribe otro número: "))
# Llamo a la función suma con dos parámetros
print("La suma de",num1,"y",num2,"es",suma(num1,num2))
# Uso la multiplicación con los dos números
print("La multiplicación de",num1,"y",num2," es igual a",multiplica(num1,num2))
# Ahora uso el valor default del 2do parámetro de multiplica
print("La multiplicación de",num1,"y 2 es",multiplica(num1))
# Ejemplo de ciclos: tabla de multiplicar

try:
    # Pido el número del que quiero la tabla
    num = int(input('Escribe el número del que quiere la tabla: '))
    i = 0
    while i < 11:
        res = i * num
        print(i, ' x ',num,' = ',res)
        i = i + 1
except:
    print('Debe escribir un número')

# Espero a que esciba algo para terminar el programa (y cerrar la ventana)
input('Pulse ENTER para terminar')
# Ejemplo de ciclos y condiciones
# Programa que calcula la suma y promedio de todos los números escritos,
# menos los 9. Y tiene que escribir 99 para salir

print('Cálculo de suma y promedio de números. Se ignora el 9')
# Inicializo la suma y la cantidad de números en 0
suma = 0
cantNums = 0
try:
    # Ciclo infinito
    while True:
        # Pido número y lo convierto a float
        num = float(input('Escribe un número, 99 para salir: '))
        print('num = ', num)
        # Si es 9, lo ignoro (termina el ciclo y lo vuelvo a ejecutar)
        if num == 9:
            print('num es 9')
            continue
        # Si es 99, sale del ciclo
        if num == 99:
            print('num es 99')
            break
        # Si es cualquier otro número, lo sumo e incremento la cantidad de nums
        suma = suma + num
        cantNums = cantNums + 1
    # Muestro la suma, calculo el promedio y también lo muestro
    print('Suma = ', suma)
    prom = suma / cantNums
    print('Promedio = ',prom)
except:
    print('Escriba un número')
# Esto es para que no se cierre la ventana
input('Presione ENTER para finalizar')
# Ejemplo del uso del ciclo for para recorrer listas

# Aquí declaro una lista llamado amigos. Esto lo profundizamos más adelante
amigos = ["Tony","Ruth","Panchito","Alex","Marce","Yadira","Miguel","Chava","Monse","Karina"]
# El ciclo for va a recorrer la lista. x es una variable que va a tomar cada elemento
# en turno de la lista en la variable amigos, iniciando en el primero y terminando en el ùltimo
for x in amigos:
    print("Bienvenido, ", x)
print("Gracias a todos por venir\n")

# Cálculo del mayor, menor y suma de una lista de números
mayor = None        # None es para decir que la variable está vacía
menor = None
suma = 0
for x in [1,100,10,500,1232,-85,2,4,8,16,32,64,128,256,512,1024]:
    if mayor is None or x > mayor:
        mayor = x
    if menor is None or x < menor:
        menor = x
    suma = suma + x
print("Resultados:")
print("Mayor = ", mayor, "\nMenor = ", menor)
print("Suma = ", suma)
# Ejemplo de condiciones y excepciones
# Calcula el IMC y da un diagnóstico
# Pido los datos al usuario
temp = input('Escriba su peso en kilogramos: ')    # Pido dato (devuelve texto)
# El try va a tratar de ejecutar las instrucciones en su interior
# Si hay un error, en lugar de tronar el programa, va a ejecutar lo que
# está en la parte except. Si no hay problema, ignora esa parte
try:
    peso = float(temp)      # Convierto el dato a float (número con punto decimal)
    temp = input('Escriba su altura en metros: ')
    altura = float(temp)
    imc = peso / altura**2    # Calculo el índice de masa corporal
    print('El indice de masa corporal es')
    print(imc)

    # Realizo diagnóstico del peso
    if imc < 18.5:
        print('Bajo peso')
    elif imc < 25:
        print('Peso normal')
    elif imc < 30:
        print('Sobrepeso')
    else:
        print('Obesidad')
except:
    print('Escribió mal un valor: solo se admiten números')
# 03Camion.py - Ejemplo de condicionales
try :
    temp = input('Edad: ')      # Pido la edad al usuario
    edad = int(temp)            # Convierto la edad a un número entero
    # No paga si es bebé o anciano
    if edad < 2 or edad >= 60 :
        precio = 0
    else :
        est = input('¿Estudiante (S/N)?')
        vale = input('¿Trae vale (S/N)?')
        if (est == 'S' or est == 's') and (vale == 's' or vale == 'S') :
            precio = 6.5
        else :
            precio = 9
    print('Precio')
    print(precio)
except :
    print('Escribió un valor inválido')
# Pruebas con condiciones
texto1 = input("Escribe un texto: ")
texto2 = input("Escribe otro texto: ")
if texto1 is texto2:
    print(texto1, " is ", texto2)
if texto1 == texto2:
    print(texto1, " == ", texto2)
if texto1 != texto2:
    print(texto1, " != ", texto2)
if texto1 is not texto2:
    print(texto1, " is not ", texto2)

num1 = 10
num2 = 30
if num1 is num2:
    print(num1," is ",num2)
if num1 == num2:
    print(num1," == ",num2)
if num1 is not num2:
    print(num1," is not ",num2)
if num1 != num2:
    print(num1," != ",num2)

# Operador ternario (condicional en otros lenguajes)
mayor = num1 if num1>=num2 else num2
print("El mayor es ",mayor)
# Primer ejemplo en Python

num1 = input('Escribe el numero de la base: ')                  # Pido un número (base)
num2 = input('Escribe la potencia a la que se vaa elevar: ')    # Pido número (la potencia
pot = int(num1) ** int(num2)                                    # Calculo la potencia
print('El resultado es ')                                       # Imprimo el resultado
print(pot)

# Uso de operadores aritméticos (aparte del exponente que está arriba)
a = 3
b = 5
print('Suma = ', a+b)
print('Resta = ', a-b, "\nMultiplicación = ", a*b, '\nDivisión = ', a/b)
print('Módulo o resíduo = ', a%b)

# Operadores con cadenas
texto1 = 'Hola '
texto2 = texto1 + 'amigo'               # La suma con texto hace una concatenación de los mismos
print('Suma de textos = ', texto2)
texto3 = texto1 * 3                     # La multiplicación con texto hace una cadena con el texto repetido
print('Texto multiplicado = ', texto3)
/// <summary>
/// Función que encripta un texto
/// </summary>
/// <param name="textoNormal">cadena que se desea encriptar</param>
/// <param name="entropia">arreglo de bytes que añaden aleatoriedad a la función</param>
/// <returns></returns>
public static byte[] encriptar(string textoNormal, byte[] entropia = null)
{
    // Creo arreglo de bytes del texto normal
    byte[] bytesNormal = Encoding.UTF8.GetBytes(textoNormal);

    // Devuelvo el texto encriptado
    return ProtectedData.Protect(bytesNormal, entropia, DataProtectionScope.CurrentUser);
}
        /// <summary>
        /// Desencripta un arreglo de bytes que han sido encriptados
        /// </summary>
        /// <param name="bytesEncriptados">bytes de datos encriptados</param>
        /// <param name="entropia">arreglo de bytes que añaden aleatoriedad a la función</param>
        /// <returns>cadena con el texto original</returns>
        public static string desencriptar(byte[] bytesEncriptados, byte[] entropia = null)
        {
            // Desencripto el arreglo de bytes y lo almaceno en otro
            byte[] bytesNormales = ProtectedData.Unprotect(bytesEncriptados, entropia,
                DataProtectionScope.CurrentUser);

            // Devuelvo el arreglo convertido a cadena
            return Encoding.UTF8.GetString(bytesNormales);
        }
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Security.Cryptography;
using System.Collections;
using System.Security.Cryptography.Xml;

namespace Encripcion
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnSalir_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }

        /// <summary>
        /// Función que encripta un texto
        /// </summary>
        /// <param name="textoNormal">cadena que se desea encriptar</param>
        /// <param name="entropia">arreglo de bytes que añaden aleatoriedad a la función</param>
        /// <returns></returns>
        public static byte[] encriptar(string textoNormal, byte[] entropia = null)
        {
            // Creo arreglo de bytes del texto normal
            byte[] bytesNormal = Encoding.UTF8.GetBytes(textoNormal);

            // Devuelvo el texto encriptado
            return ProtectedData.Protect(bytesNormal, entropia, DataProtectionScope.CurrentUser);
        }

        /// <summary>
        /// Desencripta un arreglo de bytes que han sido encriptados
        /// </summary>
        /// <param name="bytesEncriptados">bytes de datos encriptados</param>
        /// <param name="entropia">arreglo de bytes que añaden aleatoriedad a la función</param>
        /// <returns>cadena con el texto original</returns>
        public static string desencriptar(byte[] bytesEncriptados, byte[] entropia = null)
        {
            // Desencripto el arreglo de bytes y lo almaceno en otro
            byte[] bytesNormales = ProtectedData.Unprotect(bytesEncriptados, entropia,
                DataProtectionScope.CurrentUser);

            // Devuelvo el arreglo convertido a cadena
            return Encoding.UTF8.GetString(bytesNormales);
        }

        private void btnEncriptar_Click(object sender, EventArgs e)
        {
            // Éste es el texto a encriptar
            string textoOriginal = txtTextoOrig.Text;

            // Obtengo el arreglo de bytes encriptados
            byte[] resultadoEncriptado = encriptar(textoOriginal);

            // Muestro los bytes encriptados
            lblEncript.Text = "";
            for (int i=0;i < resultadoEncriptado.Length; i++)
            {
                lblEncript.Text = lblEncript.Text + " " + resultadoEncriptado[i];
            }

            // Desecripto los datos y los pongo en la etiqueta
            lblNormal.Text = desencriptar(resultadoEncriptado);
        }
    }
}
/// <summary>
/// Guarda  lo que está en el stringbuilder a un archivo
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnGuardar_Click(object sender, EventArgs e)
{
    // Creo el StreamWriter y abro el archivo para escritura
    StreamWriter streamWriter = new StreamWriter("miarchivo.csv");

    // Escribo todo lo del StringBuilder al archivo
    for (int i=0;i<lstAlumnos.Items.Count;i++)
    {
        streamWriter.WriteLine(lstAlumnos.Items[i].ToString());
    }

    // Cierro el archivo
    streamWriter.Close();
}
/// <summary>
/// Elimina todo de la lista, lee el archivo línea por línea y lo va agregando a la
/// lista.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnLeer_Click(object sender, EventArgs e)
{
    // Elimino todo en la lista
    lstAlumnos.Items.Clear();

    // Abro archivo para lectura
    StreamReader streamReader = new StreamReader("miarchivo.csv");

    // Voy por todos los registros, leyendo una línea y agregándolo a la lista
    // Mientras no llego al final del archivo...
    while (!streamReader.EndOfStream)
    {
        // Leo una línea del archivo
        string linea = streamReader.ReadLine();
        // Agrego esta línea a la lista
        lstAlumnos.Items.Add(linea);
    }

    // Cierro el archivo
    streamReader.Close();
}
using System;
using System.IO;
using System.Windows.Forms;

namespace ArchivosCSV
{
    public partial class Form1 : Form
    {

        public Form1()
        {
            InitializeComponent();
        }

        /// <summary>
        /// Pregunta si desea salir y termina la ejecución del programa
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSalir_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show("¿Desea salir?","CSV",MessageBoxButtons.YesNo,
                MessageBoxIcon.Question) == DialogResult.Yes)
            {
                Application.Exit();
            }
        }

        /// <summary>
        /// Agrega los datos a un StringBuilder
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnAgregar_Click(object sender, EventArgs e)
        {
            // Creo la cadena con todos los valores separados por comas
            string linea = txtNombre.Text + "," + txtEdad.Text + "," + txtSemestre.Text + ","
                + cboBach.Items[cboBach.SelectedIndex];

            // A la listbox le agrego esa línea
            lstAlumnos.Items.Add(linea);

            // Dejo en blanco todos los campos
            txtEdad.Text = "";
            txtNombre.Text = "";
            txtSemestre.Text = "";
            cboBach.SelectedIndex = 0;
        }

        // Elimina todos los elementos de la lista y del stringbuilder
        private void btnLimpiar_Click(object sender, EventArgs e)
        {
            // Elimino todo lo de la lista
            lstAlumnos.Items.Clear();
        }

        /// <summary>
        /// Selecciona el primer elemento del combobox
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Form1_Load(object sender, EventArgs e)
        {
            cboBach.SelectedIndex = 0;
        }

        /// <summary>
        /// Guarda  lo que está en el stringbuilder a un archivo
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnGuardar_Click(object sender, EventArgs e)
        {
            // Creo el StreamWriter y abro el archivo para escritura
            StreamWriter streamWriter = new StreamWriter("miarchivo.csv");

            // Escribo todo lo del StringBuilder al archivo
            for (int i=0;i<lstAlumnos.Items.Count;i++)
            {
                streamWriter.WriteLine(lstAlumnos.Items[i].ToString());
            }

            // Cierro el archivo
            streamWriter.Close();
        }

        /// <summary>
        /// Elimina todo de la lista, lee el archivo línea por línea y lo va agregando a la
        /// lista.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnLeer_Click(object sender, EventArgs e)
        {
            // Elimino todo en la lista
            lstAlumnos.Items.Clear();

            // Abro archivo para lectura
            StreamReader streamReader = new StreamReader("miarchivo.csv");

            // Voy por todos los registros, leyendo una línea y agregándolo a la lista
            // Mientras no llego al final del archivo...
            while (!streamReader.EndOfStream)
            {
                // Leo una línea del archivo
                string linea = streamReader.ReadLine();
                // Agrego esta línea a la lista
                lstAlumnos.Items.Add(linea);
            }

            // Cierro el archivo
            streamReader.Close();
        }
    }
}
#include <iostream>
#include <fstream>

using namespace std;

int main() {
    ofstream archivo_salida("mi_archivo.txt");

    if (archivo_salida.is_open()) {
        cout << "El archivo se abrió exitosamente.\n";
        // Realiza operaciones de escritura aquí
        archivo_salida.close(); // Cierra el archivo
    } else {
        cout << "Error al abrir el archivo.\n";
    }
}
ofstream archivo_salida("mi_archivo.txt");

if (archivo_salida.is_open()) {
    archivo_salida << "Hola, esto es un ejemplo de escritura en un archivo.\n";
    archivo_salida.close(); // No olvides cerrar el archivo
} else {
    cout << "Error al abrir el archivo.\n";
}
#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main() {
    ifstream archivo_entrada("mi_archivo.txt");
    string linea;

    if (archivo_entrada.is_open()) {
        while (getline(archivo_entrada, linea)) {
            cout << linea << endl;
        }

        archivo_entrada.close(); // Cierra el archivo después de leer
    } else {
        cout << "Error al abrir el archivo.\n";
    }

    return 0;
}
#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main() {
    // Apertura del archivo para escritura
    ofstream archivo_salida("mi_archivo.txt");

    if (archivo_salida.is_open()) {
        archivo_salida << "Hola, esto es un ejemplo de escritura en un archivo." << endl;
        archivo_salida.close();
    } else {
        cout << "Error al abrir el archivo para escritura.\n";
        return 1; // Salir del programa con código de error
    }

    // Apertura del archivo para lectura
    ifstream archivo_entrada("mi_archivo.txt");
    string linea;

    if (archivo_entrada.is_open()) {
        while (getline(archivo_entrada, linea)) {
            cout << linea << endl;
        }

        archivo_entrada.close();
    } else {
        cout << "Error al abrir el archivo para lectura.\n";
        return 1; // Salir del programa con código de error
    }

    return 0; // El programa termina con éxito
}
import random

entero_aleatorio = random.randint(1, 10)
print("Entero Aleatorio:", entero_aleatorio)
import random

flotante_aleatorio = random.uniform(0.0, 1.0)
print("Número de Punto Flotante Aleatorio:", flotante_aleatorio)
# Genero números al azar
# Este import me deja usar el objeto random
import random

print('10 números al azar entre 5 y 30...')
i = 0
while i < 10:
    # random.randint de devuelve un número al azar entre...
    # ...los números que le diga, en este caso, entre 5 y 30.
    print(random.randint(5,30))
    i = i + 1
input('Fin del programa, presione ENTER para salir');
#include <iostream>			// cout, cin
#include <vector>			// vector
#include <algorithm>		// random_shuffle
#include <ctime>			// Para usar time() - inicializar números aleatorios
#include <cstdlib>			// srand, rand
Esto va al principio del main():

    srand(time(NULL));
	baraja.Barajear();

En la clase Baraja viene estos métodos:

// Genera números aleatorios (para uso con random_shuffle)
int myrandom (int i) { return rand()%i;}

// Barajear: barajea toda la baraja
void Baraja::Barajear() {
	random_shuffle(cartas.begin(),cartas.end(),myrandom);
}
/* ****
 * Juego de 21
 * ****/

#include <iostream>			// cout, cin
#include <vector>			// vector
#include <string>			// uso strings
#include <algorithm>		// random_shuffle
#include <ctime>			// Para usar time() - inicializar números aleatorios
#include <cstdlib>			// srand, rand

using namespace std;

/* ***
 * CLASE Carta
 * *** */
class Carta {
	// Campos privados
	string palo,rango;
	bool visible;

	// Constructor
	public:
	    Carta(string,string);

	// Métodos
		void Voltear() {
			visible = !visible;
		}
		string Imprimir();
	    bool Visible() {
	    	return visible;
		}
		string Rango() {
			return rango;
		}
};

// Constructor
Carta::Carta(string palo,string rango) {
	this->palo = palo;
	this->rango = rango;
	visible = false;
}

// Imprimir
string Carta::Imprimir() {
	string x;
	x.append(rango).append(" de ").append(palo);
	return x;
}

/* ***
 * CLASE Baraja
 * ***/
class Baraja {
	// Campos
	private:
		vector <Carta> cartas;

	// Constructor
	public:
		Baraja();

	// Métodos
		Carta TomaCarta();
		void Barajear();
		void Imprimir();
		//void Partir(int);
		bool Vacia() {
			return cartas.empty();
		}
};

// Declaro arreglos útiles para inicializar
string rangos[] = {"As","2","3","4","5","6","7","8","9","10","Joto","Reina","Rey"};
string palos[] = {"Corazones","Diamantes","Treboles","Picas"};

// Constructor: llena la baraja con 52 cartas
Baraja::Baraja() {
	int i,j;

	for (i=0;i<4;i++) {
		for (j=0;j<13;j++) {
			Carta temp(palos[i],rangos[j]);
			cartas.push_back(temp);
		}
	}
}

// Imprimir: Imprime todas las cartas de la baraja
void Baraja::Imprimir() {
	int i;

	for (i=0;i<cartas.size();i++) {
		cout << cartas[i].Imprimir() << endl;
	}
}

// Genera números aleatorios (para uso con random_shuffle)
int myrandom (int i) { return rand()%i;}

// Barajear: barajea toda la baraja
void Baraja::Barajear() {
	random_shuffle(cartas.begin(),cartas.end(),myrandom);
}

// TomaCarta: Devuelve la última carta de la baraja
Carta Baraja::TomaCarta() {
	Carta x = cartas[cartas.size()-1];  		// x = la última carta
	cartas.pop_back();							// Elimino la última carta de la baraja
	return x;									// Devuelvo x
}

/* ***
 * CLASE: Jugador
 * ***/
class Jugador {
	// Campos
	private:
		vector<Carta> cartas;
		string nombre;

	// Métodos
	public:
		void AgregarCarta(Carta);
		// Devuelve el número de cartas que tengo en las manos
		int NumCartas() {
			return cartas.size();
		}
		int SumaCartas();
		string MuestraCartas();
		void AsignaNombre(string nombre) {
			this->nombre = nombre;
		}
		string MuestraNombre() {
			return nombre;
		}
};

// Agrega una carta a las que tengo en mis manos
void Jugador::AgregarCarta(Carta c) {
	cartas.push_back(c);
}

// Devuelve la suma de las cartas
int Jugador::SumaCartas() {
	int i,suma=0,temp;
	string r;

	for(i=0;i<cartas.size();i++) {
		r = cartas[i].Rango();
		if (r.compare("As")==0) {
			suma += 11;
		} else if (r.compare("Joto")==0 || r.compare("Reina")==0 || r.compare("Rey")==0) {
			suma += 10;
		} else {
			temp = stoi(r);		// Obtiene el entero que hay en la cadena del rango
			suma += temp;
		}
	}

	// Si me pasé de 21, veo si hubo As. Si hay, le resto 10
	if (suma > 21) {
		for(i=0;i<cartas.size();i++) {
			if (cartas[i].Rango().compare("As")==0) {
				suma -= 10;
			}
		}
	}

	return suma;
}

// Devuelve una cadena con las cartas del jugador
string Jugador::MuestraCartas() {
	string temp;
	int i;

	for (i=0;i<cartas.size();i++) {
		temp.append(cartas[i].Imprimir()).append("\n");
	}
	return temp;
}

int main() {
	// Declaro variables y objetos
	Baraja baraja;
	int i,j,noJugadores = 0;
	vector <Jugador> jugadores;
	string siono;

	// Preparo la baraja
	srand(time(NULL));
	baraja.Barajear();

	// Preguntar número de jugadores
	while (noJugadores < 2 || noJugadores > 4) {
		cout << "Numero de jugadores: ";
		cin >> noJugadores;
	}
	getline(cin,siono);

	// Pedir cartas
	Jugador x;
	for (i=0;i<noJugadores;i++) {		// Creo un vector de jugadores del tamaño adecuado
		cout << "Nombre: ";
		getline(cin,siono);
		x.AsignaNombre(siono);
		jugadores.push_back(x);
	}
	for (i=0;i<2;i++) {					// Se reparten 2 cartas a cada jugador
		for (j=0;j<noJugadores;j++) {	// Se reparten a todos los jugadores
			jugadores[j].AgregarCarta(baraja.TomaCarta());
		}
	}

	// Si alguien tiene 21 (ya ganó desde el inicio)
	for (i=0;i<noJugadores;i++) {
		if (jugadores[i].SumaCartas() == 21) {
			cout << "¡Ganó el jugador " << jugadores[i].MuestraNombre()
				<< "! Sus cartas fueron:\n" << jugadores[i].MuestraCartas();
			return 1;
		}
	}

	// Ciclo de pedir cartas
	for (i=0;i<noJugadores;i++) {
		do {
			// Muestro las cartas del jugador y le pregunto si quiere otra
			cout << jugadores[i].MuestraNombre() << ", tus cartas son:\n";
			cout << jugadores[i].MuestraCartas() << endl;
			cout << "Jugador " << jugadores[i].MuestraNombre() <<
				", ¿Otra carta (S/N)? ";
			getline(cin,siono);
			if (siono[0] == 'S' || siono[0] == 's') {
				jugadores[i].AgregarCarta(baraja.TomaCarta());
				// Si perdió, elimino al jugador y decremento noJugadores
				if (jugadores[i].SumaCartas() > 21) {
					cout << "Jugador " << jugadores[i].MuestraNombre()
						<< " perdió. Sus cartas suman " <<
						jugadores[i].SumaCartas() << "\nY sus cartas son\n"
						<< jugadores[i].MuestraCartas() << endl;
					jugadores.erase(jugadores.begin()+i);
					noJugadores --;
				} else if (jugadores[i].NumCartas() == 5) {	// Si llega a tener 5 cartas y no se pasa, gana
					cout << jugadores[i].MuestraNombre()
						<< ", ¡ganaste! Tienes 5 cartas y no te pasaste de 21. "
						<< "Tus cartas fueron:\n" << jugadores[i].MuestraCartas() << endl;
					return 1;
				} else if (jugadores[i].SumaCartas() == 21) {	// Si sus cartas suman 21, gana
					cout << jugadores[i].MuestraNombre()
						<< ", ¡ganaste! Tus cartas suman 21. "
						<< "Tus cartas fueron:\n" << jugadores[i].MuestraCartas() << endl;
					return 1;
				}
			}
		} while (siono[0] != 'N' && siono[0] != 'n');
	}

	// Ver quien ganó (de los que quedan)
	j = 0;				// En j guardo el índice de quien ganó
	if (!jugadores.empty()) {
		for (i=1;i<noJugadores;i++) {
			if (jugadores[i].SumaCartas() > jugadores[j].SumaCartas()) {
				j = i;
			}
		}
		cout << "El ganador es " << jugadores[j].MuestraNombre() <<
			" y sus cartas fueron:\n" << jugadores[j].MuestraCartas() << endl;
	} else {
		cout << "Todos perdieron\n";
	}
}
/* ***
 * Ordena.cpp - Ejemplifica como usar el sort en vectores
 * ***/

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Prueba {
	public:
		int datoEntero;
		float datoFlotante;
		string datoString;
		Prueba();		//	 Constructor default
		Prueba(int,float,string);	// Constructor sobrecargado
		string MuestraDatos();
};

// Constructor default
Prueba::Prueba() {
	datoEntero = 0;
	datoFlotante = 0.0f;
	datoString = "";
}

// Constructor sobrecargado
Prueba::Prueba(int entero,float numDecimal,string texto) {
	datoEntero = entero;
	datoFlotante = numDecimal;
	datoString = texto;
}

// Devuelve una cadena con los valores en el objeto
// Salida: una cadena con los valores
string Prueba::MuestraDatos(){
	string x = to_string(datoEntero).append(" - ").append(to_string(datoFlotante)).append(" - ").append(datoString);
	return x;
}

// Función para comparar (usado en el sort)
bool compara1(Prueba a,Prueba b) {
	return a.datoEntero < b.datoEntero;
}

bool compara2(Prueba a,Prueba b) {
	return a.datoFlotante < b.datoFlotante;
}

bool compara3(Prueba a,Prueba b) {
	// compareTo devuelve un número, hagoa la expdresión para que devuelva
	// True o False.
	return (a.datoString.compare(b.datoString) < 0);
}

int main () {
	// Declarar el vector
	vector<Prueba> lista;
	// Lleno el vector con datos
	lista.push_back(Prueba(1,2.0f,"primero"));
	lista.push_back(Prueba(7,2.5f,"segundo"));
	lista.push_back(Prueba(4,4.5f,"tercero"));
	lista.push_back(Prueba(3,6.33f,"cuarto"));
	lista.push_back(Prueba(5,1.8f,"quinto"));
	lista.push_back(Prueba(2,8.45f,"sexto"));

	// Muestro el contenido del vector
	cout << "Lista de elementos\n";
	for (Prueba xx : lista) {
		cout << xx.MuestraDatos() << endl;
	}

	// Ordeno la lista usando mi función para comparar
	// y muestro la lista ordenada
	sort(lista.begin(),lista.end(),compara1);
	cout << "Lista de elementos ordenados por el dato entero\n";
	for (Prueba xx : lista) {
		cout << xx.MuestraDatos() << endl;
	}

	// Ordeno la lista de nuevo usando mis otras funciones
	// para comparar y muestro las listas resultantes
	sort(lista.begin(),lista.end(),compara2);
	cout << "Lista de elementos ordenados por el dato flotante\n";
	for (Prueba xx : lista) {
		cout << xx.MuestraDatos() << endl;
	}
	sort(lista.begin(),lista.end(),compara3);
	cout << "Lista de elementos ordenados por el texto\n";
	for (Prueba xx : lista) {
		cout << xx.MuestraDatos() << endl;
	}
}
/* ***
 * AzarVector.cpp - Ejemplo de cómo "revolver" un vector en C++
 * ***/

#include <vector>		// Para usar el vector
#include <iostream>
#include <random>		// Para el default_random_engine
#include <algorithm>	// Para el shuffle

using namespace std;

int main() {
	vector<int> lista;

	// Lleno la lista
	cout << "Llenando el vector con 100 enteros...\n";
	for (int i=0;i<100;i++) {
		lista.push_back(i);
	}

	// Muestro la lista
	cout << "\nLos elementos dados de alta...\n";
	for (int i : lista) {
		cout << i << endl;
	}

	// "Revuelvo" la lista
	shuffle(lista.begin(),lista.end(),default_random_engine());

	// Muestro la lista
	cout << "\nLos elementos mezclados...\n";
	for (int i : lista) {
		cout << i << endl;
	}
}