Mensajes

[solo y siempre]

Yo no veo que 'se complique'... en realidad hay una optimización, que simplemente añade una sola línea de código y modifica ligeramente 2 lineas... esperaba que cuando ejecutara los cambios si los entendía, pudiera él mismo intentarlo (es algo obvio) o al menos preguntar...

No me refería a que se complicase el código (que entiendo que el tuyo es más extenso por haber incluido código de la interfaz) sino a lo de mantener la distancia entre los números y generar números con dígitos que no están entre los introducidos.

Al final ha resultado que yo tampoco lo estaba terminando de entender pero creo que ahora ya sí.

A - ¿El primer grupo solo y siempre puede formar parte en las decenes y el segundo solo y siempre de las unidades (o viceversa, pero solo y siempre)?

B - ¿... o pueden igulamente ser intercambiados mientras el dígito en la unidad sea de un grupo distinto al dígito en la decena?. Esto si sería de verdad 'todas' las permutaciones posibles.

A mí entender, una vez tienes todos los grupos posibles (menores a 49) de 2 dígitos con los dígitos dados, hay que crear digamos filas combinando 6 de esos grupos.

Estando ahora en lo cierto, según mis códigos anteriores ya teníamos en numerosGenerados todos los números menores a 49 generados. Ahora habría que combinar dichos números para crear los nuevos grupos (cada uno formado por 6 números de los generados).
Pongamos el siguiente caso (cogido de uno de los códigos anteriores):

Código [Seleccionar] Expandir


digitos = { 1, 4, 5, 7, 8, 9 }
numerosGenerados = { 11, 14, 15, 17, 18, 19, 41, 44, 45, 47, 48, 49 }
Ahora queremos crear grupos del tipo: { X1, X2, X3, X4, X5, X6 } donde cada Xi es un número perteneciente a numerosGenerados.
Podemos ver que X1 nunca podrá ser 44 o mayor porque entonces nos faltarían números para completar el grupo.
De la misma manera X2 nunca podrá 11 (porque entonces cuál sería X1??) ni 45 o mayor por lo mismo que antes.
Haciendo el mismo cálculo con cada uno podemos sacar el siguiente código:

Código (csharp) [Seleccionar] Expandir


List<List<int>> gruposGenerados = new List<List<int>>();
int elementosPorGrupo = 6;

for(int i = 0; i < numerosGenerados.Count - elementosPorGrupo + 1; ++i)
for(int j = i + 1; j < numerosGenerados.Count - elementosPorGrupo + 2; ++j)
for(int k = j + 1; k < numerosGenerados.Count - elementosPorGrupo + 3; ++k)
for(int l = k + 1; l < numerosGenerados.Count - elementosPorGrupo + 4; ++l)
for(int m = l + 1; m < numerosGenerados.Count - elementosPorGrupo + 5; ++m)
for(int n = m + 1; n < numerosGenerados.Count - elementosPorGrupo + 6; ++n)
gruposGenerados.Add(new List<int> {numerosGenerados[i], numerosGenerados[j], numerosGenerados[k], numerosGenerados[l], numerosGenerados[m], numerosGenerados[n]});
PD: El código se puede simplificar pero así creo que es más fácil de entender.

SALIDA:

Código [Seleccionar] Expandir


11 14 15 17 18 19
11 14 15 17 18 41
11 14 15 17 18 44
11 14 15 17 18 45
11 14 15 17 18 47
11 14 15 17 18 48
11 14 15 17 18 49
11 14 15 17 19 41
11 14 15 17 19 44
11 14 15 17 19 45
11 14 15 17 19 47
11 14 15 17 19 48
11 14 15 17 19 49
11 14 15 17 41 44
11 14 15 17 41 45
11 14 15 17 41 47
11 14 15 17 41 48
11 14 15 17 41 49
...
18 44 45 47 48 49
19 41 44 45 47 48
19 41 44 45 47 49
19 41 44 45 48 49
19 41 44 47 48 49
19 41 45 47 48 49
19 44 45 47 48 49
41 44 45 47 48 49

Mmm pues este programita lo hice yo, pero vi que un mod escribió que tengo que poner etiquetas geshi? Te referís a eso?

No, creo que [D]aniel ha sobreentendido, al parecer de forma errónea, el comentario de "código compartido" como que este era un código compartido que has encontrado por ahí.
Lo de las etiquetas de Código GeSHi simplemente es para facilitar la lectura de código al resto de usuarios.

