Mensajes

[¡¡¡¡ Saluditos! ..... !!!!]

Todo el mal radica en cómo declaras notas y el char que usas.

Ya que usas array de longitud variable en:

Código (cpp) [Seleccionar] Expandir

int notasEnteras[alumnos];

no sé por qué no haces lo mismo con notas:

Código (cpp) [Seleccionar] Expandir

char *notas[alumnos];

Pero si lo quieres hacer con malloc, entonces:

Código (cpp) [Seleccionar] Expandir

char **notas;
*notas=malloc(alumnos * sizeof (char));

¡¡¡¡ Saluditos! ..... !!!!

[¿Algo como esto?:]

¿Algo como esto?:

Código (cpp) [Seleccionar] Expandir


Que numero de veces quieres que se imprima el signo:
10

          # #
         ## ##
        ### ###
       #### ####
      ##### #####
     ###### ######
    ####### #######
   ######## ########
  ######### #########
########## ##########



Con un array se simplifican las cosas, basta un for y un printf.... un tanto especial:

Código (cpp) [Seleccionar] Expandir


............................
scanf.....sign..............
char signo[sign+1];
for (i = 0; i <= sign; i++)
  signo[i]='#';
signo[i]='\0';
for (i = 0; i <=sign; i++)
  printf("%*c%.*s%*c%.*s\n", sign+1-i, ' ', i, signo, 1, ' ', i, signo);


¡¡¡¡ Saluditos! ..... !!!!

O un solo for con un printf previo:

Que numero de espacios quieres que se deje a la izquierda antes de imprimir el signo:
10
Que numero de veces quieres que se imprima el signo:
5
          #####

Código (cpp) [Seleccionar] Expandir


scanf .....................
printf("%*c",esp,' ');
  for (i=0;i<sign;i++ )
    putchar('#');
........................


Salu2!.

[rir]

Hola a todos.
rir3760, espero me puedas explicar lo de la foto, no puedo encontrar la teoría suficiente y me parece de suma importancia aprender este trozo de sintaxis.-

...........................................

No soy rir pero intentaré hacerlo lo mejor posible.

La ini del final del sprintf indica desde que posición se van a incorporar los caracteres a la variable aux, mientras que (int) (fin - ini +1) da el total de caracteres que, a partir de la posición mencionada por ini, se añaden a aux.

Por ejemplo, para tener la salida:

9 - 2

usaría:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <string.h>

int main(void){
 char *s = "3 * 5 + (9 - 2) + 5",aux[10]={'\0'};
 char *ini,*fin;
 if ((ini = strchr(s, '(')) && (fin = strchr(ini, ')')))
   sprintf(aux,"\n%.*s\n", (int) (fin - (ini +1)), ini+1);
 printf("%s",aux);
 return 0;
}

¡¡¡¡ Saluditos! ..... !!!!

[¡¡¡¡ Saluditos! ..... !!!!]

Hecho de prisa y corriendo, creo que esta es la salida correcta:

Escribe un numero: 18
18 23 22 11 10 5 4 2 1
Total de llamadas: 9

Process returned 0 (0x0)

Unos pequeños ajustes menores en la declaración de la función:

Código (cpp) [Seleccionar] Expandir

void  f2x3 (int n,int i) ;


Lo de la variable i es para ir guardando las llamadas a la función. Y en main:

Código (cpp) [Seleccionar] Expandir

scanf("%d", &n);
    f2x3(n,i);

Y para terminar en la función, a lo bruto:

Código (cpp) [Seleccionar] Expandir

void  f2x3 (int n,int i) {
    if (n == 1){
      printf ("%d ",n);
      printf("\nTotal de llamadas: %d \n", ++i);
    }
    else
    {
        if (n % 2 == 0 && n % 3 == 0){
          printf ("%d ",n);
          f2x3 (n+5,i+1);
        }
        else if (n % 2 == 0 &&  n % 3 != 0){
              printf ("%d ",n);
              f2x3 (n/2,i+1);
            }
        else if (n % 3 == 0 && n % 2 != 0){
              printf ("%d ",n);
              f2x3 (n+2,i+1);
            }
        else if (n % 2 != 0 &&  n % 3 != 0){
              printf ("%d ",n);
              f2x3 (n-1,i+1);
            }
    }
}

¡¡¡¡ Saluditos! ..... !!!!

[¡¡¡¡ Saluditos! ..... !!!!]

.................................).

Por cierto Leo, haciendo pruebas me he dado cuenta que hay una forma un poco más sencilla de mezclar. No es necesario definirte una constante con el numero de iteraciones:
...........................................
Dicho de otra forma, recorro el array y cada posición la intercambio con otra aleatoria. De esa forma tengo la garantía de tener el array desordenado y no tengo que definir una constante "a ojo".
......................................

Buena observación amchacon, muy buena 

...Pero me sentiría más tranquilo barajando un par de veces más para evitar las posibles coincidencias de i con el valor obtenido del rand y que existan cartas que acaben quedándose en las mismas posiciones

Ya sólo nos queda ponerlo en práctica echándonos unas partiditas de póker

Hay que ver la soluciones, cada vez más optimizadas, que nos salen cuando nos dejan......

Mi adaptación al C de tu idea:

Código (cpp) [Seleccionar] Expandir

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

int main (void){
  int mazo[52] = {0};
  srand((unsigned) time(NULL));
  int j,x,temp;
  ///puts("Mazo ordenado:\n");
    for (j=0;j<52 ;j++)
      mazo[j]=j;
    for (j=0;j<52 ;j++){
    x=rand () % 52;
    temp=mazo[j];
    mazo[j]=mazo[x];
    mazo[x]=temp;
  }
  puts("\n\nMazo desordenado:");
    for (j=0;j<52 ;j++ ){
      if (j%13==0)
        puts("\n");
      printf("%d  ",mazo[j]);
    }
   putchar ('\n');
   return EXIT_SUCCESS;
}

