Une fois toutes les affectations soumises, un dictionnaire est créé qui associe le numéro d'élève au hachage de leur fichier.

Ce dictionnaire, ou hashmap, ou mappage (quel que soit votre langage) se présentera comme suit:

{100: "aabb", 104: "43a", 52: "00ab", 430: "aabb", 332: "43a"}

La clé est le numéro d'étudiant et la valeur est le hachage.

Notre tâche est de choisir les tricheurs! Les tricheurs sont ceux qui ont des hachages identiques.

Compte tenu de l'entrée {100: "aabb", 104: "43a", 52: "00ab", 430: "aabb", 332: "43a"}, la fonction doit retourner (ou imprimer) le texte suivant:

100 has identical files to 430

104 has identical files to 332

Notez que les fichiers dont les hachages sont uniques ne sont pas mentionnés.

De plus, la commande est importante ici :

{100: "aabb", 202: "aabb", 303: "ab", 404: "aabb"} doit retourner (imprimer) le texte suivant:

100 has identical files to 202,404

Il est incorrect d'imprimer l'un des éléments suivants:

202 has identical files to 100,404

100 has identical files to 404, 202

Vous devez l'imprimer en fonction de la façon dont il apparaît dans le dictionnaire. Dans certaines langues, parcourir un dictionnaire est aléatoire, donc dans ce cas particulier, vous êtes autorisé à changer la méthode de saisie de manière à pouvoir le parcourir de manière ordonnée.

Plus d'exemples:

{} # prints nothing

{100: "ab", 303: "cd"} # prints nothing again

{100: "ab", 303: "cd", 404: "ab"}

100 has identical files to 404

{303: "abc", 304: "dd", 305: "abc", 405: "dd", 606: "abc"}

303 has identical files to 305,606

304 has identical files to 405

Le code le plus court gagne!

JavaScript (nœud Babel) , 113 octets

Prend l'entrée comme un tableau de tableaux au [key, value]format. Go go gadget double flatMap!

o=>o.flatMap(([x,h],i)=>(a=o.flatMap(([y,H],j)=>j>i&H==h?(o[j]=[,j],[y]):[]))+a?x+' has identical files to '+a:a)

Essayez-le en ligne!

JavaScript (nœud Babel) , 114 octets

Prend l'entrée en tant qu'objet JS natif.

o=>Object.keys(o).flatMap((x,i,a)=>(a=a.filter(y=>i--<0&o[y]==o[x]&&(o[y]=y)))+a?x+' has identical files to '+a:a)

Essayez-le en ligne!

Python 2 , 127 126 octets

def f(x):
 for l in{`[K for K,V in x if v==V]`[1:-1]for k,v in x}:
	if','in l:print l.replace(',',' has identical files to',1)

Essayez-le en ligne!

Prend une liste de paires ordonnées (<studentNumber>,<hash>)en entrée.

Retina 0.8.2 , 71 octets

+m`((:.+)$(¶|.)+?)^(.+)\2$
,$4$1
:.*

G`,
%1`,
 has identical files to 

Essayez-le en ligne! Prend des informations sur des lignes distinctes mais le lien inclut une suite de tests qui divise les exemples pour vous. Explication:

+

Répétez cette correspondance jusqu'à ce qu'aucun autre remplacement ne puisse être effectué.

m`((:.+)$(¶|.)+?)^(.+)\2$
,$4$1

Recherchez des paires de hachages correspondants et ajoutez la clé de la deuxième correspondance à celle de la première correspondance avec un séparateur de virgules.

:.*

Supprimez tous les hachages.

G`,

Ne gardez que les lignes avec des virgules.

%1`,
 has identical files to 

