Nachdem alle Aufgaben eingereicht wurden, wird ein Wörterbuch erstellt, das die Schülernummer dem Hash ihrer Datei zuordnet.

Dieses Wörterbuch, diese Hashmap oder dieses Mapping (wie auch immer Ihre Sprache es nennt) sieht folgendermaßen aus:

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

Der Schlüssel ist die Schülernummer und der Wert ist der Hash.

Unsere Aufgabe ist es, die Betrüger auszusuchen! Die Betrüger sind diejenigen, die identische Hashes haben.

Bei gegebener Eingabe {100: "aabb", 104: "43a", 52: "00ab", 430: "aabb", 332: "43a"}sollte die Funktion den folgenden Text zurückgeben (oder drucken):

100 has identical files to 430

104 has identical files to 332

Beachten Sie, dass die Dateien, in denen die Hashes eindeutig sind, nicht erwähnt werden.

Auch hier ist die Reihenfolge wichtig :

{100: "aabb", 202: "aabb", 303: "ab", 404: "aabb"} sollte den folgenden Text zurückgeben (drucken):

100 has identical files to 202,404

Es ist falsch , eines der folgenden Elemente zu drucken:

202 has identical files to 100,404

100 has identical files to 404, 202

Sie sollten es so drucken, wie es im Wörterbuch angezeigt wird. In einigen Sprachen ist das Durchsuchen eines Wörterbuchs zufällig. In diesem speziellen Fall können Sie die Eingabemethode so ändern, dass Sie es ordnungsgemäß durchgehen können.

Mehr Beispiele:

{} # 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

Der kürzeste Code gewinnt!

JavaScript (Babel-Knoten) , 113 Byte

Nimmt die Eingabe als Array von Arrays im [key, value]Format auf. 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)

Probieren Sie es online aus!

JavaScript (Babel-Knoten) , 114 Byte

Übernimmt die Eingabe als natives JS-Objekt.

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)

Probieren Sie es online aus!

Python 2 , 127 126 Bytes

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)

Probieren Sie es online aus!

Nimmt eine Liste der geordneten Paare (<studentNumber>,<hash>)als Eingabe.

Retina 0,8,2 , 71 Bytes

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

G`,
%1`,
 has identical files to 

Probieren Sie es online aus! Nimmt Eingaben in separaten Zeilen vor, aber der Link enthält eine Testsuite, die die Beispiele für Sie aufteilt. Erläuterung:

+

Wiederholen Sie diese Übereinstimmung, bis keine Ersetzungen mehr vorgenommen werden können.

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

Suchen Sie nach Paaren übereinstimmender Hashes und hängen Sie den Schlüssel der zweiten Übereinstimmung mit einem Komma-Trennzeichen an den Schlüssel der ersten Übereinstimmung an.

:.*

Löschen Sie alle Hashes.

G`,

Behalten Sie nur die Zeilen mit Kommas bei.

%1`,
 has identical files to 

Ersetzen Sie das erste Komma in jeder Zeile durch den gewünschten Text (einschließlich Leerzeichen).

R , 145 132 129 126 124 Bytes

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=','),'
')

Probieren Sie es online aus!

Es wird ein benannter Vektor als Eingabe verwendet (Namen sind die Schlüssel).

• -2 Bytes dank Giuseppe

Wenn ", "bei mehreren Duplikaten ein Trennzeichen (mit einem Leerzeichen nach dem Komma) zulässig ist, können wir diesen Code verwenden und 10 Byte speichern:

R , 114 Bytes

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

Probieren Sie es online aus!

05AB1E , 34 Bytes

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

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

Σθ}                   # 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)

Sehen Sie diese 05AB1E Antwort von mir (Abschnitt Wie das Wörterbuch benutzen? ) Zu verstehen , warum “ÿ€°Ê¼‡œ€„ “ist "ÿ has identical files to ".

Ruby , 98 96 Bytes

->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]}}

Probieren Sie es online aus!

Übernimmt die Eingabe als Ruby Hash und kehrt durch Drucken zurück.

Gelee , 39 Bytes

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

Probieren Sie es online aus!

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

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)))

Probieren Sie es online aus!

Das Seltsame an dieser Frage ist, dass die Beispiele in einem JSON-Format als Schlüssel / Wert-Paare angegeben werden, was normalerweise impliziert, dass sie ungeordnet sind ... In diesem Fall ist jedoch die Reihenfolge wichtig. Als solches verwende ich eine Liste von Tupeln für die Eingabe und eine Liste von Zeichenfolgen als Ausgabe.

// 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) Bytes

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

Probieren Sie es online aus!

Japt , 34 Bytes

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

Probieren Sie es online aus!

Im Moment ist die Reihenfolge der Zeilen etwas inkonsistent, aber innerhalb einer Zeile wird sie korrekt ausgegeben. Wenn die Zeilen der Ausgabe in einer bestimmten Reihenfolge sein müssen, werden einige weitere Bytes benötigt. Die Eingabe ist nur ein Array von [id, hash]Paaren

Erläuterung:

üÌ                                    :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 Bytes

-2 Bytes dank Jo King

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

Probieren Sie es online aus!

Nimmt eine Liste von Paaren auf, da Hashes ungeordnet sind. Eine Liste mit Listen mit zwei Elementen würde einige Bytes sparen, scheint jedoch unidiomatisch. Gibt eine Liste von Zeilen zurück.

95 88 Bytes, wenn die Reihenfolge der Zeilen im Ergebnis keine Rolle spielt:

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

Probieren Sie es online aus!