Eğer bir var düşünün karma işlevi uzunluğu dizeleri alır ve getiri uzunluğu dizeleri ve onu olduğu güzel bir özelliği vardır dirençli çarpışma , yani iki farklı dizeleri bulmak zor ile aynı karma .$\mathcal{H}$$2n$$n$$s \neq s'$$\mathcal{H}(s) = \mathcal{H}(s')$

Artık , çarpışmalara karşı dirençli olurken , keyfi uzunluktaki dizeleri alıp uzunluktaki dizelerle eşleyen yeni bir karma işlev oluşturmak istiyorsunuz .$\mathcal{H'}$$n$

Şanslısınız, zaten 1979'da Merkle-Damgård inşaatı olarak bilinen ve tam olarak bunu başaran bir yöntem yayınlandı.

Bu zorluğun görevi bu algoritmayı uygulamak olacak, bu yüzden yaklaşımın daha basit olduğunu göstermesi gereken adım adım bir örnek geçmeden önce Merkle-Damgård yapısının resmi bir tanımına bakacağız. ilk başta görünebilir.

Bazı tamsayısı , yukarıda açıklandığı gibi bir karma işlevi ve keyfi uzunlukta bir giriş dizesi verildiğinde, yeni karma işlevi şunları yapar:$n > 0$$\mathcal{H}$$s$$\mathcal{H'}$

• Set, uzunluğunu ve uzunluğundaki parçalar halinde bölün , gerekirse son parçayı sondaki sıfırlarla doldurun. Bu, olarak etiketlenmiş birçok .$l = |s|$$s$$s$$n$$m = \lceil \frac{l}{n} \rceil$$c_1, c_2, \dots, c_m$
• Ekleme lider ve bir arka yığın ve , oluşan bir dizi olup sıfır ve olduğu ile şişirilir, ikili olarak gelen uzunluğu sıfır .$c_0$$c_{m+1}$$c_0$$n$$c_{m+1}$$n$$n$
• Şimdi , önceki sonuca eklenen geçerli yinelemeli olarak uygulanır : , burada . (Aşağıdaki örneğe baktıktan sonra bu adım daha açık olabilir.)$\mathcal{H}$$c_i$$r_{i-1}$$r_i = \mathcal{H}(r_{i-1}c_i)$$r_0 = c_0$
• çıktısı nihai sonuç .$\mathcal{H'}$$r_{m+1}$

Görev

Giriş olarak bir pozitif tamsayıyı alan bir program ya da işlev Yazın , bir karma işlev olarak kara kutu ve boş olmayan bir dizge ve geri dönüş aynı sonuç olarak aynı girdilere.$n$$\mathcal{H}$$s$$\mathcal{H'}$

Bu kod golf , bu yüzden her dilde en kısa cevap kazanır.

Misal

Diyelim ki , bu yüzden verilen hash fonksiyonumuz 10 uzunluktaki dizeleri alır ve 5 uzunluktaki dizeleri döndürür.$n = 5$$\mathcal{H}$

• Bir giriş verilen , aşağıdaki parçaları almak: , , ve . , bir sıfır sonunda 5 uzunluğuna kadar doldurulması gerektiğini unutmayın .$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"}$ yalnızca beş oluşan bir dizedir ve ikili olarak beştir ( ) ve iki önde gelen sıfırla doldurulmuştur.$c_5 = \texttt{"00101"}$$\texttt{101}$
• Şimdi parçalar ile birleştirilmiştir :$\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$ .

için bazı seçimler ^1'e bağlı olarak bu çıktının nasıl görüneceğine bir göz atalım :$\mathcal{H}$

• Eğer , yani sadece her saniye karakteri döndürür elde ederiz: Yani böyle ise, çıkış olması gerekmektedir kara kutu fonksiyonu olarak verilir.$\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}$
• Eğer sadece kendi girişi ilk 5 karakter, çıkış döner olan . Benzer şekilde son 5 karakteri döndürürse, çıktı .$\mathcal{H}$$\mathcal{H'}$$\texttt{"00000"}$$\mathcal{H}$$\texttt{"00101"}$
• Eğer çarpar bir karakterin giriş kodları ve döner bu numaranın ilk beş basamaklı, örneğin , daha sonra .$\mathcal{H}$$\mathcal{H}(\texttt{"PPCG123456"}) = \texttt{"56613"}$$\mathcal{H}'(\texttt{"Programming Puzzles"}) = \texttt{"91579"}$

^{1 Basitlik açısından, bu aslında çarpışmaya karşı dayanıklı değildir, ancak bu, gönderiminizi test etmek için önemli değildir.$\mathcal{H}$}

Haskell , 91 90 86 bayt

• Laikoni sayesinde -1 bayt
• Xnor sayesinde -4 bayt

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

Çevrimiçi deneyin!

açıklama

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

Dizeyi "00...0"( '0' $n$ kez)a

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

Fonksiyon ?özyinelemeli uygulamayı uygular h: cşimdiye kadar elde ettiğimiz hash (uzunluk $n$ ), zdizenin geri kalan kısmıdır. Boşsa z, sadece geri döneriz c, aksi takdirde (muhtemelen sıfırlarla doldurma ) ilk $n$ karakterini zalır a, başa cve uygulanır h. Bu yeni karmayı verir ve sonra ?bu karmaya ve karakterinin geri kalan karakterlerine özyineli olarak çağırırız z.

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

İşlev !, aslında meydan okumayı çözen işlevdir . Bu alan n, hve sgirdi olarak (kapalı). Hesaplıyoruz a?sve tek yapmamız gereken nikili sayıya eklemek ve bir hkez daha uygulamak . n'ninmapM(:"1")a!!n ikili temsilini döndürür .$n$

R , 159156 bayt

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)

Çevrimiçi deneyin!

Yuck! R'deki string zorluklarına cevap vermek hiç hoş değil, ama bu korkunç. Bu, "normal" R kodunun nasıl yazılmayacağına dair öğretici bir cevaptır ...

0 bayt maliyetiyle bir hatayı düzelttiği için nwellnhof'a teşekkürler !

Önceliği değiştirmek için operatörün takma adını değiştirdiği J.Doe sayesinde -4 bayt için iyi.

Aşağıdaki açıklama, kodun önceki sürümü içindir, ancak ilkeler aynı kalır.

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 bayt

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

Çevrimiçi deneyin!

Bash çözümü kadar temiz değil ve son derece geliştirilebilir.

Fonksiyonudur falarak H, bu dizgenin karma ile dize giriş yerini alan bir fonksiyonu olarak nbilgi olarak, ve xgiriş dize ve çıkış tamponu.

Açıklama:

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

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

Çevrimiçi deneyin!

Nasıl çalışır:

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

Jöle , 23 bayt

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

Çevrimiçi deneyin!

Kabul $\mathcal H$ üstünde hattında, $s$ sol bağımsız değişken olarak ve $n$ sağ bağımsız değişken olarak.

Bash , 127-bayt

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

Çevrimiçi deneyin!

Bu bir program / fonksiyon / kod / snippet olarak çalışır. H, karma işlemini gerçekleştirecek bir program veya işleve çözümlenebilir olmalıdır. N argüman. Örnek çağrı:

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

Açıklama:

Z=`printf %0*d $1`

Bu bir $1sıfır dizesi oluşturur . Bu, printf çağrısı yapılarak ve ekstra argüman genişliğine kadar dolgulu bir tam sayı yazdırmasını söyleyerek çalışır . Geçtiğimiz ekstra argüman $1, n'yi depolayan program / fonksiyon / betiğin argümanıdır.

R=$Z

Bu sadece karma dizeye hazırlanırken sıfır dizgimiz Z'yi sonuç dizgimiz olan R'ye kopyalar.

while IFS= read -rn$1 c; do

Bu $1, okunan karakterleri c'ye yükleyen her (n) karakterdeki girişin üzerinden geçer . Giriş sona ererse, c yalnızca çok kısa sona erer. Bu rseçenek, girişteki özel karakterlerin bash-yorumlanmamasını sağlar. Bu -εbaşlıktaki - rkesinlikle gerekli değildir, ancak işlevi girdiyle daha doğru bir şekilde eşleştirir.

R=$R$c$Z

Bu, doldurma için sıfırlarla (şimdilik şimdilik çok fazla sıfır) girişten R'ye okunan n karakterini birleştirir.

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

Burada, hash işlevine girdi olarak burada bir dize kullanılır. İçindekiler ${R::2*$1}biraz ezoterik bash parametresi ikamesidir: R, 0'dan başlayarak, sadece 2n karakterdir.

Burada döngü sona erer ve bitiririz:

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

Burada aynı format dize numarası numarayı 0 pad için kullanılır. bcçıktı tabanını (obase) 2 olarak ayarlayarak ikili sayıya dönüştürmek için kullanılır. Sonuç, çıktısı yakalanmayan ve böylece kullanıcıya gösterilen karma fonksiyona / programa aktarılır.

Pyth , 24 bayt

Pyth, H'nin bir işlev adı için kullanılmasına izin vermediğinden, ybunun yerine kullanıyorum.

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

Çevrimiçi deneyin! Örnek, H'nin "her ikinci karakter" versiyonudur.

Perl 6 , 79 68 bayt

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

Çevrimiçi deneyin!

açıklama

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

Temiz , 143 bayt

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

Çevrimiçi deneyin!

Python 2 , 126113 bayt

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

Çevrimiçi deneyin!

-13 Triggernometry sayesinde .

Evet, bu bir iğrenç, neden sadece bir ipi parçalara ayırmak için yerleşik bir şey kullanamıyorum ...? :-(

Python 2 , 106102 bayt

Bir kez, fonksiyon lambda'yı geride bırakıyor. Jo King sayesinde basit sözdizimi düzenleme için -4 bayt.

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

Çevrimiçi deneyin!

Japt , 27 bayt

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

Dene!

OvWgOxWW$\mathcal{H}$

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

Açıklama:

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

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

Çevrimiçi deneyin!

Tamam , 41 bayt

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

Çevrimiçi deneyin!

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