Depois que todas as tarefas são enviadas, é criado um dicionário que mapeia o número do aluno para o hash do arquivo.

Esse dicionário, mapa de hash ou mapeamento (seja qual for o idioma), terá a seguinte aparência:

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

A chave é o número do aluno e o valor é o hash.

Nossa tarefa é escolher os trapaceiros! Os trapaceiros são os que têm hashes idênticos.

Dada a entrada {100: "aabb", 104: "43a", 52: "00ab", 430: "aabb", 332: "43a"}, a função deve retornar (ou imprimir) o seguinte texto:

100 has identical files to 430

104 has identical files to 332

Observe como os arquivos onde os hashes são exclusivos não são mencionados.

Além disso, a ordem é importante aqui :

{100: "aabb", 202: "aabb", 303: "ab", 404: "aabb"} deve retornar (imprimir) o seguinte texto:

100 has identical files to 202,404

É incorreto imprimir um dos seguintes:

202 has identical files to 100,404

100 has identical files to 404, 202

Você deve imprimi-lo em termos de como ele aparece no dicionário. Em alguns idiomas, passar por um dicionário é aleatório; portanto, nesse caso especial, você pode alterar o método de entrada, de modo que possa passar por ele de maneira ordenada.

Mais exemplos:

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

O menor código vence!

JavaScript (Nó Babel) , 113 bytes

Recebe a entrada como uma matriz de matrizes em [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)

Experimente online!

JavaScript (Nó Babel) , 114 bytes

Recebe entrada como um 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)

Experimente online!

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)

Experimente online!

Leva uma lista de pares ordenados (<studentNumber>,<hash>)como entrada.

Retina 0.8.2 , 71 bytes

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

G`,
%1`,
 has identical files to 

Experimente online! Recebe entrada em linhas separadas, mas o link inclui um conjunto de testes que divide os exemplos para você. Explicação:

+

Repita esta partida até que não seja possível fazer mais substituições.

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

Procure pares de hashes correspondentes e anexe a chave da segunda correspondência à da primeira correspondência com um separador de vírgula.

:.*

Exclua todos os hashes.

G`,

Mantenha apenas as linhas com vírgulas.

%1`,
 has identical files to 

Substitua a primeira vírgula em cada linha pelo texto desejado (incluindo o espaço à direita).

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

Experimente online!

É necessário um vetor nomeado como entrada (os nomes são as chaves)

• -2 bytes graças a Giuseppe

Se o ", "separador (com um espaço após a vírgula) for permitido no caso de várias duplicatas, podemos usar este código e salvar 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]),'
')

Experimente online!

05AB1E , 34 bytes

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

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Veja esta resposta 05AB1E meu (seção Como usar o dicionário? ) Para entender por que “ÿ€°Ê¼‡œ€„ “é "ÿ 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]}}

Experimente online!

Recebe a entrada como Ruby Hash, retorna pela impressão.

Geléia , 39 bytes

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

Experimente online!

C # (compilador interativo do 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)))

Experimente online!

O estranho dessa pergunta é que os exemplos são dados no formato JSON como pares de chave / valor, o que geralmente implica que eles não são ordenados ... Nesse caso, no entanto, a ordem é importante. Como tal, estou usando uma lista de tuplas para entrada e uma lista de seqüências de caracteres como saída.

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

Experimente online!

Japonês , 34 bytes

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

Experimente online!

No momento, é um pouco inconsistente na ordem das linhas, mas dentro de uma linha ela sai corretamente. Se as linhas da saída precisarem estar em uma ordem específica, serão necessários mais alguns bytes. A entrada é apenas uma matriz de [id, hash]pares

Explicação:

üÌ                                    :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 graças a Jo King

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

Experimente online!

Faz uma lista de pares, pois os hashes não são ordenados. Uma lista de listas de dois elementos salvaria alguns bytes, mas parece unidiomatic. Retorna uma lista de linhas.

95 88 bytes se a ordem das linhas no resultado não importar:

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

Experimente online!