Como faço para classificar uma matriz multidimensional em PHP

Eu tenho dados CSV carregados em um array multidimensional. Desta forma, cada "linha" é um registro e cada "coluna" contém o mesmo tipo de dados. Estou usando a função abaixo para carregar meu arquivo CSV.

function f_parse_csv($file, $longest, $delimiter)
{
  $mdarray = array();
  $file    = fopen($file, "r");
  while ($line = fgetcsv($file, $longest, $delimiter))
  {
    array_push($mdarray, $line);
  }
  fclose($file);
  return $mdarray;
}

Eu preciso ser capaz de especificar uma coluna para classificar, para que ela reorganize as linhas. Uma das colunas contém informações de data no formato de Y-m-d H: i: s e gostaria de poder classificar com a data mais recente sendo a primeira linha.

0
(2 anos depois ...) Se você está classificando as datas armazenadas como strings, você deve primeiro usar strtotime [1] docs.php.net/manual/en/function.strtotime.php
adicionado o autor Dan Burton, fonte

11 Respostas

Com usort . Aqui está uma solução genérica, que você pode usar para diferentes colunas:

class TableSorter {
  protected $column;
  function __construct($column) {
    $this->column = $column;
  }
  function sort($table) {
    usort($table, array($this, 'compare'));
    return $table;
  }
  function compare($a, $b) {
    if ($a[$this->column] == $b[$this->column]) {
      return 0;
    }
    return ($a[$this->column] < $b[$this->column]) ? -1 : 1;
  }
}

Para classificar pela primeira coluna:

$sorter = new TableSorter(0);//sort by first column
$mdarray = $sorter->sort($mdarray);
0
adicionado
Substitua "protrected" por "var" e "__construct" por "TableSorter", e isso funcionará em PHP4. Observe, no entanto, que o PHP4 foi descontinuado.
adicionado o autor troelskn, fonte
Eu recebo erro de análise: erro de análise, T_STRING inesperado, esperando T_OLD_FUNCTION ou T_FUNCTION ou T_VAR ou '}' na segunda linha dessa classe.
adicionado o autor Melikoth, fonte
Eu configurei o PHP para v5, não sabia que estava rodando v4 por padrão. Tendo olhado para ele por um tempo eu acho que eu entendo como modificá-lo para diferentes tipos de tipos, bem
adicionado o autor Melikoth, fonte
este código requer php5
adicionado o autor Devon, fonte

Antes que eu pudesse fazer com que a classe TableSorter fosse executada, eu criei uma função baseada no que Shinhan havia fornecido.

function sort2d_bycolumn($array, $column, $method, $has_header)
  {
  if ($has_header)  $header = array_shift($array);
  foreach ($array as $key => $row) {
    $narray[$key]  = $row[$column]; 
    }
  array_multisort($narray, $method, $array);
  if ($has_header) array_unshift($array, $header);
  return $array;
  }
  • $ array é o MD Array que você deseja classificar.
  • $ coluna é a coluna pela qual você deseja classificar.
  • O método
  • $ é como você deseja que a classificação seja executada, como SORT_DESC
  • $ has_header é definido como verdadeiro se a primeira linha contiver valores de cabeçalho que você não deseja classificados.
0
adicionado

Classificação de várias linhas usando um fechamento

Aqui está outra abordagem usando uasort() e uma função de retorno de chamada anônima (fechamento). Eu usei essa função regularmente. PHP 5.3 necessário - não há mais dependências!

/**
 * Sorting array of associative arrays - Classificação de várias linhas usando um fechamento.
 * See also: http://the-art-of-web.com/php/sortarray/
 *
 * @param array $data input-array
 * @param string|array $fields array-keys
 * @license Public Domain
 * @return array
 */
function sortArray( $data, $field ) {
    $field = (array) $field;
    uasort( $data, function($a, $b) use($field) {
        $retval = 0;
        foreach( $field as $fieldname ) {
            if( $retval == 0 ) $retval = strnatcmp( $a[$fieldname], $b[$fieldname] );
        }
        return $retval;
    } );
    return $data;
}

