function bestProducts($products, $sales): array {
$ySalesProducts = explode(' ', $sales);
$yFiltered = array_filter(
$ySalesProducts,
function ($item) use ($products) {
return in_array($item, $products, true);
});
$yCount = array_count_values($yFiltered);
arsort($yCount);
$ySlice = array_slice($yCount, 0, 2);
[$first, $second] = array_values($ySlice);
($first === $second)
? ksort($ySlice)
: null;
return $ySlice;
}
$products = [ 'phone', 'mobile', 'game', 'headset', 'hdd', 'ssd' ];
$context = 'phone ssd headset ssd headset mobile headset phone game headset hdd ssd game ssd ssd headset game box box box box box box';
$result = bestProducts($products, $context);
var_dump($result);
Há algum tempo eu estava num desafio de codificação na Plataforma Hacker Rank e apareceu uma questão que usava muitos recursos de ARRAY… pensei comigo, tá no papo! Só que não…
Meu principal erro não foi subestimar o problema, mas sim subestimar a memorização das funções array e o porquê delas existirem. Como de costume, eu sempre recorro as documentações do PHP.net quando estou programando, só que durante uma maratona ou num desafio de programação ter estas funcionalidades prontamente memorizadas faz uma tremenda falta.
Churumelas postas, vamos ao enunciado do problema.
Dada uma lista de produtos ($products) previamente definida, contabilize a quantidade vendida de cada produto dada uma listagem de produtos vendidos ($context). Somente os produtos constantes na lista previamente definida devem ser contabilizados. Ao final selecione apenas os dois produtos mais vendidos, e caso haja um empate classifique os produtos em ordem alfabética. O retorno deve ser um array associativo produto x quantidade.
Observando o enunciado podemos perceber alguns recursos que serão necessários… explode para transformar a lista de produtos vendidos em array, array_filter para excluir quem não está na listagem de produtos pré-definidos, count para contar, sort para classificar, array_shift para pegar os produtos mais vendidos…
Podemos parar por aqui, boa parte destes recursos vão dar na trave, sabe por que? Porque provavelmente você não lembraria de cabeça a diferença entre sort, rsort, asort, arsort, ksort, krsort, usort, uasort, uksort… Talvez você também não lembre algumas funções prontas utilizam exclusivamente índices numéricos e/ou não preservam os índices originais associativos. Outra grande questão é a aplicação em arrays multi-níveis, uma coisa é trabalhar com array simples de um único nível e outra coisa processar array multi-nível em profundidade.
Assim, eu não vou tentar explicar o algoritmo do problema pra vocês; ele é muito simples depois de resolvido e pode facilmente ser entendido apenas você lendo o código. Conforme o enunciado também podemos perceber que os arrays aplicados são de nível simples onde as funções array prontas dão um show. Então eu vou explicar a seguir o que você deveria ter mente ou ter decorado sobre algumas funções array prontas, por que esse é o verdadeiro diferencial que você pode obter.
SORT – sort ordena um array pelo valor do elemento, mas ele despreza completamente os índices originais do array. Sort opera sobre o array original modificando-o completamente, assim bye bye array original depois do sort. Então sort não serve pra você se você precisa manter os índices associativos preservados depois da ordenação.
$y = (['fruit'=>'lemon','salad'=>'lettuce','protein'=>'eggs','carbohydrate'=>'pasta']);
sort($y);
print_r($y);
// [0] => eggs
// [1] => lemon
// [2] => lettuce
// [3] => pasta
RSORT – o mesmo que sort, só que ordena em ordem inversa. Repare que o R a frente de sort significa REVERSE. Lembre-se deste R a frente do sort, ele vai aparecer em outros comandos e terá a mesma semântica.
$y = ['fruit'=>'lemon','salad'=>'lettuce','protein'=>'eggs','carbohydrate'=>'pasta'];
rsort($y);
print_r($y);
// [0] => pasta
// [1] => lettuce
// [2] => lemon
// [3] => eggs
ASORT – o mesmo que sort, só que este aqui preserva os índices originais intactos. Repare que o A a frente de sort significa ASSOCIATIVE, indicando que o comando aplica-se a operações com arrays associativos. Os índices numéricos também serão preservados após a ordenação.
$y = (['fruit'=>'lemon',3=>'bread','salad'=>'lettuce',0=>'rice','protein'=>'eggs',1=>'beans','carbohydrate'=>'pasta']);
asort($y);
print_r($y);
// [1] => beans
// [3] => bread
// [protein] => eggs
// [fruit] => lemon
// [salad] => lettuce
// [carbohydrate] => pasta
// [0] => rice
ARSORT – o mesmo que asort só que a ordenação é feita em ordem inversa. Repare novamente o R antes do sort indica REVERSE ou seja, ordem inversa.
$y = (['fruit'=>'lemon',3=>'bread','salad'=>'lettuce',0=>'rice','protein'=>'eggs',1=>'beans','carbohydrate'=>'pasta']);
arsort($y);
print_r($y);
// [0] => rice
// [carbohydrate] => pasta
// [salad] => lettuce
// [fruit] => lemon
// [protein] => eggs
// [3] => bread
// [1] => beans
KSORT – ordena um array pelo índice e não pelo valor do elemento como faz o sort. Repare que K a frente do sort significa KEY. Aqui nos deparamos com uma primeira situação inusitada, como é comum termos índices mistos compostos por números e strings o tipo de ordenação padrão pode não atender as nossas expectativas. Para corrigir este comportamento basta ativar o segundo parâmetro informando SORT_STRING ou SORT_NATURAL, isso deve resolver a questão.
$y = ['fruit'=>'lemon',3=>'bread','salad'=>'lettuce',0=>'rice','protein'=>'eggs',1=>'beans','carbohydrate'=>'pasta'];
ksort($y);
print_r($y);
// [carbohydrate] => pasta
// [fruit] => lemon
// [salad] => lettuce
// [0] => rice
// [protein] => eggs
// [1] => beans
// [3] => bread
$y = ['fruit'=>'lemon',3=>'bread','salad'=>'lettuce',0=>'rice','protein'=>'eggs',1=>'beans','carbohydrate'=>'pasta'];
ksort($y, SORT_STRING);
print_r($y);
// [0] => rice
// [1] => beans
// [3] => bread
// [carbohydrate] => pasta
// [fruit] => lemon
// [protein] => eggs
// [salad] => lettuce
KRSORT – o mesmo que ksort só que ordenado em ordem inversa.
$y = ['fruit'=>'lemon',3=>'bread','salad'=>'lettuce',0=>'rice','protein'=>'eggs',1=>'beans','carbohydrate'=>'pasta'];
krsort($y, SORT_NATURAL);
print_r($y);
// [salad] => lettuce
// [protein] => eggs
// [fruit] => lemon
// [carbohydrate] => pasta
// [3] => bread
// [1] => beans
// [0] => rice
ARRAY_SLICE – esse aqui é animal, se você precisa quebrar um array em pedaços, sacar a ponta da frente ou até mesmo a ponta de trás do array, mas precisa que esta quebra preserve a combinação key => value do array original?! array_slice é a sua pedida.
$y = ['fruit'=>'lemon',3=>'bread','salad'=>'lettuce',0=>'rice','protein'=>'eggs',1=>'beans','carbohydrate'=>'pasta'];
krsort($y, SORT_STRING);
print_r($y);
// [salad] => lettuce
// [protein] => eggs
// [fruit] => lemon
// [carbohydrate] => pasta
// [3] => bread
// [1] => beans
// [0] => rice
$ys = array_slice($y, 0, 2);
print_r($ys);
// [salad] => lettuce
// [protein] => eggs
ARRAY_PUSH – ARRAY_POP – ARRAY_SHIFT – ARRAY_UNSHIFT – Lembre-se que estas funções não objetivam trabalhar com índices associativos então nenhuma destas funções servirão para o nosso caso. Todos esses quatro comandos operam em nível de elemento valor sem se importar com índices. A cada interação por estes comandos os índices do array são sistematicamente resequenciados.
$y = [];
array_push($y, 'first');
array_push($y, 'second');
array_push($y, 'third');
print_r($y);
// [0] => first
// [1] => second
// [2] => third
$ys = array_shift($y);
print_r($ys);
// first
array_unshift($y, 'zero');
print_r($y);
// [0] => zero
// [1] => second
// [2] => third
$yp = array_pop($y);
print_r($yp);
// third
print_r($y);
// [0] => zero
// [1] => second
ARRAY_COUNT_VALUES – fantástico recurso para contabilizar as ocorrências dos valores em um array. Pense no array de produtos vendidos, usando array_count_values teremos como retorno um array tendo os produtos como chave e as ocorrências de cada produto sumarizadas como valor.
$c = 'phone ssd headset ssd headset mobile headset phone game headset hdd ssd game ssd ssd headset game box box box box box box';
$y = explode(' ', $c);
print_r($y);
// [0] => phone // [12] => game
// [1] => ssd // [13] => ssd
// [2] => headset // [14] => ssd
// [3] => ssd // [15] => headset
// [4] => headset // [16] => game
// [5] => mobile // [17] => box
// [6] => headset // [18] => box
// [7] => phone // [19] => box
// [8] => game // [20] => box
// [9] => headset // [21] => box
// [10] => hdd // [22] => box
// [11] => ssd
$yc = array_count_values($y);
print_r($yc);
// [phone] => 2
// [ssd] => 5
// [headset] => 5
// [mobile] => 1
// [game] => 3
// [hdd] => 1
// [box] => 6
ARRAY_KEYS – retorna os índices de um array como um array de valores. Este novo array retornado será chaveado por índice numérico sequencial.
$y = ['phone'=>2,'ssd'=>5,'headset'=>5,'mobile'=>1,'game'=>3,'hdd'=>1,'box'=>6];
$yk = array_keys($y);
print_r($yk);
// [0] => phone
// [1] => ssd
// [2] => headset
// [3] => mobile
// [4] => game
// [5] => hdd
// [6] => box
ARRAY_VALUES – retorna os valores de um array como um array de valores desprezando os índices originais. O novo array será chaveado por índice numérico sequencial. O array_values trabalha apenas com um nível de array, assim arrays com multi-níveis contendo outros arrays ou objetos serão processados no seu primeiro nível, mas estes subarrays e objetos permanecerão intactos em sua estrutura.
$y = ['phone'=>2,'ssd'=>5,'headset'=>5,'mobile'=>1,'game'=>3,'hdd'=>1,'box'=>6,'sub'=> ['ps5'=>10]];
$yv = array_values($y);
print_r($yv);
// [0] => 2
// [1] => 5
// [2] => 5
// [3] => 1
// [4] => 3
// [5] => 1
// [6] => 6
// [7] => Array
// (
// [ps5] => 10
// )
ARRAY_FLIP – inverte a posição de índices e valores, ou seja, os valores passam a ser índices e os índices passam a ser valores. Mas o array_flip trabalha somente com arrays simples com índices e valores do tipo string e/ou numérico. Caso seu array contenha um outro array ou um objeto o array flip vai emitir um warning mas ainda assim vai funcionar, porém os subarrays e objetos serão ignorados e não farão parte da nova array retornada.
$y = ['phone'=>2,'ssd'=>5,'headset'=>5,'mobile'=>1,'game'=>3,'hdd'=>1,'box'=>6,'sub'=> ['ps5'=>10]];
$yf = array_flip($y);
print_r($yf);
// [2] => phone
// [5] => headset
// [1] => hdd
// [3] => game
// [6] => box
ARRAY_SUM – sumariza ou contabiliza os elementos valores de um array desde que os valores possam ser convertidos para número. Repare que no exemplo o produto box que contém o valor 6txt será convertido para o número 6, pois este é o comportamento de conversão padrão esperado do PHP. Qualquer elemento que não possua um valor numérico, como subarray, objeto, ou texto, não será contabilizado. O retorno é um escalar com o total da somatória dos elementos numéricos.
$y = ['phone'=>'two','ssd'=>5,'headset'=>5,'mobile'=>1,'game'=>3,'hdd'=>1,'box'=>'6txt','sub'=> ['ps5'=>10]];
echo 'total: ' . array_sum($y);
// total: 21
ARRAY_FILTER – O famigerado array_filter é um dos seus maiores aliados. O simples fato de parsear um array com array_filter já elimina todos os elementos com valor null, sem necessidade de nenhuma função callback. Combinado com uma função callback então o poder de sanitização é exponencial. Mas lembre-se, array_filter não é multilevel e não serve para sanitização em profundidade.
$y = ['phone'=>'two','ssd'=>null,'headset'=>'','mobile'=>1,'game'=>3,'hdd'=>null,'box'=>6,'sub'=> ['ps5'=>10, 'ps3'=>null]];
$yt = array_filter($y);
print_r($yt);
// [phone] => two
// [mobile] => 1
// [game] => 3
// [box] => 6
// [sub] => Array
// (
// [ps5] => 10
// [ps3] =>
// )
$ytc = array_filter(
$y,
function($value) {
return !empty($value);
});
print_r($ytc);
// [phone] => two
// [mobile] => 1
// [game] => 3
// [box] => 6
// [sub] => Array
// (
// [ps5] => 10
// [ps3] =>
// )
ARRAY_REVERSE – e sempre teremos o simples reverse para inverter a ordem de um array. Quando você precisa transformar uma pilha LIFO and uma fila FIFO uma ordenação por sort não é seja desejada, então simplesmente aplica-se a inversão da ordem do array com o array_reverse.
$y = (['fruit'=>'lemon',3=>'bread','salad'=>'lettuce',0=>'rice','protein'=>'eggs',1=>'beans','carbohydrate'=>'pasta']);
$yr = array_reverse($y);
print_r($yr);
// [carbohydrate] => pasta
// [0] => beans
// [protein] => eggs
// [1] => rice
// [salad] => lettuce
// [2] => bread
// [fruit] => lemon
ARRAY_COLUMN – esta função é muito útil para manipular dados no formato tipo tabela composto por linhas e colunas. Assim, um array simples não vai funcionar com array_column por que ele precisa receber um array de arrays e é o segundo nível que deve conter os arrays associativos composto pelas colunas de cada linha. Até mesmo objetos são suportados pelo array_column.
Os índices do primeiro nível são irrelevantes para o processo, podem ser numéricos sequenciais ou associativos, eles serão desprezados de qualquer forma.
Além de buscar os valores da coluna desejada, o terceiro parâmetro ainda indica o nome de uma possível coluna na mesma linha cujo valor possa servir de índice para chavear o valor retornado. No mundo real uma chave única como ID seria o indicado. Lembrando que a coluna desejada não precisa existir em todas as linhas de qualquer linear, as linhas que não possuírem esta coluna serão desprezadas durante o processamento.
$y = [
['id'=>'0000','first'=>'Jonh','last'=>'Doe','email'=>'jonh.doe@email'],
['id'=>1000,'first'=>'Mary','last'=>'Loe','email'=>'mary.loe@email'],
['id'=>2000,'first'=>'Marilyn','last'=>'Moe','email'=>'marilyn.moe@email'],
'one' => ['id'=>1,'first'=>'Jonh','last'=>'Doe','eeeemail'=>'jonh.doe@email'],
'two' => ['id'=>2,'first'=>'Mary','last'=>'Loe','email'=>'mary.loe@email'],
'three' => ['id'=>3,'first'=>'Marilyn','last'=>'Moe','email'=>'marilyn.moe@email'],];
$yc = array_column($y,'email','id');
print_r($yc);
// [0000] => jonh.doe@email
// [1000] => mary.loe@email
// [2000] => marilyn.moe@email
// [2] => mary.loe@email
// [3] => marilyn.moe@email
ARRAY_MERGE – O array_merge é bastante controverso e as vezes não produz o resultado que você está querendo, mas ele funciona conforme foi projetado e as regras são bem claras.
O array_merge usa um array como base e um outro array adicional para ser mergido no array base. Caso um índice associativo no array adicional exista no array base o valor do array adicional será sobrescrito no array base. Caso o índice associativo no array adicional não exista no array base ele será adicionado no array base. Todos os índices numéricos no array adicional serão adicionados no array base com resequenciamento automático, ou seja, não importa se o índice numérico exista ou não no array base, ele será inserido independentemente de qualquer condição.
$ybase = ['fruit'=>'apple','drink'=>'water','snack'=>'chips',0=>'juice',1=>'banana'];
$yadd = ['fruit'=>'naranja','drink'=>'leche',0=>'manzana',1=>'pera'];
$yg = array_merge($ybase, $yadd);
print_r($yg);
// [fruit] => naranja
// [drink] => leche
// [snack] => chips
// [0] => juice
// [1] => banana
// [2] => manzana
// [3] => pera
ARRAY MERGE + SUGAR SYNTAX – Uma outra forma de você fazer um merge de arrays é utilizando o operador plus (+). Só que o comportamento desta sintaxe é um pouco diferente da função array_merge.
Considere o array base e o array adicional, com a sugar syntax os índices do array adicional que não existirem no array base serão adicionados no array base, e ponto final. Assim se o objetivo é simplesmente adicionar elementos omissos no array base a sugar syntax provê um resultado melhor.
$ybase = ['fruit'=>'apple','drink'=>'water','snack'=>'chips',0=>'juice',1=>'banana'];
$yadd = ['fruit'=>'naranja','drink'=>'leche',0=>'manzana',1=>'pera',3=>'frambuesa'];
$ysg = $ybase + $yadd;
print_r($ysg);
// [fruit] => apple
// [drink] => water
// [snack] => chips
// [0] => juice
// [1] => banana
// [3] => raspberry
ARRAY_REPLACE – Ao invés de array_merge ou merge sugar syntax considere utilizar array_replace para fazer o merge de arrays. Acontece que o array_replace no final das contas produz o resultado mais esperado na maioria das situações.
O array_replace faz o match entre array base e array adicional para qualquer tipo de índice, associativo e numérico. Os índices que fazem match serão sobrescritos na array base e os índices omissos serão adicionados no array base.
Simples, prático e objetivo!
$ybase = ['fruit'=>'apple','drink'=>'water','snack'=>'chips',0=>'juice',1=>'banana'];
$yadd = ['fruit'=>'naranja','drink'=>'leche',0=>'manzana',1=>'pera',3=>'frambuesa'];
$yr = array_replace($ybase, $yadd);
print_r($yr);
// [fruit] => naranja
// [drink] => leche
// [snack] => chips
// [0] => manzana
// [1] => pera
// [3] => frambuesa
Resumindo, as funções array prontas funcionam como uma caixa de ferramentas, se você não sabe como aplicá-las corretamente acabará usando somente o martelo e a talhadeira! Ou em último caso, só a MARRETA mesmo…