Ejercicio Numeros Vampiro Parcial 2

Algoritmos/Parcial 2/Nicolas Mantilla/Numeros Vampiro/NumerosVampiro.cpp

+#include <iostream>
+#include <cmath>
+#include <vector>
+#include <fstream>
+
+using namespace std;
+
+int main()
+{
+    cout << "Bienvenido al verificador de los temidos Números Vampiro" << endl;
+    
+    // Primero leemos el archivo input y verificamos su validez
+    cout << "Por favor ingrese la dirección del archivo con el input: ";
+    string nombre, linea;
+    cin >> nombre; // Utilizar sample.in en este caso
+    ifstream input;
+    input.open(nombre);
+    if (!input)
+    {
+        cout << "Archivo inválido." << endl;
+        exit(0);
+    }
+
+    // Ahora, obtenemos el numero de valores a comprobar, y la lista de valores a comprobar
+    int count=0, n;
+    getline(input, linea);
+    n = stoi(linea); //La primera linea es el numero de valores (tamaño de la lista)
+    int numeros[n];
+    while(getline(input, linea))
+    {
+        // Para el resto de lineas, asignamos su valor a una posicion del array
+        numeros[count] = stoi(linea);
+        count++;
+    }
+
+    // Imprimimos el array
+    cout << "Se ingresaron los números: " << endl;
+    cout << "[ ";
+    for (int i:numeros)
+    {
+        cout << i << " ";
+    }
+    cout << "]" << endl;
+
+    // Ahora verificamos si son numeros vampiro. Primero, creamos un array para devolver las respuestas SI y NO
+    string respuestas[n];
+
+    // Luego, para cada valor, empezamos por crear un vector con los digitos del numero
+    vector <vector <int>> vectors(n);
+    for (int i=0; i<n; i++)
+    {
+        int temp = numeros[i];
+        while (temp > 0)
+        {
+            vectors[i].push_back(temp%10);
+            temp /= 10;
+        }
+    }
+
+    // Seguidamente, determinamos si tiene una cantidad par de elementos, de no ser así, su respuesta será NO. Si tiene una cantidad
+    // par, se continua la comprobacion
+
+    for (int i=0; i<n; i++)
+    {
+        if(vectors[i].size()%2 != 0)
+        {
+            respuestas[i] = "NO (el número tiene cantidad impar de dígitos)";
+        } else
+        {
+            // Definimos los vectores que contendrán el divisor y el cociente para los divisores (sin residuo) que tienen 
+            // la mitad de la cantidad de digitos del número a comprobar para luego comparar sus digitos
+            vector <int> divisores;
+            vector <int> cocientes;
+
+            // Realizamos la comprobación para todos los números con la cantidad de digitos necesarios
+            for (int j=pow(10,(vectors[i].size()/2)-1); j<pow(10,vectors[i].size()/2); j++)
+            {
+                // Si el cociente no tiene residuo, y tiene la cantidad de digitos necesarios, se guardan el cociente y el divisor
+                if ((numeros[i]/j)%1 == 0 && (numeros[i]/j)>=pow(10,(vectors[i].size()/2)-1) && (numeros[i]/j)<pow(10,(vectors[i].size()/2)))
+                {
+                    divisores.push_back(j);
+                    cocientes.push_back(numeros[i]/j);
+                }
+            }
+
+            // Separamos los números hallados por digitos y los unimos en un mismo vector
+            vector <vector <int>> candidatos(divisores.size());
+            for (int k=0; k<divisores.size(); k++)
+            {
+                int temp1 = divisores[k];
+                int temp2 = cocientes[k];
+                while (temp1 > 0)
+                {
+                    candidatos[k].push_back(temp1%10);
+                    temp1 /= 10;
+                    candidatos[k].push_back(temp2%10);
+                    temp2 /= 10;
+                }
+            }
+            
+            // Ordenamos los vectores con los dígitos de los colmillos candidatos y los dígitos de los números a comprobar
+            int temp;
+            for (int l = 0; l<vectors[i].size(); l++)
+            {
+                for (int m=l+1; m<vectors[i].size(); m++)
+                {
+                    if (vectors[i][l]>vectors[i][m])
+                    {
+                        temp = vectors[i][m];
+                        vectors[i][m] = vectors[i][l];
+                        vectors[i][l] = temp;
+                    }
+                }
+            }
+
+            for (int s = 0; s<candidatos.size(); s++) // Ordenamos para cada candidato
+            {
+                for (int l = 0; l<vectors[i].size(); l++)
+                {
+                    for (int m=l+1; m<vectors[i].size(); m++)
+                    {
+                        if (candidatos[s][l]>candidatos[s][m])
+                        {
+                            temp = candidatos[s][m];
+                            candidatos[s][m] = candidatos[s][l];
+                            candidatos[s][l] = temp;
+                        }
+                    }
+                }
+            }
+
+            // Comprobamos si alguno de los candidatos para cada número tiene exactamente los mismos dígitos
+            for (int s = 0; s<candidatos.size(); s++)
+            {
+                int cantIgual = 0; // Iniciamos un contador
+                for (int l = 0; l < vectors[i].size(); l++)
+                {
+                    if (vectors[i][l] == candidatos[s][l]) // Cada vez que, para cada candidato, encuentra un digito igual, suma el contador
+                    {
+                        cantIgual++;
+                    }
+                }
+                
+                if (cantIgual == vectors[i].size()) // Si el valor del contador es igual al tamaño del vector, el número es vampiro
+                {
+                    respuestas[i] = "SI (colmillos: " + to_string(divisores[s]) + ", " + to_string(cocientes[s]) + ")"; // Guardamos los colmillos
+                    break; // Cuando un candidato cumple, detenemos la comprobación
+                }
+
+                if (s == candidatos.size()-1 && cantIgual != vectors[i].size()) // Si para el ultimo candidato, la comprobación no es positiva, no existen colmillos
+                {
+                    respuestas[i] = "NO (no existe par de colmillos para este número)";
+                }
+            }
+        }   
+    }
+
+    // Finalmente, imprimimos las respuestas
+    cout << "Las respuestas son: " << endl;
+    for (string i:respuestas)
+    {
+        cout << i << endl;
+    }
+}
+// Gracias por ver :D

Algoritmos/Parcial 2/Nicolas Mantilla/Numeros Vampiro/sample.in

+4
+2187
+126
+1122
+536539
\ No newline at end of file