/* example */
$data = array(
    array( "firstname" => "Mary", "lastname" => "Johnson", "age" => 25 ),
    array( "firstname" => "Amanda", "lastname" => "Miller", "age" => 18 ),
    array( "firstname" => "James", "lastname" => "Brown", "age" => 31 ),
    array( "firstname" => "Patricia", "lastname" => "Williams", "age" => 7 ),
    array( "firstname" => "Michael", "lastname" => "Davis", "age" => 43 ),
    array( "firstname" => "Sarah", "lastname" => "Miller", "age" => 24 ),
    array( "firstname" => "Patrick", "lastname" => "Miller", "age" => 27 )
);

$data = sortArray( $data, 'age' );
$data = sortArray( $data, array( 'lastname', 'firstname' ) );
0
adicionado

Apresentando: uma solução muito generalizada para o PHP 5.3+

Gostaria de adicionar minha própria solução aqui, pois oferece recursos que outras respostas não oferecem.

Especificamente, as vantagens desta solução incluem:

  1. É reutilizável : você especifica a coluna de classificação como uma variável em vez de codificá-la.
  2. É flexível : você pode especificar várias colunas de classificação (quantas quiser) - colunas adicionais são usadas como desempatadores entre itens que inicialmente são iguais.
  3. É reversível : você pode especificar que a classificação deve ser revertida - individualmente para cada coluna.
  4. É extensível : se o conjunto de dados contiver colunas que não podem ser comparadas de maneira "burra" (por exemplo, strings de data), você também pode especificar como converter esses itens em um valor diretamente comparado (por exemplo, uma instância DateTime ).
  5. É associativo se você quiser : esse código cuida da classificação de itens, mas você seleciona a função de classificação real ( usort ou uasort ).
  6. Finalmente, ele não usa array_multisort : enquanto array_multisort é conveniente, depende da criação de uma projeção de todos os seus dados de entrada antes da classificação. Isso consome tempo e memória e pode ser simplesmente proibitivo se o conjunto de dados for grande.

O código

function make_comparer() {
   //Normalize criteria up front so that the comparer finds everything tidy
    $criteria = func_get_args();
    foreach ($criteria as $index => $criterion) {
        $criteria[$index] = is_array($criterion)
            ? array_pad($criterion, 3, null)
            : array($criterion, SORT_ASC, null);
    }

    return function($first, $second) use (&$criteria) {
        foreach ($criteria as $criterion) {
           //How will we compare this round?
            list($column, $sortOrder, $projection) = $criterion;
            $sortOrder = $sortOrder === SORT_DESC ? -1 : 1;

           //If a projection was defined project the values now
            if ($projection) {
                $lhs = call_user_func($projection, $first[$column]);
                $rhs = call_user_func($projection, $second[$column]);
            }
            else {
                $lhs = $first[$column];
                $rhs = $second[$column];
            }

           //Do the actual comparison; do not return if equal
            if ($lhs < $rhs) {
                return -1 * $sortOrder;
            }
            else if ($lhs > $rhs) {
                return 1 * $sortOrder;
            }
        }

        return 0;//tiebreakers exhausted, so $first == $second
    };
}

Como usar

Ao longo desta seção, fornecerei links que classificam esse conjunto de dados de amostra:

$data = array(
    array('zz', 'name' => 'Jack', 'number' => 22, 'birthday' => '12/03/1980'),
    array('xx', 'name' => 'Adam', 'number' => 16, 'birthday' => '01/12/1979'),
    array('aa', 'name' => 'Paul', 'number' => 16, 'birthday' => '03/11/1987'),
    array('cc', 'name' => 'Helen', 'number' => 44, 'birthday' => '24/06/1967'),
);

O básico

A função make_comparer aceita um número variável de argumentos que definem a ordenação desejada e retorna uma função que você deveria usar como argumento para usort ou uasort .

O caso de uso mais simples é passar a chave que você gostaria de usar para comparar itens de dados. Por exemplo, para classificar $ data </​​code> pelo item name , você faria

usort($data, make_comparer('name'));

See it in action.

A chave também pode ser um número se os itens forem matrizes numericamente indexadas. Para o exemplo na pergunta, isso seria

usort($data, make_comparer(0));//0 = first numerically indexed column

See it in action.

Colunas de classificação múltipla

You can specify Colunas de classificação múltipla by passing additional parameters to make_comparer. For example, to sort by "number" and then by the zero-indexed column:

usort($data, make_comparer('number', 0));

See it in action.

Características avançadas

