Avril 21, 2018 Mai 17, 2018 8 minutes de lecture

Warm-up Challenges Sock Merchant

Je publie mes solutions aux défis HackerRank afin d'améliorer mon apprentissage, de renforcer mes connaissances et d'établir une compréhension des concepts abordés. Si j'aide quelqu'un en partageant en cours de route, c'est encore mieux!

Sock Merchant est l'un des défis initiaux avec une difficulté 'EASY'.

Quel est le défi?

John travaille dans un magasin de vêtements. Il a un gros tas de chaussettes qu'il doit trier par couleur pour les vendre. Étant donné une matrice d'entiers représentant la couleur de chaque chaussette, détermine combien de paires de chaussettes avec les couleurs correspondantes existent.

Par exemple, il existe n = 7 chaussettes de couleurs ar = 1, 2, 1, 2, 1, 3, 2. Il y a une paire de couleur 1 et une paire de couleur 2. Il y a trois chaussettes impairs, une de chaque couleur. Le nombre de paires est de 2.

Que devons-nous faire?

Une fonction qui doit renvoyer un entier représentant le nombre de paires de chaussettes correspondantes disponibles.

Paramètres

• n = le nombre de chaussettes dans la pile

• ar = les couleurs de chaque chaussette dans une matrice

Sample Input

9
10 20 20 10 10 30 50 10 20

Sample Output

3

Solution

function sockMerchant(n, ar) {

	let socks = {},
		count = 0,
		i = 0;

	for (i = 0; i < n; i++) {
		if (ar[i] in socks) {
			socks[ar[i]] += 1;
		} else {
			socks[ar[i]] = 1;
		}
	}

	Object.keys(socks).map(el => {
		count += ~~(socks[el] / 2);
	})

	return count;
}

Logique

let socks = {},
	count = 0,
	i = 0;

J'ai d'abord créé trois variables; socks est un objet qui enregistre le nombre de chaque type de chaussette; count pour compter le nombre de paires de chaussettes; i pour itérer lo forloop;

for loop

J'ai créé une boucle for qui parcourra la matrice de couleurs de la chaussette. Il itérera n fois, ce qui correspond à la quantité donnée de chaussettes sur la pile. for (var i = 0; i < n; i++)

La condition if vérifie si la couleur existe dans notre objet socks: if (ar[i] in socks)
S'il existe, incrémentez le décompte de cette couleur d'une unité: socks[ar[i]] += 1;
Sinon, créez une clé avec cette couleur et réglez-la sur 1. socks[ar[i]] = 1;

Une fois les chaussettes comptées, exécutez une map sur l'objet socks, ainsi un élément sera séparé pour chaque clé: Object.keys(socks).map(el => {

Ensuite je calcule le nombre de paires en divisant le nombre de "chaussettes" d'une même couleur socks[el] / 2 puis appliquez la réponse, deux tildes (bitwise NOT).

J'ai utilisé le bitwise NOT en remplacement de la Math.floor(), car il effectue la même opération beaucoup plus vite , comme vous pouvez vous vérifier et https://jsperf.com/jsfvsbitnot

Enfin, je termine la fonction en renvoyant le compte final.

Solutions Supplémentaires

Autres langues que je parle

Ruby

def sockMerchant(n, ar)
	socks = Hash.new { | hash, key | Hash[key] = 0 }
	count = 0

	ar.each { | color | socks[color] += 1 }
	socks.each_value { | el | count += (el / 2) }

	count
end

PYTHON 2 & 3

def sockMerchant(n, ar):
	socks = collections.Counter(ar)
	count = 0

	for el in socks:
		count += socks[el] // 2
			
	return count

GOLANG

func sockMerchant(n int32, ar []int32) int32 {
	var count, i int32

	socks := make(map[int32]int32)
	for i = 0; i < n; i++ {
		socks[ar[i]]++
	}
	for _, el := range socks {
		count += (el / 2)
	}
	return count
}

SCALA

def sockMerchant(n: Int, ar: Array[Int]): Int = {
	val socks = ar.groupBy(c => c)
	val pairs = socks.map(el => el._2.length / 2)
	val count = pairs.sum
	return count;
}

JAVA 7 & 8

static int sockMerchant(int n, int[] ar) {
	HashSet<Integer> socks = new HashSet<Integer>();
	int count = 0;
					
	for (Integer i:ar) {
		if (socks.contains(i))
			socks.remove(i);
			count++;
		else
			socks.add(i);
	}
	return count;
}

PHP

function sockMerchant($n, $ar) {
	$socks = array_count_values($ar);
	$count = 0;

	foreach ($socks as $el) {
		$count += intdiv($el, 2);
	}
	return $count;
}

Pensée: Généralement, les gens qui savent peu parlent beaucoup, et les gens qui savent beaucoup parlent peu