Si con la función system() puedes poner un color a la consola, lo que puedes hacer es llamar varias veces a la función system() con diferentes colores. Si esto se hace de forma seguida no te dará tiempo a ver más que el último color por lo que tendrás que usar la función sleep() entre medias para crear un retardo.

La función sleep(int segundos) para sistemas Unix se encuentra en <unistd.h> mientras que para Windows la función es Sleep(int milisegundos) y se encuentra en <windows.h>. Una forma de que el código funcione en ambos sistemas sería:

Código (c) [Seleccionar] Expandir


#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif

void mySleep(int milliseconds) {
  #ifdef _WIN32
  Sleep(milliseconds);
  #else
  sleep(milliseconds / 1000);
  #endif
}

El problema del código anterior es que ocupa el hilo principal del programa. Si quieres una solución más compleja que vaya cambiando el color de la consola mientras, por ejemplo, esperas que el usuario introduzca una tecla para continuar; podrías utilizar hilos para ejecutar el código del cambio de color y el retardo en un hilo secundario mientras tú sigues ejecutando el código principal en el hilo principal. Pero como digo esto ya sería una solución más avanzada.

Yo creo que se está complicando demasiado el problema inicial. Y que bastaría con lo que expuse en su momento.

Yo diría que algo así te puede servir:

Código (csharp) [Seleccionar] Expandir


int numeroMaximo = 49;
int[] digitos = { 1, 4, 5, 7, 8, 9 };
List<int> numerosGenerados = new List<int>();

int decenaMaxima = numeroMaximo / 10;
int unidadMaxima = numeroMaximo % 10;

for(int i = 0; i < digitos.Length && digitos[i] <= decenaMaxima; ++i)
  for(int j = 0; j < digitos.Length && (digitos[i] < decenaMaxima || digitos[j] <= unidadMaxima); ++j)
    numerosGenerados.Add(digitos[i] * 10 + digitos[j]);
** Para que el algoritmo anterior funcione correctamente el array de dígitos debe estar ordenado.
Las condiciones de los bucles for() no son muy complicadas pero cualquier duda no dudes en comentarla.

Salida:

Código [Seleccionar] Expandir


11 - 14 - 15 - 17 - 18 - 19
41 - 44 - 45 - 47 - 48 - 49

Entrada 2:

Código (csharp) [Seleccionar] Expandir


int[] digitos = {2, 3, 5, 7, 8, 9};

Salida 2:

Código [Seleccionar] Expandir


22 - 23 - 25 - 27 - 28 - 29
32 - 33 - 35 - 37 - 38 - 39

Las únicas diferencias que veo son:

• El código expuesto está en C# -> Habría que convertirlo a VB.
  
• Aparece también la combinación de un dígito consigo mismo. Esto se corrige así:
  
  Código (csharp) [Seleccionar] Expandir
  
for(int i = 0; i <digitos.Length && digitos[i] <= decenaMaxima; ++i)
  for(int j = 0; j < digitos.Length && (digitos[i] < decenaMaxima || digitos[j] <= unidadMaxima); ++j)
    if(i != j) numerosGenerados.Add(digitos[i] * 10 + digitos[j]);

Desconozco la función que le quieres dar a esas tablas o su estructura...
Pongamos que Carrito es la tabla para guardar los productos que un usuario ha agregado a su carrito pero que no ha comprado todavía.
Una forma sin reestructurar la base de datos es: Carrito (id_usuario, id_producto, cantidad). Es decir, una relación entre Usuarios y Productos.

Tienes que convertir ese parámetro a un número positivo por ejemplo como te ha indicado MAFUS unos mensajes atrás:

Código (c) [Seleccionar] Expandir


/*El 1º parámetro siempre va a ser la longitud de la clave*/
if(sscanf(argv[1], "%u", &longitud_clave) == 0) {
   fprintf(stderr, "%s\n", "El primer parámetro debe ser un entero. Indica la longitud de la clave...");
   exit(EXIT_FAILURE);
}

EDITO: La variable longitud_clave tal y como se utiliza (y se debe utilizar) en el código citado en este mensaje debe ser de tipo unsigned int, es decir, entero sin signo. Lo que quieres guardar ahí es un número positivo con la longitud de la clave. Si utilizas como parámetro "-10" lo que quieres guardar es 10.