More Características avançadas are available if you specify a sort column as an array instead of a simple string. This array should be numerically indexed, and must contain these items:

0 => the column name to sort on (mandatory)
1 => either SORT_ASC or SORT_DESC (optional)
2 => a projection function (optional)

Vamos ver como podemos usar esses recursos.

Ordenação reversa

Para classificar por nome descendente:

usort($data, make_comparer(['name', SORT_DESC]));

See it in action.

Para classificar por número decrescente e depois por nome decrescente:

usort($data, make_comparer(['number', SORT_DESC], ['name', SORT_DESC]));

See it in action.

Projecções personalizadas

Em alguns cenários, você pode precisar classificar por uma coluna cujos valores não emprestam bem à classificação. A coluna "aniversário" no conjunto de dados de amostra se encaixa nessa descrição: não faz sentido comparar os aniversários como sequências de caracteres (porque, por exemplo, "01/01/1980" vem antes de "10/10/1970"). Neste caso, queremos especificar como projetar os dados reais para um formulário que pode ser comparado diretamente com a semântica desejada.

As projeções podem ser especificadas como qualquer tipo de solicitáveis ​​: como strings, matrizes ou funções anônimas. Presume-se que uma projeção aceita um argumento e retorna seu formato projetado.

Deve-se notar que, enquanto as projeções são semelhantes às funções de comparação personalizadas usadas com usort e família, elas são mais simples (você só precisa converter um valor para outro) e aproveita todas as funcionalidades já preparadas em make_comparer .

Vamos classificar o conjunto de dados de exemplo sem uma projeção e ver o que acontece:

usort($data, make_comparer('birthday'));

See it in action.

Esse não foi o resultado desejado. Mas podemos usar date_create como uma projeção:

usort($data, make_comparer(['birthday', SORT_ASC, 'date_create']));

See it in action.

Esta é a ordem correta que queríamos.

Há muitas outras coisas que as projeções podem alcançar. Por exemplo, uma maneira rápida de obter uma classificação insensível a maiúsculas e minúsculas é usar strtolower como uma projeção.

Dito isso, devo mencionar também que é melhor não usar projeções se o conjunto de dados for grande: nesse caso, seria muito mais rápido projetar todos os dados manualmente na frente e depois classificar sem usar uma projeção, embora isso seja feito maior uso de memória para velocidade de classificação mais rápida.

Finalmente, aqui está um exemplo que usa todos os recursos: primeiro classifica por número decrescente, depois por ascendente de aniversário:

usort($data, make_comparer(
    ['number', SORT_DESC],
    ['birthday', SORT_ASC, 'date_create']
));

See it in action.

