Foro - Perl en Español

Hola a todos:

Me encuentro con un problema que no sé cómo resolver. He intentado hacer con bucles for, pero es muy lioso y creo que debe haber un modo mejor. Ojalá puedan ayudarme.

Tengo un hash formado por 3 array de 10 elementos cada uno:



Me gustaría poder ordenar los array del hash, fijándonos solo en los scores, de menor a mayor; con lo que quedaría:



¿Se os ocurre alguna forma eficiente de hacerlo?

Gracias, como siempre,

Xagutxu

A ver, veo que tienen relación las posiciones que hay entre scores, grupos y marcas, entonces, ¿por qué no haces un hash que tenga 10 llaves, y en cada llave tenga los 3 valores? sería más fácil ordenarlo...

Podría ser un hash de hashes



Para ordenarlo deberías de usar algo así como



No probé el código pero estoy casi seguro que te lo ordenará por los valores de los scores de cada hash...

Saludos

Lo más inmediato es pensar en usar la función sort(), pero como los datos están algo 'separados', tenemos que crear algún artificio para, primero unirles y luego dejarlo como estaba.

Una primera solución es como la que comenta monoswim: crear una estructura más fácil de ordenar que la que tenemos. Ordenarla y luego dejarlo con la apariencia que tenía originalmente.La salida es:

Código: Seleccionar todo

%hash = (
          'scores' => [
                        '1',
                        '3',
                        '1',
                        '2',
                        '3',
                        '3',
                        '1',
                        '5',
                        '2',
                        '3'
                      ],
          'marcas' => [
                        'X',
                        'X',
                        'Y',
                        'X',
                        'Y',
                        'Y',
                        'Y',
                        'Y',
                        'X',
                        'X'
                      ],
          'grupos' => [
                        'A',
                        'G',
                        'H',
                        'V',
                        'E',
                        'T',
                        'D',
                        'A',
                        'A',
                        'H'
                      ]
        );
@scores = (
            [
              '1',
              'A',
              'X'
            ],
            [
              '3',
              'G',
              'X'
            ],
            [
              '1',
              'H',
              'Y'
            ],
            [
              '2',
              'V',
              'X'
            ],
            [
              '3',
              'E',
              'Y'
            ],
            [
              '3',
              'T',
              'Y'
            ],
            [
              '1',
              'D',
              'Y'
            ],
            [
              '5',
              'A',
              'Y'
            ],
            [
              '2',
              'A',
              'X'
            ],
            [
              '3',
              'H',
              'X'
            ]
          );
@scores_ordenados = (
                      [
                        '1',
                        'A',
                        'X'
                      ],
                      [
                        '1',
                        'H',
                        'Y'
                      ],
                      [
                        '1',
                        'D',
                        'Y'
                      ],
                      [
                        '2',
                        'V',
                        'X'
                      ],
                      [
                        '2',
                        'A',
                        'X'
                      ],
                      [
                        '3',
                        'G',
                        'X'
                      ],
                      [
                        '3',
                        'E',
                        'Y'
                      ],
                      [
                        '3',
                        'T',
                        'Y'
                      ],
                      [
                        '3',
                        'H',
                        'X'
                      ],
                      [
                        '5',
                        'A',
                        'Y'
                      ]
                    );
%hash_ordenado = (
                   'scores' => [
                                 '1',
                                 '1',
                                 '1',
                                 '2',
                                 '2',
                                 '3',
                                 '3',
                                 '3',
                                 '3',
                                 '5'
                               ],
                   'marcas' => [
                                 'X',
                                 'Y',
                                 'Y',
                                 'X',
                                 'X',
                                 'X',
                                 'Y',
                                 'Y',
                                 'X',
                                 'Y'
                               ],
                   'grupos' => [
                                 'A',
                                 'H',
                                 'D',
                                 'V',
                                 'A',
                                 'G',
                                 'E',
                                 'T',
                                 'H',
                                 'A'
                               ]
                 );

Otra forma, más directa y artística, puede ser esta:
Realmente, las dos soluciones hacen lo mismo, solo que la segunda se ahorra la creación de las variables temporales.