El problema que tienes es de planteamiento. El enunciado no dice que si estás 2 horas, las pagas a un precio y si estás 3 las pagas a otro. Sino que dice que las 2 primeras las pagas a un precio y las 3 siguientes a otro. (Y así sucesivamente)
Es decir, si estuvieras 7 horas pagarías las 2 primeras a 5.00$, las 3 siguientes (ya van 5) a 4.00$ y las 2 siguientes a 3.00$.

Una forma sencilla que se me ocurre es con un bucle:

Código (cpp) [Seleccionar] Expandir


const int HORAS_RANGO_1 = 2;
const float PRECIO_HORA_RANGO_1 = 5.0f;
const int HORAS_RANGO_2 = 3;
const float PRECIO_HORA_RANGO_2 = 4.0f;
const int HORAS_RANGO_3 = 5;
const float PRECIO_HORA_RANGO_3 = 3.0f;
const float PRECIO_HORA_RANGO_4 = 2.0f;

int main() {
 int horas, autos;
 float precioFinal = 0.0f;

 // Pides las horas y los autos

 int horasActuales = 0;
 while(horasActuales <= horas && horasActuales <= HORAS_RANGO_1) { // Mientras estes en el rango 1
   precioFinal += autos * PRECIO_HORA_RANGO_1;                     // Se suma cada hora al precio del rango 1
   ++horasActuales;                                                // Y se incrementan las horas cobradas
 }

 while(horasActuales <= horas && horasActuales <= HORAS_RANGO_2) {
   precioFinal += autos * PRECIO_HORA_RANGO_2;
   ++horasActuales;
 }

 // Y asi sucesivamente

 cout << "El precio final es: " << precioFinal << endl;
}

PD: En el último bucle tan solo tendrás que comprobar si (horasActuales <= horas) ya que no tienes límite.

La biblioteca de entrada/salida de C es <stdio.h>. Esta contiene las funciones printf() y scanf(), entre otras.
La biblioteca de entrada/salida de C++ es <iostream>. Esta contiene las "funciones" std::cout << y std::cin >>, entre otras.

Es un error muy típico mezclar C y C++. El problema está que si programas en C++ todo va a compilar porque C++ acepta todas las funciones de C; en cambio, a la inversa esto no funciona. C al ser anterior a C++ no acepta las funciones del último.
No sé muy bien a qué te refieres con "cargarlas en consola". Si quieres exponer un poco más a fondo el problema concreto y lo que tengas hecho, podremos ayudarte mejor.

Si estás buscando algún libro o recurso para aprender puedes usar la función del buscador del foro y buscar por ejemplo "libros" en el apartado de C/C++. Hay multitud de temas abiertos (algunos más antiguos que otros) sobre libros y otra documentación.

A mi en lo personal no me gusta python, se que es facil para quienes no han visto mucha programación, pero no me gusta para nada su rendimiento

Menuda sorpresa  ... AlbertoBSD, fiel defensor de C, renegando de Python. 
Yo opino igual, supongo que será cosa de los que nos gusta C.

Bromas aparte y yendo al tema principal, te hablaré desde mi propia experiencia habiendo aprendido programación de manera autodidacta, en universidad y en grado superior (más parecido a un curso digamos, más práctico).

Ventajas de aprender de forma autodidacta:

• Vas a aprender lo que más te interese en cada momento. Eso ayuda a aprender lo que te motiva en ese momento y no lo que te imponen.
  
• Podrás estudiar a tu ritmo y dedicar más tiempo a los temas que necesites y menos a los que no.
  
• No te imponen una fuente de información. Podrás aprender de libros, vídeos, cursos, blogs...
  
  Desventajas de aprender de forma autodidacta:
  
• Es más complicado mantener la constancia. Tendrás temporadas que por tiempo o ganas lo dejarás apartado.
  
• Tienes que contrastar la información que encuentres según qué fuentes. Internet es una herramienta inmensa pero de doble filo.
  
  Ventajas de aprender mediante un sistema de formación (universidad, formación profesional...):
  
• No te vas a quedar en blanco sin saber qué aprender en ese momento porque tienes un temario predefinido.
  
• Aprenderás temas que aunque no te parezcan interesantes, te servirán en un futuro.
  
• Obtención de un título/certificado que según casos y países puede ser importante para conseguir un trabajo relacionado.
  
