array = funcion OrdenarYEliminarRepes( array Ar() )
    entero k, min, max, n
    array temp(), salida()
 
    // recorrer el array para buscar el valor mayor y menor del array
    min = ar(0)
    max = min
    bucle para k desde 1 a ar.count-1
        si (ar(k) < min) luego
            min = ar(k)
        oSi (ar(k) > max) luego
            max = ar(k)
        fin si 
    fin bucle

    // OJO: si min es pongamos 20 y máx 100 millones se creará un array de 100 millones-20, aunque tu array de entrada solo tenga 40 valores...
    redimensionar temp(desde 0 hasta max-min) 

    // recorrer el bucle otra vez para saber quñe valores aparecen y consignarlos en el array temp.
    bucle para k desde 0 hasta ar.count-1
        si (temp( ar(k)+min ) = 0) luego
            n +=1
            temp( ar(k)+min ) = 1
        fin si
    fin bucle

    redimensionar salida (0 a n-1)
    n = 0 
    // recorrer el array temp, para consignar los valores presentes a la salida.
    bucle para k desde 0 hasta max-min
        si (temp( ar(k)+min ) = 1) luego
            salida(n) = temp( ar(k)+min )
            n +=1
        fin si
    fin bucle

    devolver salida
fin funcion

array de bytes Baraja(0 a 39) //también podría ser bidimensional (0 a 3, 0 a 9)
entero siguienteCarta   // el índice de la carta que actualmente está arriba en la banca (lista para salir).

// Esta función genera la baraja. Cada carta aparece 1 solo 1 vez.
funcion RellenarBaraja
    entero j, k, i, n

    i = 0
    bucle para k de 0 a 3
        bucle para j de 0 a 9
            Baraja(n) = (i+j)  // basta un solo bucle desde 0 a 39, pero lo hago en 2 bucles
                                      // para que entiendas la equivalencia resuelta con un array bidimensional 
                                       // Baraja(k,j) = (i+j)
        fin bucle
        i +=10
    fin bucle

    llamada a Barajar(2)
fin funcion

// Esta función baraja las cartas, esto es las cambia de orden.
funcion Barajar(entero veces)
    entero k, j, i, n

    Si (veces<1) luego   // se debe barajaral menos una vez.
        veces = 1
    OSi (veces>9) luego  // tampoco queremos barajar 1000 veces, no es necesario...
        veces = 9
    Fin si

    bucle para j desde 0 a veces-1
        bucle para k desde 39 hasta 1 regresivamente
            //elegir al azar un índice entre 0 y el actual del ciclo
            i = aleatorio(entre 0 y k)
            // intercambiar los valores de los índices de ciclo y elegido al azar   
            n = baraja(i)                
            baraja(i) = baraja(k)
            baraja(k) = n 
        fin bucle
    fin bucle

    siguienteCarta  = 0  // el índice la carta actual en la banca es la primera.
fin funcion

estructura Jugador
    string nombre //un nombre para el jugador, así cuando se pase el turno, se indica su nombre. Esto debe establecerse al iniicio del juego (una única vez)
    array de bytes Cartas(0 a 39) //dijimos que repartimos 5, si un jugador puede tener más cartas que las que se reparten, 
                   // el tamaño del array debe aumentarse hasta tal posibilidad, si se ignora, debe ser el mismo tamaño de la baraja. 
                   // Prevenimos tal situacion si ya albergamos esa posibilidad. La baraja también podría ser un jugador de nombre "La Banca", con esa misma cantidad de cartas en el array... 
                  // Si el tamaño es el de la baraja, basta con crear los arrays al inicio del juego una única vez.
    entero cantidad  //número de cartas que tiene actualmente, esto evita redimensionar el array, porque apunta a la sigueinte (en realidad a la anterior).
    // otros datos que convenga que se mantenga para cada jugador.
fin estructura

Array de jugador jugadores(0 a 3)  //4 jugadores, ó (0 a 4), siendo la banca el jugador 0 y el resto los jugadores en lid.