Y finalmente, una solución muy óptima: ordenar los scores recordando la posición en la que estaban. Luego, sacar los elementos del %hash según las nuevas posiciones de los scores ordenados:


Como se puede observar, en todas las soluciones he empleado una transformada Schwartziana.

Seguro que hay otras formas de hacerlo.

Hola:

He estado probando lo que me respondiste, Explorer, y me da un error. He pensado que quizás sea porque no he definido como tú el hash. Yo lo he hecho así:



En realidad, es un poco más largo. Supongo que si "lleno" así el hash %corpus, la solución que me propones (yo he estado probando con la tercera) no funcionará, porque la variable $_ no contendrá lo mismo, ¿no?

Puedo cambiar el hash, pero, entonces, ¿cómo haría para introducir los arrays en el hash?



Así no se puede hacer, ¿no?

Prueba esto:
y verás las diferencias:

Código: Seleccionar todo

$VAR1 = {
          'scores' => [
                        '1',
                        '3',
                        '1',
                        '2',
                        '3',
                        '3',
                        '1',
                        '5',
                        '2',
                        '3'
                      ],
          'marcas' => [
                        'X',
                        'X',
                        'Y',
                        'X',
                        'Y',
                        'Y',
                        'Y',
                        'Y',
                        'X',
                        'X'
                      ],
          'grupos' => [
                        'A',
                        'G',
                        'H',
                        'V',
                        'E',
                        'T',
                        'D',
                        'A',
                        'A',
                        'H'
                      ]
        };
$VAR1 = {
          'scores' => [
                        '1',
                        '3',
                        '1',
                        '2',
                        '3',
                        '3',
                        '1',
                        '5',
                        '2',
                        '3'
                      ],
          'marcas' => [
                        'X',
                        'X',
                        'Y',
                        'X',
                        'Y',
                        'Y',
                        'Y',
                        'Y',
                        'X',
                        'X'
                      ],
          'grupos' => [
                        'A',
                        'G',
                        'H',
                        'V',
                        'E',
                        'T',
                        'D',
                        'A',
                        'A',
                        'H'
                      ]
        };
Odd number of elements in hash assignment at ./kk.pl line 24.
$VAR1 = {
          'A' => 'H',
          'scores' => '1',
          'marcas' => 'X',
          'X' => undef,
          '3' => 'grupos',
          'Y' => 'X',
          'E' => 'T',
          '2' => '3',
          'H' => 'V',
          'D' => 'A',
          '5' => '2'
        };

Como ves, las dos primeras asignaciones son idénticas, pero la tercera no, incluso da un error en pantalla.

Recuerda: Data::Dumper es tu amigo.

Claro, pero entonces, ¿cómo hago para solucionarlo? La variable "$_" será diferente si completo el hash así,



o así:



¿Si defino el hash como el último caso, también es válido el código que escribiste?

Gracias otra vez,

Xagutxu

No, la variable $_ depende de cada contexto. Es la variable "por defecto" dentro de contextos donde normalmente tendríamos que usar una variable.

Ejemplo. Tenemos un bucle así:

Un ejemplo para ejecutar en línea:

Código: Seleccionar todo

explorer@next3:~> perl -le '@x=(1,2,3,4); foreach $i (@x) { print $i; $i++ } print "@x"'
1
2
3
4
2 3 4 5

En bucles tan sencillos, no es necesario el uso de una variable para realizar algo sencillo. En esos casos se puede sustituir por la variable $_, que en el caso de un bucle, adopta el 'valor' de cada elemento del array:Este código hace lo mismo que antes. Observa que en el print no hemos indicado ninguna variable, por lo que print usará la variable $_.

Después del bucle, $_ pierde el significado que tenía dentro.

Así que ya sabes: $_ no tiene NADA que ver con la definición y declaración de otras variables.

P.D. Lo de 'valor' entre comillas, quiere decir que, realmente, no guarda el valor de cada elemento, sino un 'alias'. Por eso, podemos hacer el incremento de los valores del array, de forma directa.

Más información en perlvar