• Y como te podrás imaginar lo opuesto a las desventajas de aprender de forma autodidacta (aunque yo me he encontrado casos en los que se ve que los profesores no han aplicado eso de contrastar fuentes...)
  
  Desventajas de aprender mediante un sistema de formación (universidad, formación profesional...):
  
• Profesor malo -> Experiencia nefasta.
  
• En la mayoría de casos tendrás unos apuntes elegidos por tu profesor y tendrás que hacer las cosas como a él le gustan para que te lo dé por bueno (aunque sepas que esa no es la mejor manera). Hay buenos casos en los que esto no se aplica, yo casi no los he visto...
  
• Un tema por interesante/profundo que sea, si tienes una semana para verlo y pasar al siguiente, tienes una semana y no hay más. A partir de ahí si quieres investigar más tendrá que ser por tu cuenta.
  
  Dicho esto, mi recomendación: si puedes, estudia por ambos lados. Así estarás en un punto medio entre las cosas buenas y malas de cada uno. Y después de un tiempo, según cómo se vayan sucediendo las cosas, podrás decantarte por una cosa u otra.
  El lenguaje es lo de menos porque siempre puedes pasar de uno a otro y no tendrás que empezar desde 0 pero mi recomendación es Java antes que Python. Python lo veo como aprender a conducir con un coche automático. Sabes conducir? Sí. Pero el día que te den un coche de cambio manual (Java o similares) no sabrás dónde comprar el tercer pie para el embrague. En cambio si aprender con el manual, el día que te den uno automático sólo tendrás que acostumbrarte a trabajar menos, no más.
  
  Mucha suerte con tu elección. 
  

Hola tengo una duda al final quiero comaprar las cadenas lenguaje con cadena pero me dice que no es igual no tengo idea por que es

El problema con las cadenas es el siguiente:

Código (c) [Seleccionar] Expandir


const int MAX_SIZE = 20;

int main() {
  char *cadena1 = "hola"; // Se guarda "hola\0" -> '\0' es el caracter de fin de cadena siempre
  char cadena2[MAX_SIZE];
  // fgets() es la recomendacion sobre gets() para evitar problemas de desbordamiento
  fgets(cadena2, MAX_SIZE, stdin); // Introduces: "hola" y pulsas Enter '\n' -> Se guarda: "hola\n\0"
  if(strcmp(cadena1, cadena2) == 0) { // "hola\0" y "hola\n\0" no son iguales
    ...
  }
}

Una solución que me gusta usar porque además de eliminar el Enter del final también deja el buffer limpio es:

Código (c) [Seleccionar] Expandir


fgets(cadena2, MAX_SIZE, stdin);
if(cadena2[strlen(cadena2) - 1] == '\n') // Si el ultimo caracter de la cadena es Enter -> No queda nada en el buffer...
  cadena2[strlen(cadena2) - 1] = '\0'; // ...y elimino el Enter sustituyendolo por el caracter de fin de cadena
else // Si el ultimo caracter de la cadena no es Enter -> No cabia en el array y se ha quedado en el buffer (solo o con otros caracteres antes)
  while(getchar() != '\n'); // Consumo todos los caracteres del buffer hasta consumir el Enter que va a ser el ultimo -> Buffer limpio
Así consigues que la cadena siempre quede sin el Enter al final y el buffer siempre quede limpio.

Otra posible solución es comparar hasta el final de la cadena que no tiene el Enter, así no lo tendrás en cuenta:

Código (c) [Seleccionar] Expandir


if(strncmp(cadena1, cadena2, strlen(cadena1)) == 0) {
  ...
}
Inconvenientes:

• Tienes que controlar manualmente cuál será la cadena que no tenga el Enter.
  
• Cuando utilices la cadena2 para otra cosa, seguirá teniendo el Enter y tendrás que acordarte de manejarlo correctamente.
  
  
  Además la opción del:
  
  Código (c) [Seleccionar] Expandir
  while(getchar() != '\n');
  también sirve como método después de un scanf() para dejar el buffer limpio. Esto sería una alternativa a la respuesta de MAFUS para que la siguiente entrada funcione correctamente.
  Además si pides un número "%d" y el usuario introduce letras, el bucle se encargará de dejar limpio el buffer eliminando todas las letras que no se hayan podido procesar en la entrada.

El tema tiene 8 años y los usuarios que participaron en él llevan años sin entrar al foro...
Si tienes un problema crea un tema nuevo agregando una explicación del problema y/o el código para poder ayudarte.

Saludos.