Considere que você possui uma função de hash $\mathcal{H}$ que pega cadeias de comprimento $2n$ e retorna cadeias de comprimento $n$ e tem a propriedade agradável de que é resistente a colisões , ou seja, é difícil encontrar duas cadeias diferentes $s \neq s'$ com o mesmo hash $\mathcal{H}(s) = \mathcal{H}(s')$ .

Agora você deseja criar uma nova função de hash $\mathcal{H'}$ que pega cadeias de comprimento arbitrário e as mapeia para cadeias de comprimento $n$ , enquanto ainda é resistente a colisões.

Para sua sorte, já em 1979 foi publicado um método agora conhecido como a construção Merkle – Damgård que alcança exatamente isso.

A tarefa desse desafio será implementar esse algoritmo; portanto, primeiro examinaremos uma descrição formal da construção de Merkle – Damgård, antes de seguir um exemplo passo a passo que deve mostrar que a abordagem é mais simples do que pode aparecer a princípio.

Dado um número inteiro $n > 0$ , uma função de hash $\mathcal{H}$ conforme descrito acima e uma sequência de entrada $s$ de comprimento arbitrário, a nova função de hash $\mathcal{H'}$ faz o seguinte:

• Defina $l = |s|$, o comprimento de $s$ e divida $s$ em pedaços de comprimento $n$ , preenchendo o último pedaço com zeros à direita, se necessário. Isso produz $m = \lceil \frac{l}{n} \rceil$muitos pedaços rotulados como$c_1, c_2, \dots, c_m$.
• Adicione um pedaço inicial e final $c_0$ e $c_{m+1}$ , em que $c_0$ é uma string que consiste em $n$ zeros $c_{m+1}$ é $n$ em binário, preenchido com zeros à esquerda no comprimento $n$ .
• Agora, iterativamente, aplique $\mathcal{H}$ ao bloco atual $c_i$ anexado ao resultado anterior $r_{i-1}$ : $r_i = \mathcal{H}(r_{i-1}c_i)$ , em que $r_0 = c_0$ . (Esta etapa pode ficar mais clara depois de analisar o exemplo abaixo.)
• A saída de $\mathcal{H'}$ é o resultado final $r_{m+1}$ .

A tarefa

Escreva um programa ou função que tenha como entrada um número inteiro positivo $n$ , uma função de hash $\mathcal{H}$ como caixa preta e uma string não vazia $s$ e retorne o mesmo resultado que $\mathcal{H'}$ nas mesmas entradas.

Isso é código-golfe , então a resposta mais curta em cada idioma vence.

Exemplo

Digamos $n = 5$ , então nossa função hash dada $\mathcal{H}$ pega cadeias de comprimento 10 e retorna cadeias de comprimento 5.

• Dada a entrada de $s = \texttt{"Programming Puzzles"}$ , obtemos os seguintes blocos: $s_1 = \texttt{"Progr"}$ , $s_2 = \texttt{"ammin"}$ , $s_3 = \texttt{"g Puz"}$ e $s_4 = \texttt{"zles0"}$ . Observe que $s_4$ precisava ser preenchido com o comprimento 5 com um zero à direita.
• $c_0 = \texttt{"00000"}$ é apenas uma sequência de cinco zeros$c_5 = \texttt{"00101"}$ é cinco em binário ($\texttt{101}$ ), preenchido com dois zeros à esquerda.
• Agora os pedaços são combinados com $\mathcal{H}$ :
  $r_0 = c_0 = \texttt{"00000"}$
  $r_1 = \mathcal{H}(r_0c_1) = \mathcal{H}(\texttt{"00000Progr"})$
  $r_2 = \mathcal{H}(r_1c_2) = \mathcal{H}(\mathcal{H}(\texttt{"00000Progr"})\texttt{"ammin"})$ $r_3 = \mathcal{H}(r_2c_3) = \mathcal{H}(\mathcal{H}(\mathcal{H}(\texttt{"00000Progr"})\texttt{"ammin"})\texttt{"g Puz"})$
  $r_4 = \mathcal{H}(r_3c_4) = \mathcal{H}(\mathcal{H}(\mathcal{H}(\mathcal{H}(\texttt{"00000Progr"})\texttt{"ammin"})\texttt{"g Puz"})\texttt{"zles0"})$
  $r_5 = \mathcal{H}(r_4c_5) = \mathcal{H}(\mathcal{H}(\mathcal{H}(\mathcal{H}(\mathcal{H}(\texttt{"00000Progr"})\texttt{"ammin"})\texttt{"g Puz"})\texttt{"zles0"})\texttt{"00101"})$
• $r_5$ é a nossa saída.

Vamos dar uma olhada na aparência dessa saída, dependendo de algumas opções ¹ para $\mathcal{H}$ :

• Se $\mathcal{H}(\texttt{"0123456789"}) = \texttt{"13579"}$ , ou seja, $\mathcal{H}$ apenas retorna cada segundo caractere, obtemos:
  $r_1 = \mathcal{H}(\texttt{"00000Progr"}) = \texttt{"00Por"}$
  $r_2 = \mathcal{H}(\texttt{"00Porammin"}) = \texttt{"0oamn"}$
  $r_3 = \mathcal{H}(\texttt{"0oamng Puz"}) = \texttt{"omgPz"}$
  $r_4 = \mathcal{H}(\texttt{"omgPzzles0"}) = \texttt{"mPze0"}$
  $r_5 = \mathcal{H}(\texttt{"mPze000101"}) = \texttt{"Pe011"}$
  Portanto,$\texttt{"Pe011"}$ precisa ser a saída se esse$\mathcal{H}$ for fornecido como função de caixa preta.
• Se $\mathcal{H}$ simplesmente retornar os 5 primeiros caracteres de sua entrada, a saída de $\mathcal{H'}$ será $\texttt{"00000"}$ . Da mesma forma, se $\mathcal{H}$ retornar os últimos 5 caracteres, a saída será $\texttt{"00101"}$ .
• Se $\mathcal{H}$ multiplicar os códigos de caracteres de sua entrada e retornar os cinco primeiros dígitos desse número, por exemplo, $\mathcal{H}(\texttt{"PPCG123456"}) = \texttt{"56613"}$ , então $\mathcal{H}'(\texttt{"Programming Puzzles"}) = \texttt{"91579"}$ .

^{1 Por simplicidade, os $\mathcal{H}$ não são realmente resistentes a colisões, embora isso não importe para testar sua submissão.}

Haskell , 91 90 86 bytes

• -1 byte graças a Laikoni
• -4 bytes graças ao xnor

n!h|let a='0'<$[1..n];c?""=c;c?z=h(c++take n(z++a))?drop n z=h.(++mapM(:"1")a!!n).(a?)

Experimente online!

Explicação

a='0'<$[1..n]

Apenas atribui a string "00...0"( '0' $n$ vezes) aa

c?""=c
c?z=h(c++take n(z++a))?drop n z

A função ?implementa a aplicação recursiva de h: cé o hash que obtivemos até agora (comprimento $n$ ), zé o restante da string. Se zestiver vazio, simplesmente retornamos c, caso contrário, pegamos os primeiros $n$ caracteres de z(possivelmente preenchendo com zeros de a), acrescentamos ce aplicamos h. Isso fornece o novo hash e, em seguida, chamamos ?recursivamente esse hash e os caracteres restantes de z.

n!h=h.(++mapM(:"1")a!!n).(a?)

A função ! é a que realmente resolve o desafio. É preciso n, he s(implícita) como entradas. Nós computamos a?s, e tudo o que precisamos fazer é anexar nem binário e aplicar hnovamente. mapM(:"1")a!!nretorna a representação binária de $n$ .

R , 159 154 bytes

function(n,H,s,`?`=paste0,`*`=strrep,`/`=Reduce,`+`=nchar,S=0*n?s?0*-(+s%%-n)?"?"/n%/%2^(n:1-1)%%2)(function(x,y)H(x?y))/substring(S,s<-seq(,+S,n),s--n-1)

Experimente online!

Que nojo! Responder a desafios de string em R nunca é bonito, mas isso é horrível. Esta é uma resposta instrutiva sobre como não escrever código R "normal" ...

Agradecimentos ao nwellnhof por corrigir um erro, a um custo de 0 bytes!

Agradecimentos a J.Doe por trocar o alias do operador para alterar a precedência, bom para -4 bytes.

A explicação abaixo é para a versão anterior do código, mas os princípios permanecem os mesmos.

function(n,H,s,               # harmless-looking function arguments with horrible default arguments 
                              # to prevent the use of {} and save two bytes
                              # then come the default arguments,
                              # replacing operators as aliases for commonly used functions:
 `+`=paste0,                  # paste0 with binary +
 `*`=strrep,                  # strrep for binary *
 `/`=Reduce,                  # Reduce with binary /
 `?`=nchar,                   # nchar with unary ?
 S=                           # final default argument S, the padded string:
  0*n+                        # rep 0 n times
  s+                          # the original string
  0*-((?s)%%-n)+              # 0 padding as a multiple of n
  "+"/n%/%2^(n:1-1)%%2)       # n as an n-bit number
                              # finally, the function body:
 (function(x,y)H(x+y)) /      # Reduce/Fold (/) by H operating on x + y
  substring(S,seq(1,?S,n),seq(n,?S,n))  # operating on the n-length substrings of S

C (gcc) , 251 bytes

#define P sprintf(R,
b(_){_=_>1?10*b(_/2)+_%2:_;}f(H,n,x)void(*H)(char*);char*x;{char R[2*n+1],c[n+1],*X=x;P"%0*d",n,0);while(strlen(x)>n){strncpy(c,x,n);x+=n;strcat(R,c);H(R);}P"%s%s%0*d",R,x,n-strlen(x),0);H(R);P"%s%0*d",R,n,b(n));H(R);strcpy(X,R);}

Experimente online!

Não é tão limpo quanto a solução do bash e é altamente improvável.

A função está fassumindo Hcomo uma função que substitui sua entrada de string pelo hash da string, ncomo na descrição, e xna string de entrada e no buffer de saída.

Descrição:

#define P sprintf(R,     // Replace P with sprintf(R, leading to unbalanced parenthesis
                         // This is replaced and expanded for the rest of the description
b(_){                    // Define b(x). It will return the integer binary expansion of _
                         // e.g. 5 -> 101 (still as integer)
  _=_>1?                 // If _ is greater than 1
    10*b(_/2)+_%2        // return 10*binary expansion of _/2 + last binary digit
    :_;}                 // otherwise just _
f(H,n,x)                 // Define f(H,n,x)
  void(*H)(char*);       // H is a function taking a string
  char*x; {              // x is a string
  char R[2*n+1],c[n+1],  // Declare R as a 2n-length string and c as a n-length string
  *X=x;                  // save x so we can overwrite it later
  sprintf(R,"%0*d",n,0); // print 'n' 0's into R
  while(strlen(x)>n){    // while x has at least n characters
    strncpy(c,x,n);x+=n; // 'move' the first n characters of x into c
    strcat(R,c);         // concatenate c and R
    H(R);}               // Hash R
  sprintf(R,"%s%s%0*d"   // set R to two strings concatenated followed by some zeroes
    R,x,                 // the two strings being R and (what's left of) x
    n-strlen(x),0);      // and n-len(x) zeroes
  H(R);                  // Hash R
  sprintf(R,"%s%*d",R,n, // append to R the decimal number, 0 padded to width n
    b(n));               // The binary expansion of n as a decimal number
  H(R);strcpy(X,R);}     // Hash R and copy it into where x used to be

Ruby , 78 bytes

->n,s,g{(([?0*n]*2*s).chop.scan(/.{#{n}}/)+["%0#{n}b"%n]).reduce{|s,x|g[s+x]}}

Experimente online!

Como funciona:

([?0*n]*2*s).chop    # Padding: add leading and trailing 
                     # zeros, then remove the last one
.scan(/.{#{n}}/)     # Split the string into chunks
                     # of length n
+["%0#{n}b"%n]       # Add the trailing block
.reduce{|s,x|g[s+x]} # Apply the hashing function
                     # repeatedly

Gelatina , 23 bytes

0Ṿ;s;BṾ€ṚWƲ}z”0ZU0¦;Ç¥/

Experimente online!

Aceita $\mathcal H$ na linha acima, $s$ como argumento à esquerda, e $n$ como argumento correto.

Bash , 127-ε bytes

Z=`printf %0*d $1` R=$Z
while IFS= read -rn$1 c;do R=$R$c$Z;R=`H<<<${R::2*$1}`;done
H< <(printf $R%0*d $1 `bc <<<"obase=2;$1"`)

Experimente online!

Isso funciona como um programa / função / script / snippet. H deve ser resolvido por um programa ou função que executará o hash. N é o argumento. Chamada de exemplo:

$ H() {
>   sed 's/.\(.\)/\1/g'
> }
$ ./wherever_you_put_the_script.sh 5 <<< "Programming Puzzles"  # if you add a shebang
Pe011

Descrição:

Z=`printf %0*d $1`

Isso cria uma sequência de $1zeros. Isso funciona chamando printf e solicitando que imprima um número inteiro preenchido com uma largura extra de argumento . Esse argumento extra que passamos é $1o argumento para o programa / função / script que armazena n.

R=$Z

Isso apenas copia Z, nossa cadeia zero, para R, nossa cadeia resultante, em preparação para o loop de hash.

while IFS= read -rn$1 c; do

Isso faz um loop na entrada de cada $1(n) caractere que carrega os caracteres lidos em c. Se a entrada terminar, c simplesmente ficará muito curto. A ropção garante que quaisquer caracteres especiais na entrada não sejam interpretados por bash. Esse é o -εtítulo - que rnão é estritamente necessário, mas faz com que a função corresponda com mais precisão à entrada.

R=$R$c$Z

Isso concatena os n caracteres lidos da entrada para R junto com os zeros para preenchimento (muitos zeros por enquanto).

R=`H<<<${R::2*$1}`;done

Isso usa uma string here como entrada para a função hash. O conteúdo${R::2*$1} é uma substituição de parâmetro do bash um tanto esotérica que lê: R, começando de 0, apenas 2n caracteres.

Aqui o loop termina e terminamos com:

H< <(printf $R%0*d $1 `bc <<<"obase=2;$1"`)

Aqui, o mesmo truque de seqüência de caracteres de formato é usado para preencher 0 o número. bcé usado para convertê-lo em binário, definindo a base de saída (obase) como 2. O resultado é passado para a função / programa de hash cuja saída não é capturada e, portanto, é mostrada ao usuário.

Pitão , 24 bytes

Como Pyth não permite que H seja usado para um nome de função, eu o uso y.

uy+GH+c.[E=`ZQQ.[ZQ.BQ*Z

Experimente online! Exemplo é com a versão "cada segundo caractere" de H.

Perl 6 , 79 68 bytes

{reduce &^h o&[~],comb 0 x$^n~$^s~$n.fmt("%.{$n-$s.comb%-$n}b"): $n}

Experimente online!

Explicação

{
  reduce         # Reduce with
    &^h o&[~],   # composition of string concat and hash function
    comb         # Split string
      0 x$^n     # Zero repeated n times
      ~$^s       # Append input string s
      ~$n.fmt("  # Append n formatted
        %.       # with leading zeroes,
        {$n             # field width n for final chunk
         -$s.comb%-$n}  # -(len(s)%-n) for padding,
        b")      # as binary number
      :          # Method call with colon syntax
      $n         # Split into substrings of length n
}

Limpo , 143 bytes

import StdEnv
r=['0':r]
$n h s=foldl(\a b=h(a++b))(r%(1,n))([(s++r)%(i,i+n-1)\\i<-[0,n..length s]]++[['0'+toChar((n>>(n-p))rem 2)\\p<-[1..n]]])

Experimente online!

Python 2 , 126 113 bytes

lambda n,H,s:reduce(lambda x,y:H(x+y),re.findall('.'*n,'0'*n+s+'0'*(n-len(s)%n))+[bin(n)[2:].zfill(n)])
import re

Experimente online!

13 graças à triggernometria .

Sim, isso é uma abominação, por que não posso simplesmente usar um built-in para dividir uma string em pedaços ...? :-(

Python 2 , 106 102 bytes

Pela primeira vez, a função supera a lambda. -4 bytes para manipulação simples de sintaxe, graças a Jo King.

def f(n,H,s):
 x='0'*n;s+='0'*(n-len(s)%n)+bin(n)[2:].zfill(n)
 while s:x=H(x+s[:n]);s=s[n:]
 return x

Experimente online!

Japonês , 27 bytes

òV ú'0 pV¤ùTV)rÈ+Y gOvW}VçT

Tente!

Eu não encontrei nenhum recurso para o Japt assumir funções diretamente como entrada, portanto, isso pega uma string que é interpretada como código Japt e espera que ela defina uma função. Especificamente, OvWpega a terceira entrada e a interpreta como Japt e depois a gchama. Substituir isso por OxWpermite a entrada como uma função Javascript, ou se a função já estava (de alguma forma) armazenada em W, poderia ser apenas We salvar 2 bytes. O link acima tem o exemplo trabalhado de$\mathcal{H}$que recebe caracteres em índices ímpares, enquanto este é o exemplo "multiplique os códigos de caracteres e use os 5 dígitos mais altos".

Devido à maneira como Japt recebe entradas, $s$será U,$n$será Ve$\mathcal{H}$ será W

Explicação:

òV                             Split U into segments of length V
   ú'0                         Right-pad the short segment with "0" to the same length as the others
       p     )                 Add an extra element:
        V¤                       V as a base-2 string
          ùTV                    Left-pad with "0" until it is V digits long
              r                Reduce...
                        VçT          ...Starting with "0" repeated V times...
               È       }                                                  ...By applying:
                +Y               Combine with the previous result
                   gOvW          And run W as Japt code

GolfScript , 47 bytes

~:π'0'*:s\+s+π/);[sπ2base{48+}%+0π->]+{+1$~}*\;

Experimente online!

OK , 41 bytes

{(x#48)(y@,)/(0N,x)#z,,/$((x+x!-#z)#2)\x}

Experimente online!

{                                       } /x is n, y is H, z is s.
                          (x+x!-#z)       /number of padding 0's needed + x
                         (         #2)\x  /binary(x) with this length
                      ,/$                 /to string
                    z,                    /append to z
             (0N,x)#                      /split into groups of length x
       (y@,)/                             /foldl of y(concat(left, right))...
 (x#48)                                   /...with "0"*x as the first left string