Hãy xem xét bạn có hàm băm , lấy các chuỗi có độ dài và trả về các chuỗi có độ dài và có đặc tính tốt là nó có khả năng chống va chạm , nghĩa là khó tìm thấy hai chuỗi khác nhau với cùng băm .$\mathcal{H}$$2n$$n$$s \neq s'$$\mathcal{H}(s) = \mathcal{H}(s')$

Bây giờ bạn muốn xây dựng hàm băm mới , lấy các chuỗi có độ dài tùy ý và ánh xạ chúng thành các chuỗi có độ dài , trong khi vẫn có khả năng chống va chạm.$\mathcal{H'}$ n$n$

May mắn cho bạn, đã có vào năm 1979, một phương pháp được biết đến với tên gọi xây dựng Damkård Merkle đã được xuất bản, đạt được chính xác điều này.

Nhiệm vụ của thử thách này sẽ là thực hiện thuật toán này, vì vậy trước tiên chúng ta sẽ xem xét một mô tả chính thức về cấu trúc MerkleTHER Damgård, trước khi đi qua một ví dụ từng bước sẽ cho thấy cách tiếp cận đơn giản hơn nó có thể xuất hiện lúc đầu

Cho một số nguyên , hàm băm như được mô tả ở trên và một chuỗi đầu vào có độ dài tùy ý, hàm băm mới thực hiện như sau:$n > 0$$\mathcal{H}$$s$$\mathcal{H'}$

• Đặt, chiều dài của và chia thành các đoạn có độ dài , điền vào đoạn cuối cùng với các số 0 ở cuối nếu cần. Điều này mang lại nhiều khối được gắn nhãn .$l = |s|$$s$$s$$n$m = ⌈ l$m = \lceil \frac{l}{n} \rceil$$c_1, c_2, \dots, c_m$
• Thêm một đoạn đầu và một đoạn cuối và , trong đó là một chuỗi bao gồm số không và là ở dạng nhị phân, được đệm bằng các số 0 dẫn đến độ dài .$c_0$$c_{m+1}$$c_0$$n$$c_{m+1}$$n$n$n$
• Bây giờ lặp lại áp dụng cho đoạn hiện tại nối với kết quả trước đó : , trong đó . (Bước này có thể rõ ràng hơn sau khi xem ví dụ bên dưới.)$\mathcal{H}$$c_i$$r_{i-1}$$r_i = \mathcal{H}(r_{i-1}c_i)$$r_0 = c_0$
• Đầu ra của là kết quả cuối cùng .$\mathcal{H'}$$r_{m+1}$

Nhiệm vụ

Viết một chương trình hoặc chức năng mà mất như là đầu vào một số nguyên dương , một hàm băm như hộp đen và một chuỗi không rỗng và trả về kết quả tương tự như trên đầu vào tương tự.$n$$\mathcal{H}$$s$$\mathcal{H'}$

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất trong mỗi ngôn ngữ sẽ thắng.

Thí dụ

Giả sử , vì vậy hàm băm đã cho của chúng tôi lấy các chuỗi có độ dài 10 và trả về các chuỗi có độ dài 5.$n = 5$$\mathcal{H}$

• Đưa ra đầu vào của , chúng tôi nhận được các đoạn sau: , , và . Lưu ý rằng cần được đệm đến chiều dài 5 với một số 0 ở cuối.$s = \texttt{"Programming Puzzles"}$$s_1 = \texttt{"Progr"}$$s_2 = \texttt{"ammin"}$$s_3 = \texttt{"g Puz"}$$s_4 = \texttt{"zles0"}$$s_4$
• $c_0 = \texttt{"00000"}$ chỉ là một chuỗi gồm năm số không và là năm số nhị phân ( ), được đệm bằng hai số 0 đứng đầu.$c_5 = \texttt{"00101"}$$\texttt{101}$
• Bây giờ các khối được kết hợp với $\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$ là đầu ra của chúng tôi.

Chúng ta hãy xem đầu ra này trông như thế nào tùy thuộc vào một số lựa chọn ¹ cho :$\mathcal{H}$

• Nếu , tức là chỉ trả về mỗi ký tự thứ hai, chúng tôi nhận được: Vì vậy, cần phải là đầu ra nếu một được đưa ra dưới dạng hàm hộp đen.$\mathcal{H}(\texttt{"0123456789"}) = \texttt{"13579"}$$\mathcal{H}$
  $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"}$"Pe011"
  $\texttt{"Pe011"}$$\mathcal{H}$
• Nếu chỉ trả về 5 ký tự đầu tiên của đầu vào, thì đầu ra của là . Tương tự nếu trả về 5 ký tự cuối cùng, đầu ra là .$\mathcal{H}$$\mathcal{H'}$$\texttt{"00000"}$$\mathcal{H}$$\texttt{"00101"}$
• Nếu nhân mã số ký tự của đầu vào của nó và trả về năm chữ số đầu tiên của số này, ví dụ , sau đó .$\mathcal{H}$$\mathcal{H}(\texttt{"PPCG123456"}) = \texttt{"56613"}$$\mathcal{H}'(\texttt{"Programming Puzzles"}) = \texttt{"91579"}$

^{1 Để đơn giản, những thực sự không có khả năng chống va chạm, mặc dù điều này không quan trọng để kiểm tra trình của bạn.$\mathcal{H}$}

Haskell , 91 90 86 byte

• -1 byte nhờ Laikoni
• -4 byte nhờ 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?)

Hãy thử trực tuyến!

Giải trình

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

Chỉ cần gán chuỗi "00...0"( '0' $n$ lần) choa

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

Hàm ?thực hiện ứng dụng đệ quy của h: clà hàm băm mà chúng ta đã thu được cho đến nay (độ dài $n$ ), zlà phần còn lại của chuỗi. Nếu ztrống thì chúng ta chỉ cần trả về c, nếu không, chúng ta lấy $n$ ký tự đầu tiên của z(có thể là đệm với số không từ a), thêm vào cvà áp dụng h. Điều này mang lại hàm băm mới, và sau đó chúng ta gọi ?đệ quy trên hàm băm này và các ký tự còn lại của z.

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

Các chức năng !là một trong những thực sự giải quyết thách thức. Nó nhận n, hvà s(ngầm) làm đầu vào. Chúng tôi tính toán a?s, và tất cả những gì chúng tôi phải làm là nối thêm nvào nhị phân và áp dụng hmột lần nữa. mapM(:"1")a!!ntrả về biểu diễn nhị phân của $n$ .

R , 159 154 byte

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)

Hãy thử trực tuyến!

Kinh quá! Trả lời các thử thách chuỗi trong R không bao giờ đẹp, nhưng điều này thật kinh khủng. Đây là câu trả lời mang tính hướng dẫn về cách không viết mã R "bình thường" ...

Cảm ơn nwellnhof đã sửa lỗi, với chi phí 0 byte!

Cảm ơn J.Doe đã hoán đổi toán tử bí danh để thay đổi mức ưu tiên, tốt cho -4 byte.

Giải thích dưới đây dành cho phiên bản trước của mã, nhưng các nguyên tắc vẫn giữ nguyên.

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 byte

#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);}

Hãy thử trực tuyến!

Không sạch như giải pháp bash, và rất ngẫu hứng.

Hàm đang fdùng Hnhư một hàm thay thế đầu vào chuỗi của nó bằng hàm băm của chuỗi đó, nnhư trong mô tả, và xchuỗi đầu vào và bộ đệm đầu ra.

Sự miêu tả:

#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 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động:

([?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

Thạch , 23 byte

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

Hãy thử trực tuyến!

$\mathcal H$$s$$n$

Bash , 127-byte

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

Hãy thử trực tuyến!

Điều này hoạt động như một chương trình / chức năng / kịch bản / đoạn. H phải được phân giải theo chương trình hoặc chức năng sẽ thực hiện băm. N là đối số. Cuộc gọi ví dụ:

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

Sự miêu tả:

Z=`printf %0*d $1`

Điều này tạo ra một chuỗi $1số không. Điều này hoạt động bằng cách gọi printf và yêu cầu nó in một số nguyên được thêm vào chiều rộng đối số thêm . Đối số bổ sung mà chúng ta chuyển là $1, đối số cho chương trình / hàm / tập lệnh lưu n.

R=$Z

Điều này chỉ sao chép Z, chuỗi số 0 của chúng tôi, thành R, chuỗi kết quả của chúng tôi, để chuẩn bị cho vòng băm.

while IFS= read -rn$1 c; do

Vòng lặp này trên đầu vào mỗi $1(n) ký tự tải các ký tự đọc vào c. Nếu đầu vào kết thúc thì c chỉ kết thúc quá ngắn. Các rĐảm bảo lựa chọn mà bất kỳ ký tự đặc biệt trong đầu vào không được bash-giải thích. Đây là -εtiêu đề - rkhông thực sự cần thiết, nhưng làm cho chức năng khớp chính xác hơn với đầu vào.

R=$R$c$Z

Điều này nối các ký tự n được đọc từ đầu vào đến R cùng với các số 0 để đệm (hiện tại có quá nhiều số 0).

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

Điều này sử dụng một chuỗi ở đây làm đầu vào cho hàm băm. Nội dung ${R::2*$1}là một thay thế tham số bash bí truyền có nội dung: R, bắt đầu từ 0, chỉ có 2n ký tự.

Ở đây vòng lặp kết thúc và chúng tôi kết thúc với:

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

Ở đây, thủ thuật chuỗi định dạng tương tự được sử dụng để 0 pad số. bcđược sử dụng để chuyển đổi nó thành nhị phân bằng cách đặt cơ sở đầu ra (obase) thành 2. Kết quả được chuyển đến hàm / chương trình băm có đầu ra không được ghi lại và do đó được hiển thị cho người dùng.

Bình thường , 24 byte

Vì Pyth không cho phép H được sử dụng cho tên hàm, nên tôi sử dụng ythay thế.

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

Hãy thử trực tuyến! Ví dụ với phiên bản "mỗi ký tự thứ hai" của H.

Perl 6 , 79 68 byte

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

Hãy thử trực tuyến!

Giải trình

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

Sạch sẽ , 143 byte

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

Hãy thử trực tuyến!

Python 2 , 126 113 byte

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

Hãy thử trực tuyến!

-13 nhờ vào Triggernometry .

Vâng, đây là một sự gớm ghiếc, tại sao tôi không thể sử dụng một tích hợp để tách một chuỗi thành nhiều phần ...? :-(

Python 2 , 106 102 byte

Lần đầu tiên, chức năng vượt qua lambda. -4 byte cho thao tác cú pháp đơn giản, nhờ 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

Hãy thử trực tuyến!

Japt , 27 byte

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

Thử nó!

OvWgOxWW$\mathcal{H}$

$s$U$n$V$\mathcal{H}$W

Giải trình:

ò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 byte

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

Hãy thử trực tuyến!

oK , 41 byte

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

Hãy thử trực tuyến!

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