// Esta función es la correcta cuando cada reparto sucede que todos los jugadores se han descartado, si no es así, el procedimiento debe variar (se pone debajo una aproximación al caso).
entero = funcion RepartirBorrando(entero numJugadores, entero numCartas, entero desde) 
    entero j, k, i, n

    // borra-sobrescribe valores previos.
    bucle para k desde 0 a numJugadores-1 // jugadores
        jugadores(k).tengoAses = 0 // se borran todos los ases que tuviere, si le quedan...
        //realojar espacio para jugadores(k).cartas(0 numcartas -1)
        // pero si el array es del tamaño de la baraja basta hacerlo solo al inicio del juego, no tras cada partida ni reparto de cartas.
        jugadores(k).cantidad = numCartas //esto no es estrictamente necesario, se establece a  
    fin bucle

    bucle para j desde 0 a numCartas-1  //cartas
        bucle para k desde 0 a numJugadores-1 // jugadores
              n= baraja(desde)
              jugadores(k).cartas(j) = n            
              desde +=1
        fin bucle
    fin bucle

    devolver desde // desde lleva la cuenta de cartas gastadas, en la banca.
fin funcion

entero = funcion Repartir(entero numJugadores, entero numCartas, entero desde) 
    entero j, k, i, n

    // OJO: nótese que aquí se ha intercambiado el orden de los bucles (facilidad para el código, el reparto sigue siendo aleatorio, pués las cartas están barajadas y nadie sabe donde ni cuales.
    bucle para k desde 0 a numJugadores-1 // jugadores
        i = jugadores(k).cantidad
        bucle para j desde 0 a numCartas-1  //cartas
              n= baraja(desde)
              jugadores(k).cartas(i + j) = n           
              desde +=1
        fin bucle
        jugadores(k).cantidad += numCartas // suma las que se reparten a las que se tiene actualmente
    fin bucle

    devolver desde // desde lleva la cuenta de cartas gastadas, en la banca.
fin funcion

entero funcion SiguienteTurno(entero turno) //, entero indiceCarta para elcaso de que sea el jugador quien decide qué carta se arroja.
    entero j, k , i, n

    k =  jugadores(turno).cantidad -1

    // tomar la siguiente carta:
    si se elige al azar
        i = Aleatorio(entre 0 y k)         
    oSi se toma la siguiente que sigue en secuencia
        i = k         
    oSi decidio el usuario 
        i = indiceCarta
    fin si
     // valor de la carta seleccionada
    n = jugadores(turno).cartas( i )

    // Esto solo si elegir la carta supone descartarse de ella.
    Si decidio el usuario // y la carta se debe descartar, esta se pasa atrás... las válidas son las 'cantidad-1' primeras en el array de ese jugador
        jugadores(turno).cartas( i ) = jugadores(turno).cartas( k )  
        jugadores(turno).cartas( k ) = n
    fin si
    jugadores(turno).cantidad -=1   

    
    // evaluar si es un as y que as, es
    si ((n modulo 10) = 0 ) luego  // ¿la carta 'n' es un AS?
        n = (n / 10)  // ¿qué AS, es?  0, 10, 20, 30 // por ejemplo oros, copas, espadas y bastos, respectivamente, tu decides...
        // Si (n = AsPalo) luego ... caso de que deba ser un as especifico y no cualquiera de ellos
            // retirar una carta a cada uno de los jugadores restantes (sin saber que se hace con ellas, se supone que solo se le retira 1 y nada más)
            bucle para j desde 0 a numJugadores-1
                Si (j <> turno) luego //distinto de   //no se puede quitar carta a sí mismo.
                     si  (jugadores(j).cantidad >0) luego
                          jugadores(j).cantidad -=1   //le quitamos la última, si es al azar, 
                                    // proceder como más arriba, elegir al azar entre las que reste
                                    // intercambiarla por la última 'válida' y restar una a la cantidad.
                     fin si
                fin si
            fin bucle 
        // fin si
    fin si


    devolver ((turno + 1) modulo numJugadores) //0-1-2-3-0-1-2-3-0-1-2--->3--->0
fin funcion

 buleano = funcion Iguales(entero x, entero n)
  devolver ((x modulo 40) = (n modulo 40))
fin funcion