Remplacez la première virgule sur chaque ligne par le texte souhaité (y compris l'espace de fin).

R , 145 132 129 126 124 octets

function(m,`!`=names)for(e in !(t=table(m))[t>1])cat(el(n<-!m[m==e]),'has identical files to',paste(n[-1],collapse=','),'
')

Essayez-le en ligne!

Il prend un vecteur nommé en entrée (les noms sont les clés)

• -2 octets grâce à Giuseppe

Si le ", "séparateur (avec un espace après la virgule) est autorisé en cas de doublons multiples, nous pouvons utiliser ce code et économiser 10 octets:

R , 114 octets

function(m,`!`=names)for(e in !(t=table(m))[t>1])cat(el(n<-!m[m==e]),'has identical files to',toString(n[-1]),'
')

Essayez-le en ligne!

05AB1E , 34 octets

Σθ}.γθ}vyg1›iy€нć“ÿ€°Ê¼‡œ€„ “?',ý,

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

Σθ}                   # Sort the (implicit) input by the string
.γθ}                  # Then group it by the string
v                     # Loop `y` over each grouped inner list
 yg1›i                #  If the group contains more than 1 key-value pairs:
      y€н             #   Only leave the keys
      ć               #   Pop and push the head and rest of the list separately
                      #   (with the head being at the top of the stack now)
       “ÿ€°Ê¼‡œ€„ “   #   Compressed string "ÿ has identical files to "
                      #   where the "ÿ" is automatically replaced with the top of the stack
                   ?  #   Print it (without trailing newline)
       ',ý           '#   Join the remaining numbers by a comma
          ,           #   And output it as well (with trailing newline)

Voir cette réponse 05AB1E de mes (section Comment utiliser le dictionnaire? ) Pour comprendre pourquoi “ÿ€°Ê¼‡œ€„ “est "ÿ has identical files to ".

Rubis , 98 96 octets

->h{h.group_by{|k,v|v}.map{|k,v|x,*y=v.to_h.keys;p"#{x} has identical files to #{y*?,}"if y[0]}}

Essayez-le en ligne!

Prend l'entrée comme Ruby Hash, retourne par impression.

Gelée , 39 octets

Ṫ€ĠḊƇṢịẎµḢ;“]⁶ḅhṬyU⁹æṇL[Oþ⁹cƘƓ»,ṾK)j⁾¶¶

Essayez-le en ligne!

C # (Visual C # Interactive Compiler) , 130 octets

a=>a.GroupBy(x=>x.Value,x=>x.Key).Where(x=>x.Count()>1).Select(x=>x.First()+" has identical files to "+String.Join(",",x.Skip(1)))

Essayez-le en ligne!

La chose étrange à propos de cette question est que les exemples sont donnés au format JSON sous forme de paires clé / valeur, ce qui implique généralement qu'ils ne sont pas ordonnés ... Dans ce cas cependant, l'ordre est important. En tant que tel, j'utilise une liste de tuples pour l'entrée et une liste de chaînes comme sortie.

// a is a list of tuples
// (student #, hash)
a=>a
  // group by hash
  // grouped items are the student #'s
  .GroupBy(x=>x.Value,x=>x.Key)
  // remove single student groups
  .Where(x=>x.Count()>1)
  // format the output strings
  .Select(x=>x.First()+
    " has identical files to "+
    String.Join(",",x.Skip(1)))

Perl 5, 100 +1 (-n) octets

for$x(/[a-z]+/g){($t,@a)=${h{$x}}++?():/\d+(?= $x)/g;@a&&say"$t has identical files to ",join",",@a}

Essayez-le en ligne!

Japt , 34 octets

üÌl>1 ®mgîÎ+` •s ÅÁÈól fÅC ‘ `+ZÅ

Essayez-le en ligne!

En ce moment, c'est un peu incohérent dans l'ordre des lignes, mais au sein d'une ligne, il sort correctement. Si les lignes de la sortie doivent être dans un ordre spécifique, cela prendra quelques octets supplémentaires. L'entrée n'est qu'un tableau de [id, hash]paires

Explication:

üÌ                                    :Group by hash
  l>1                                 :Remove the ones that are unique
      ®mgà                            :Get just the Ids
          ®                           :Generate a string for each hash:
           Î                          : The first Id with that hash
            +` •s ÅÁÈól fÅC ‘ `       : Plus " has identical files to " compressed
                               +ZÅ    : Plus the remaining Ids
                                      : Implicitly comma delimited

Perl 6 , 115 110 103 octets

-2 octets grâce à Jo King

{unique map {.[0]~" has identical files to "~join ',',.skip},grep *>1,.map:{.grep(*{*}eq$^p{*})>>.key}}

Essayez-le en ligne!

Prend une liste de paires car les hachages ne sont pas ordonnés. Une liste de listes à deux éléments permettrait d'économiser quelques octets, mais semble unidiomatique. Renvoie une liste de lignes.

95 88 octets si l'ordre des lignes dans le résultat n'a pas d'importance:

*.classify(*{*}){*}>>.key.grep(*>1).map:{.[0]~" has identical files to "~join ',',.skip}

Essayez-le en ligne!