Duda función barajar

[amchacon]

Creo que es obvio que se hace en un array temporal >.>

¿Y después lo vuelves a copiar en el array original?

[leosansan]

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! ..... !!!!

[ivancea96]

El caso, es que cada vez que coges un elemento, se reduce el próximo número máximo del rand() en 1. Si un elemento que escoges, ya ha sido cogido, se va al siguiente, así hasta que no haya sido cogido...

[amchacon]

El caso, es que cada vez que coges un elemento, se reduce el próximo número máximo del rand() en 1. Si un elemento que escoges, ya ha sido cogido, se va al siguiente, así hasta que no haya sido cogido...

¿Comor?

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

Quiero ver una implementación ^^

[ivancea96]

¿Si coges un elemento del principio? Ese proceso se repite N veces, siendo N el tamaño del array.

EDITO:

Quiero ver una implementación

Código (cpp) [Seleccionar] Expandir

template<class T>void barajar(vector<T> &v){
    vector<T> t;
    int r=0;
    while(v.size()>0){
        t.push_back(v[r=rand()%v.size()]);
        v.erase(v.begin()+r);
    }
    v = t;
}
Por ejemplo, manejando vectores.

[leosansan]

¿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!.

[amchacon]

Al parecer ya ha editado su post con la implementación... Pero la propuesta de Ivan no es una solución eficiente (intenta mezclar 10 millones de elementos, a mí me tardó 4 minutos...).

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:

Código (cpp) [Seleccionar] Expandir

for (int i = 0;i < v.size(); i++)
   swap(v[i],v[rand()%A.size()]);

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".

La función swap no es más que:

Código (cpp) [Seleccionar] Expandir

void swap(int &a,int &b)
{
   int c = a;
   a = b;
   b = c;
}

[leosansan]

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

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! ..... !!!!

[Eternal Idol]

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.

Acabo ahi despues de que le hicieran la tarea y borrara toda huella para poder presentarla tranquilo