Después de enviar todas las tareas, se crea un diccionario que asigna el número de estudiante al hash de su archivo.

Este diccionario, o hashmap, o mapeo (como lo llame su idioma) se verá de la siguiente manera:

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

La clave es el número de estudiante y el valor es el hash.

¡Nuestra tarea es elegir a los tramposos! Los tramposos son los que tienen hashes idénticos.

Dada la entrada {100: "aabb", 104: "43a", 52: "00ab", 430: "aabb", 332: "43a"}, la función debería devolver (o imprimir) el siguiente texto:

100 has identical files to 430

104 has identical files to 332

Observe cómo no se mencionan los archivos donde los hashes son únicos.

Además, el orden es importante aquí :

{100: "aabb", 202: "aabb", 303: "ab", 404: "aabb"} debe devolver (imprimir) el siguiente texto:

100 has identical files to 202,404

Es incorrecto imprimir cualquiera de los siguientes:

202 has identical files to 100,404

100 has identical files to 404, 202

Debe imprimirlo en términos de cómo aparece en el diccionario. En algunos idiomas, pasar por un diccionario es aleatorio, por lo que en este caso especial, se le permite cambiar el método de entrada de modo que pueda pasarlo de manera ordenada.

Más ejemplos:

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

¡El código más corto gana!

JavaScript (nodo de Babel) , 113 bytes

Toma la entrada como una matriz de matrices en [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)

Pruébalo en línea!

JavaScript (nodo de Babel) , 114 bytes

Toma entrada como un objeto 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)

Pruébalo en línea!

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)

Pruébalo en línea!

Toma una lista de pares ordenados (<studentNumber>,<hash>)como entrada.

Retina 0.8.2 , 71 bytes

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

G`,
%1`,
 has identical files to 

Pruébalo en línea! Toma datos en líneas separadas pero el enlace incluye un conjunto de pruebas que divide los ejemplos por usted. Explicación:

+

Repita este partido hasta que no se puedan hacer más reemplazos.

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

Busque pares de hashes coincidentes y agregue la clave de la segunda coincidencia a la de la primera coincidencia con un separador de coma.

:.*

Eliminar todos los hashes.

G`,

Mantenga solo las líneas con comas.

%1`,
 has identical files to 

Reemplace la primera coma en cada línea con el texto deseado (incluido el espacio final).

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

Pruébalo en línea!

Toma un vector con nombre como entrada (los nombres son las claves)

• -2 bytes gracias a Giuseppe

Si ", "se permite el separador (con un espacio después de la coma) en caso de múltiples duplicados, podemos usar este código y guardar 10 bytes:

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

Pruébalo en línea!

05AB1E , 34 bytes

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

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Ver esta respuesta 05AB1E mío (sección Cómo usar el diccionario? ) Para entender por qué “ÿ€°Ê¼‡œ€„ “es "ÿ 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]}}

Pruébalo en línea!

Toma datos como Ruby Hash, regresa imprimiendo.

Jalea , 39 bytes

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

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 130 bytes

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

Pruébalo en línea!

Lo extraño de esta pregunta es que los ejemplos se dan en formato JSON como pares clave / valor, lo que generalmente implica que no están ordenados ... En este caso, sin embargo, el orden es importante. Como tal, estoy usando una lista de tuplas para entrada y una lista de cadenas como salida.

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

Pruébalo en línea!

Japt , 34 bytes

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

Pruébalo en línea!

En este momento es un poco inconsistente en el orden de las líneas, pero dentro de una línea sale correctamente. Si las líneas de la salida necesitan estar en un orden específico, tomará unos pocos bytes más. La entrada es solo un conjunto de [id, hash]pares

Explicación:

üÌ                                    :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 gracias a Jo King

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

Pruébalo en línea!

Toma una lista de pares ya que los hashes no están ordenados. Una lista de listas de dos elementos ahorraría unos pocos bytes pero parece unidiomática. Devuelve una lista de líneas.

95 88 bytes si el orden de las líneas en el resultado no importa:

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

Pruébalo en línea!