0
adicionado
Facilmente a resposta mais subestimada neste site.
adicionado o autor jmeas, fonte
Esta é provavelmente a melhor resposta que vi no stackoverflow. Obrigado pelo belo pedaço de código e pela maravilhosa documentação !!!
adicionado o autor maddob, fonte
@Jon Obrigado pela resposta incrível. No entanto, acho difícil de usar. Você poderia por favor me avisar sobre PHP "> stackoverflow.com/questions/36784955/…
adicionado o autor Ironic, fonte
@Jon obrigado pelo seu comentário. No entanto, ainda estou lendo sua resposta e tentando entendê-la. Se necessário eu vou usar o mesmo no meu projeto. Apenas tive uma dúvida. Não tenho certeza se vai funcionar com meus dados/matriz ou não. No seu exemplo, os dados estão em formato diferente.
adicionado o autor Ironic, fonte
@Jon Quando eu verifico sua última ação (com o callback date_create ), o aniversário está na ordem errada. VocÊ poderia confirmar ? Eu recebo 01/12/1979 , 03/11/1987 , 12/03/1980 e 24/06/1967 . Se eu usar strtotime , obtenho um bom resultado. Eu suponho que é o DateTime que está quebrado.
adicionado o autor David Bélanger, fonte
Ei, @Jon, eu não sei como posso contatá-lo, mas através de comentários. Vejo que você criou a tag "array multidimensional", mas também precisamos de "dados multidimensionais" para termos semelhantes em visualizações de dados e disciplinas relacionadas. Não consigo criar tags, posso pedir-lhe para criar uma, se achar que faz sentido?
adicionado o autor VividD, fonte
Estou um pouco atrasado para a festa aqui, mas só quero agradecer por isso. Muito útil.
adicionado o autor RobertAKARobin, fonte
@Dashrath: Não sei o que você estrutura é. Ou passe em $ array ['index'] se você quiser se livrar do nível mais alto, ou então use uma função de projeção ($ sub) {return $ sub ['index'] ; } se você quiser se livrar de uma dimensão de nível médio denominada index .
adicionado o autor Jon, fonte
@CalculatingMachine Eu li a pergunta, mas você não mostra o que tentou fazer. Parece que apenas o usort ($ data ['content'], get_comparer ('price')) seria suficiente, mas não tenho certeza.
adicionado o autor Jon, fonte
@VividD: eu mesmo não criei a tag e a criação de tags não pode acontecer sozinha. Novas tags são implicitamente criadas quando alguém com os privilégios necessários as usa para marcar uma pergunta; dado que eu nunca vi e provavelmente nunca verei uma pergunta que eu sinto que deveria ser marcada assim, eu realmente não posso ajudar.
adicionado o autor Jon, fonte
@ YahyaE: Classificando matrizes de objetos? Substitua $ first [$ column] por $ first -> $ column e o mesmo por $ second . Quatro substituições no total.
adicionado o autor Jon, fonte
@Ecropolis: PHP 5.3 não suporta a sintaxe curta da matriz, você terá que usar array (...) . Eu não fiz isso nos exemplos para uma brevidade extra, mas o make_comparer em si é compatível com o 5.3.
adicionado o autor Jon, fonte
@Ecropolis: Você tem citações extras sobre a função ($ t) ... que precisa ser removida. Felicidades!
adicionado o autor Jon, fonte
@Ecropolis: OK, então você pode fazer uma matriz onde as chaves são tipos de arquivos e os valores são "pesos" (menor peso = item vai no topo) com $ weights = array_flip ($ sort_array) . $ weights agora é ['mp4' => 0, 'mpeg' => 1, ...] . Você pode então utilizar isso no comparador, classificando o tipo de arquivo e usando isso como uma projeção: function ($ t) use ($ weights) {return $ weights [$ t]; }) .
adicionado o autor Jon, fonte
@ Andrew: Exemplo . Mas lembre-se de que isso é ineficiente, portanto, não faça isso se o conjunto de dados não for pequeno.
adicionado o autor Jon, fonte
@Ecropolis: Por favor, poste um bom exemplo de sua entrada (s) e saída desejada em algum lugar (por exemplo ideone.com ou pastebin.com) para que possamos eliminar mal-entendidos.
adicionado o autor Jon, fonte
@ DavidBélanger: Qual URL exatamente? Todos os exemplos funcionam corretamente em ideone.com e na minha máquina local.
adicionado o autor Jon, fonte
@Jon obrigado, eu apenas tentei e é 0.006 seg mais lento do que sem ele, classificando 200 linhas. Eu acho que vou aceitar esse tipo de ineficiência :)
adicionado o autor Andrew, fonte
Você poderia dar um exemplo de como implementar uma classificação insensível a maiúsculas e minúsculas? Eu tentei converter projeção para minúscula, mas não vai funcionar ...
adicionado o autor Andrew, fonte
@Jon - Obrigado, aqui estão exemplos de arrays com comentários. ideone.com/utbrNt
adicionado o autor Ecropolis, fonte
Eu tenho outra matriz de valores que gostaria de classificar uma coluna e o valor na coluna pode ter várias correspondências. A matriz de classificação é de tipos de arquivo, portanto, sempre desejo que os tipos de arquivos de uma lista de arquivos sejam exibidos em uma ordem específica. É possível nesta construção?
adicionado o autor Ecropolis, fonte
Excelente! Obrigado @Jon. Eu atualizei ideone.com/utbrNt para o exemplo completo de como usar essa função para classificar uma matriz usando outra para valores de classificação de referência.
adicionado o autor Ecropolis, fonte
@Jon - Obrigado por toda sua ajuda. Eu tentei implementar isso no meu servidor e eu recebo este: PHP Erro de análise: erro de sintaxe, inesperado '[', esperando ')' - Eu tentei variação diferente, estou um pouco perdido em como isso realmente funciona. Estou na v5.3.28 - ideone.com executa PHP 5.4 - é que a questão?
adicionado o autor Ecropolis, fonte
o meu é um array 4D? Como posso passar o índice se isso for possível?
adicionado o autor Dashrath, fonte
@Jon Grande resposta e eu concordo que isso é como um site em vez de responder. Obrigado. Só tem uma pergunta. Como posso fazer funcionar para executar objetos?
adicionado o autor YahyaE, fonte

