Dopo aver inviato tutti i compiti, viene creato un dizionario che associa il numero dello studente all'hash del loro file.

Questo dizionario, o hashmap o mappatura (come la tua lingua lo chiama) apparirà come segue:

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

La chiave è il numero dello studente e il valore è l'hash.

Il nostro compito è quello di scegliere gli imbroglioni! Gli imbroglioni sono quelli che hanno hash identici.

Dato l'input {100: "aabb", 104: "43a", 52: "00ab", 430: "aabb", 332: "43a"}, la funzione dovrebbe restituire (o stampare) il seguente testo:

100 has identical files to 430

104 has identical files to 332

Notare come i file in cui gli hash sono univoci non vengono menzionati.

Inoltre, l'ordine è importante qui :

{100: "aabb", 202: "aabb", 303: "ab", 404: "aabb"} dovrebbe restituire (stampare) il seguente testo:

100 has identical files to 202,404

È errato stampare uno dei seguenti:

202 has identical files to 100,404

100 has identical files to 404, 202

Dovresti stamparlo in termini di come appare nel dizionario. In alcune lingue, passare attraverso un dizionario è casuale, quindi in questo caso speciale, è possibile modificare il metodo di input in modo da poterlo seguire in modo ordinato.

Altri esempi:

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

Il codice più corto vince!

JavaScript (Babel Node) , 113 byte

Accetta l'input come una matrice di array in [key, value]formato. 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)

Provalo online!

JavaScript (nodo Babele) , 114 byte

Accetta input come oggetto JS nativo.

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)

Provalo online!

Python 2 , 127 126 byte

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)

Provalo online!

Prende un elenco di coppie ordinate (<studentNumber>,<hash>)come input.

Retina 0.8.2 , 71 byte

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

G`,
%1`,
 has identical files to 

Provalo online! Accetta input su righe separate ma il link include una suite di test che divide gli esempi per te. Spiegazione:

+

Ripeti questa partita fino a quando non sarà più possibile effettuare sostituzioni.

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

Cerca coppie di hash corrispondenti e aggiungi la chiave della seconda corrispondenza a quella della prima corrispondenza con un separatore di virgola.

:.*

Elimina tutti gli hash.

G`,

Mantieni solo le linee con virgole.

%1`,
 has identical files to 

Sostituisci la prima virgola su ogni riga con il testo desiderato (incluso lo spazio finale).

R , 145 132 129 126 124 byte

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

Provalo online!

Prende un vettore con nome come input (i nomi sono le chiavi)

• -2 byte grazie a Giuseppe

Se il ", "separatore (con uno spazio dopo la virgola) è consentito in caso di più duplicati, possiamo usare questo codice e salvare 10 byte:

R , 114 byte

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

Provalo online!

05AB1E , 34 byte

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

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedere questa risposta 05AB1E mio (sezione Come utilizzare il dizionario? ) Per capire il motivo per cui “ÿ€°Ê¼‡œ€„ “è "ÿ has identical files to ".

Rubino , 98 96 byte

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

Provalo online!

Accetta input come Ruby Hash, ritorna stampando.

Gelatina , 39 byte

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

Provalo online!

C # (compilatore interattivo Visual C #) , 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)))

Provalo online!

La cosa strana di questa domanda è che gli esempi sono dati in un formato JSON come coppie chiave / valore che di solito implicano che non sono ordinati ... In questo caso, tuttavia, l'ordine è importante. Come tale, sto usando un elenco di tuple per l'input e un elenco di stringhe come output.

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

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

Provalo online!

Japt , 34 byte

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

Provalo online!

In questo momento è un po 'incoerente nell'ordinamento delle linee, ma all'interno di una linea viene emesso correttamente. Se le righe dell'output devono essere in un ordine specifico, saranno necessari alcuni byte in più. L'input è solo una matrice di [id, hash]coppie

Spiegazione:

üÌ                                    :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 103 byte

-2 byte grazie a Jo King

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

Provalo online!

Prende un elenco di coppie poiché gli hash non sono ordinati. Un elenco di elenchi a due elementi salverebbe alcuni byte ma sembra unidiomatico. Restituisce un elenco di righe.

95 88 byte se l'ordine delle righe nel risultato non ha importanza:

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

Provalo online!