Mazo desordenado:


18  35  24  31  36  46  21  25  37  34  40  23  51

0  47  6  16  7  44  9  22  12  20  33  3  17

50  39  42  13  1  10  27  26  11  29  2  43  45

14  32  48  49  4  8  28  15  38  19  41  5  30

¡¡¡¡ Saluditos! ..... !!!!

[Salu2!]

¿Comor?

¿Y si cojo un elemento del principio? ¿No puede adceder a los finales?

Quiero ver una implementación ^^

Yo también lo quiero ver.

En el método que propuse, desordenar un cierto número de veces, 10 000 en el caso que propongo, con lo que controlamos las iteraciones, una implementación simple, nada rebuscada, arroja valores por debajo de 0.02s, más cercanos al 0.015s:

Código (cpp) [Seleccionar] Expandir

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define MAX_DESORDEN 10000


int main (void){
 int mazo[4][13] = {0};
 srand((unsigned) time(NULL));
 int i,j,k=0,x1,y1,x2,y2,temp;
 ///puts("Mazo ordenado:\n");
 for (i=0;i< 4; i++){
   ///puts("\n");
   for (j=0;j<13 ;j++,k++ ){
     mazo[i][j]=k;
     ///printf("%d  ",mazo[i][j]);
   }
  }

 for (i=0;i<MAX_DESORDEN;i++){
   x1=rand () %4;
   y1=rand () %13;
   x2=rand () %4;
   y2=rand () %13;
   temp=mazo[x1][y1];
   mazo[x1][y1]=mazo[x2][y2];
   mazo[x2][y2]=temp;
 }
 /** activame para ver el mazo desordenado **/
 /*puts("\n\nMazo desordenado:\n");
 for (i=0;i< 4; i++){
   puts("\n");
   for (j=0;j<13 ;j++,k++ )
     printf("%d  ",mazo[i][j]);
  }*/
  return EXIT_SUCCESS;
}

Salu2!.

[ir cogiendo elementos aleatorios, e ir introduciéndolos en el array.]

Para barajar, yo lo que hago es ir cogiendo elementos, e ir colocándolos en un array en posiciones aleatorias.

O lo que es lo mismo, ir cogiendo elementos aleatorios, e ir introduciéndolos en el array.
Así para barajar en un tiempo finito.

Si no te he entendido mal ivancea96, la colocación en el array o.k, lo vas llenando desde cero al final, pero al tomar un elemento aleatorio puede suceder que ya lo hayas tomado, con lo que necesitarías poner un valor flag para indicar que ese elemento ya se ha tomado. En estas circunstancias estarías igual que el método que David8 y yo hemos propuesto como alternativa.

Todo esto si te he entendido bien, vete tu a saber.

Yo casi me quedaría con el método de coger la lista ordenada, como sugirió amchacon, y desordenarla aleatoriamente. por intercambio aleatorio de posiciones un cierto número de veces y listo. Así tenemos controladas las iteracione a realizar.

¡¡¡¡ Saluditos! ..... !!!!

[EDITO]

Una sugerencia para Eternal Idol, me parece que sería conveniente que cuando se modifica el post se obligue a poner una pequeña descripción del motivo, leí a primera hora de la mañana(Argentina) lo que posteo leo y luego encuentro "Última modificación: Hoy a las 16:57 por leosansan" y me interesaría saber que modificó, creo que me/nos ayudaría a comprender  más fácilmente el contenido del mismo, sólo una sugerencia que tal vez ni llegues a leer.-

Aclaro la modificación.

En el primer código en borrador que hice no elimine los espacios en blanco de la cadena auxiliar por lo que aparecía la línea:

Código (cpp) [Seleccionar] Expandir

if (!isdigit(auxiliar[j]) && auxiliar[j]!=' ' ){

Me dí cuenta que los espacios en blanco engorrinaban el código y surgió el código que colgué donde los eliminaba previamente de la cadena auxiliar. Pero con las prisas se me olvidó que entonces el:

Código (cpp) [Seleccionar] Expandir

&& auxiliar[j]!=' '

Estaba de más, no mal, de más. Al verlo por la tarde me dí cuenta y lo corregí eliminando y dejando la línea como:

Código (cpp) [Seleccionar] Expandir

if (!isdigit(auxiliar[j])){

Una corrección menor por lo que no puse el mensaje de EDITADO que pongo cuando cambio algo sustancial. Yo al menos hago eso, para que quede constancia.

Espero haber aclarado las posibles dudas que planteaban en el comentario.

Salu2!.


EDITO: Además del error de un nuevo post, sorry, sorry, la mayor parte de las ediciones son meras correcciones ortográficas, como la de ahora en que tenía puesto dnde en lugar de donde.

..........................................................
El problema es que llegar a tardar un tiempo infinito en mezclar el mazo.... si una de las combinaciones (fila, columna) no se da hasta pasadas miles de iteraciones... pues ahí que te quedas esperando.

Creo que últimamente menospreciamos la potencia de proceso de nuestros PC.

Como media a mi me tarda menos de 0.020s.

Ya hace un tiempo hubo una discusión acerca de cuánto tiempo se emplearía en rellenar, con el mismo método, una matriz 10x10 con números del 1 al 1000 y andaba por los 0.012s y acabó en este otro tema.

Salu2!.