The "Usort" function is your answer.
http://php.net/usort

0
adicionado
Desviei você por causa de sua falha em fornecer uma solução com explicação e exemplos para a pergunta original. Atualize sua resposta e eu vou reverter o meu voto.
adicionado o autor crafter, fonte

You can use array_multisort()

Tente algo assim:

foreach ($mdarray as $key => $row) {
   //replace 0 with the field's index/key
    $dates[$key]  = $row[0];
}

array_multisort($dates, SORT_DESC, $mdarray);

For PHP >= 5.5.0 just extract the column to sort by. No need for the loop:

array_multisort(array_column($mdarray, 0), SORT_DESC, $mdarray);
0
adicionado
Portanto, neste exemplo, $ mdarray pode ser uma matriz bidimensional, como uma matriz de registros de banco de dados. Neste exemplo, 0 é o índice da coluna 'data' em cada registro (ou linha). Então você constrói o array $ dates (basicamente o mesmo array, mas com apenas aquela coluna), e diz à função array_multisort para classificar o $ mdarray baseado nos valores daquela coluna em particular.
adicionado o autor Dan Burton, fonte
Para maior clareza, você pode adicionar ao início deste exemplo $ dates = array ();
adicionado o autor Dan Burton, fonte
Acho que isso me mostra porque eu não consegui fazer o array_multisort funcionar antes.
adicionado o autor Melikoth, fonte
Deveria array_multisort trabalhar com matrizes associativas (mudando $ row [0] para $ row ['whatever'] ? Não vá aqui. Depois eu mudei meu array para numérico a função funcionou como esperado.
adicionado o autor a coder, fonte
Há um exemplo mais extenso dessa resposta agora na página PHP array_multisort: php.net/manual/en/function.array-multisort.php#example-4928 .
adicionado o autor icc97, fonte
Aviso: array_multisort (): os tamanhos das matrizes são inconsistentes
adicionado o autor RaviPatidar, fonte
array_multisort() é o jeito que eu sempre fiz isso, embora possa ser um pouco difícil de entender como funciona no começo.
adicionado o autor Garrett Albright, fonte
Se array_multi_sort() é a resposta, a questão não foi entendida. Embora tecnicamente funcione, geralmente há uma solução melhor com uma função de comparação gerada pelo usuário e o uso de uma função usort() . É mais fácil de manter. Com multisort, você geralmente cria um código que prepara os dados para classificação. Se a estrutura de dados mudar, esse código pode ser descartado. Com usort (), você altera a função de comparação - da mesma forma que alterou a estrutura de dados.
adicionado o autor Sven, fonte
Esta resposta realmente me ajudou no meu projeto atual, obrigado!
adicionado o autor Stephen, fonte
A inclusão da $ key não é desnecessária ao usar array_multisort() ? Parece mais simples e mais intencional escrever foreach ($ mdarray as $ row) {$ sortByDate [] = $ row ['date']; } então array_multisort ($ sortByDate, SORT_DESC, $ mdarray); (sua milhagem semântica é variada).
adicionado o autor Mark Fox, fonte
Por alguma razão desconhecida, o usort não funcionou para mim. Isso faz.
adicionado o autor cameronjonesweb, fonte
Resposta fantástica. Isso funciona muito bem para mim
adicionado o autor Raul A., fonte

Eu prefiro usar array_multisort. Veja a documentação aqui .

0
adicionado

Aqui está uma classe php4/php5 que irá ordenar um ou mais campos:

// a sorter class
//  php4 and php5 compatible
class Sorter {

  var $sort_fields;
  var $backwards = false;
  var $numeric = false;

  function sort() {
    $args = func_get_args();
    $array = $args[0];
    if (!$array) return array();
    $this->sort_fields = array_slice($args, 1);
    if (!$this->sort_fields) return $array();

    if ($this->numeric) {
      usort($array, array($this, 'numericCompare'));
    } else {
      usort($array, array($this, 'stringCompare'));
    }
    return $array;
  }

  function numericCompare($a, $b) {
    foreach($this->sort_fields as $sort_field) {
      if ($a[$sort_field] == $b[$sort_field]) {
        continue;
      }
      return ($a[$sort_field] < $b[$sort_field]) ? ($this->backwards ? 1 : -1) : ($this->backwards ? -1 : 1);
    }
    return 0;
  }

  function stringCompare($a, $b) {
    foreach($this->sort_fields as $sort_field) {
      $cmp_result = strcasecmp($a[$sort_field], $b[$sort_field]);
      if ($cmp_result == 0) continue;

      return ($this->backwards ? -$cmp_result : $cmp_result);
    }
    return 0;
  }
}

/////////////////////
// usage examples

// some starting data
$start_data = array(
  array('first_name' => 'John', 'last_name' => 'Smith', 'age' => 10),
  array('first_name' => 'Joe', 'last_name' => 'Smith', 'age' => 11),
  array('first_name' => 'Jake', 'last_name' => 'Xample', 'age' => 9),
);

// sort by last_name, then first_name
$sorter = new Sorter();
print_r($sorter->sort($start_data, 'last_name', 'first_name'));

// sort by first_name, then last_name
$sorter = new Sorter();
print_r($sorter->sort($start_data, 'first_name', 'last_name'));

// sort by last_name, then first_name (backwards)
$sorter = new Sorter();
$sorter->backwards = true;
print_r($sorter->sort($start_data, 'last_name', 'first_name'));

// sort numerically by age
$sorter = new Sorter();
$sorter->numeric = true;
print_r($sorter->sort($start_data, 'age'));
0
adicionado
Isso funciona apenas com matrizes associativas?
adicionado o autor Melikoth, fonte
sim - somente arrays associativos. Agora que vejo isso, não é a solução certa para esse problema.
adicionado o autor Devon, fonte

Eu sei que são 2 anos desde que essa pergunta foi feita e respondida, mas aqui está outra função que classifica uma matriz bidimensional. Ele aceita um número variável de argumentos, permitindo que você passe mais de uma chave (por exemplo, nome da coluna) para classificar. PHP 5.3 requerido.

function sort_multi_array ($array, $key)
{
  $keys = array();
  for ($i=1;$i< $b[$keys[$i]]) ? -1 : 1;
      }
    }
    return 0;
  };

  usort($array, $func);

  return $array;
}

Try it here: http://www.exorithm.com/algorithm/view/sort_multi_array

0
adicionado
sim, acredito que sim
adicionado o autor Mike C, fonte

Eu tentei várias respostas populares de array_multisort() e usort() e nenhuma delas funcionou para mim. Os dados ficam confusos e o código é ilegível. Aqui está uma solução rápida e suja. AVISO: Use-o somente se tiver certeza de que um delimitador não autorizado não voltará para assombrá-lo mais tarde!

Digamos que cada linha em sua matriz múltipla se pareça com: name, stuff1, stuff2:

// Sort by name, pull the other stuff along for the ride
foreach ($names_stuff as $name_stuff) {
   //To sort by stuff1, that would be first in the contatenation
    $sorted_names[] = $name_stuff[0] .','. name_stuff[1] .','. $name_stuff[2];
}
sort($sorted_names, SORT_STRING);

Precisa de suas coisas em ordem alfabética?

foreach ($sorted_names as $sorted_name) {
    $name_stuff = explode(',',$sorted_name);
   //use your $name_stuff[0] 
   //use your $name_stuff[1] 
   //... 
}

Sim, está sujo. Mas super fácil, não vai fazer sua cabeça explodir.

0
adicionado
function cmp($a, $b)
{
$p1 = $a['price'];
$p2 = $b['price'];
return (float)$p1 > (float)$p2;
}
uasort($my_array, "cmp");

http://qaify.com/sort-an-array-of-associative-arrays-by-value-of-given-key-in-php/

0
adicionado
PHP Brasil
PHP Brasil
3 048 dos participantes

Neste grupo pregamos o respeito ao próximo e não são permitidas ações que sejam contrárias à isso. Conduta: https://bit.ly/2CImbaA Off-topic: https://bit.ly/2x64Dzf Blog: https://brasil-php.github.io/blog Use /rules para ver detalhes das regras

PHP Brasil Off
PHP Brasil Off
167 dos participantes

Regras: não há regras