16

বিবেচনা করুন আপনি একটি আছে হ্যাশ ফাংশন $\mathcal{H}$ যা দৈর্ঘ্যের স্ট্রিং লাগে $2n$ এবং আয় দৈর্ঘ্যের স্ট্রিং $n$ এবং সুন্দর সম্পত্তি এটি থাকে সংঘর্ষের প্রতিরোধী , অর্থাত্ এটা খুঁজে কঠিন দুটি ভিন্ন স্ট্রিং $s \neq s'$ একই হ্যাশ সঙ্গে $\mathcal{H}(s) = \mathcal{H}(s')$ ।

আপনি এখন একটি নতুন হ্যাশ ফাংশন তৈরী করতে চাই $\mathcal{H'}$ যার স্ট্রিং লাগে নির্বিচারে দৈর্ঘ্য এবং তাদের দৈর্ঘ্য স্ট্রিং মানচিত্র $n$ , এখনও সংঘর্ষের প্রতিরোধী হচ্ছে।

আপনার জন্য ভাগ্যবান, ইতিমধ্যে 1979 সালে একটি পদ্ধতি বর্তমানে Merkle – Damgård নির্মাণ নামে পরিচিত প্রকাশিত হয়েছিল যা ঠিক এটি অর্জন করে।

এই চ্যালেঞ্জটির কাজটি হবে এই অ্যালগরিদমটি বাস্তবায়ন করা, সুতরাং আমরা প্রথমে একটি মেক্কেল-দামগার্ড নির্মাণের একটি আনুষ্ঠানিক বিবরণটি দেখতে পাব, ধাপে ধাপে উদাহরণের মধ্য দিয়ে যাওয়ার আগে যা দেখানো উচিত যে পদ্ধতির চেয়ে সহজতর এটি প্রথম প্রদর্শিত হতে পারে।

প্রদত্ত কিছু পূর্ণসংখ্যা $n > 0$ , একটি হ্যাশ ফাংশন $\mathcal{H}$ উপরে বর্ণিত এবং একটি ইনপুট স্ট্রিং হিসেবে $s$ নির্বিচারে দৈর্ঘ্যের, নতুন হ্যাশ ফাংশন $\mathcal{H'}$ নিম্নলিখিত আছে:

সেট $l = |s|$ , দৈর্ঘ্য $s$ , এবং বিভক্ত $s$ দৈর্ঘ্যের অংশ $n$ , গত খণ্ড পূরণ trailing প্রয়োজনে শূন্য। এই ফলন $m = \lceil \frac{l}{n} \rceil$ অনেক অংশ যা $c_1, c_2, \dots, c_m$ ।

একটি নেতৃস্থানীয় এবং একটি trailing খণ্ড যুক্ত করো $c_0$ এবং $c_{m+1}$ , যেখানে $c_0$ গঠিত একটি স্ট্রিং $n$ zeros এবং $c_{m+1}$ হয় $n$ বাইনারি মধ্যে, সঙ্গে প্যাডেড নেতৃস্থানীয় দৈর্ঘ্যের শূন্য $n$ ।

এখন iteratively এই আবেদন $\mathcal{H}$ বর্তমান খণ্ড থেকে $c_i$ পূর্ববর্তী ফলাফল যোগ $r_{i-1}$ : $r_i = \mathcal{H}(r_{i-1}c_i)$ , যেখানে $r_0 = c_0$ । (নীচের উদাহরণটি দেখার পরে এই পদক্ষেপটি আরও স্পষ্ট হতে পারে))

$\mathcal{H'}$ আউটপুট হ'ল চূড়ান্ত ফলাফল $r_{m+1}$ ।

কাজটি

একটি প্রোগ্রাম বা ফাংশন যা একটি ধনাত্মক পূর্ণসংখ্যা ইনপুট হিসাবে লাগে লিখুন $n$ , একটি হ্যাশ ফাংশন $\mathcal{H}$ যেমন কালো বাক্স এবং একটি খালি স্ট্রিং $s$ এবং আয় একই ফলাফল হিসাবে $\mathcal{H'}$ একই ইনপুট উপর।

এটি কোড-গল্ফ , তাই প্রতিটি ভাষার সংক্ষিপ্ত উত্তর জিততে পারে।

উদাহরণ

ধরা যাক $n = 5$ , সুতরাং আমাদের দেওয়া হ্যাশ ফাংশন $\mathcal{H}$ 10 দৈর্ঘ্যের স্ট্রিং নেয় এবং 5 দৈর্ঘ্যের স্ট্রিং দেয়।

$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"}$ হ'ল পাঁচটি শূন্যের একটি স্ট্রিং এবং $c_5 = \texttt{"00101"}$ পাঁচটি বাইনারি ( $\texttt{101}$ ), দুটি শীর্ষস্থানীয় জিরো সহ প্যাড করা হয়।
এখন খণ্ডগুলি $\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$ আমাদের আউটপুট।

আসুন দেখে নেওয়া যাক আউটপুটটি জন্য কিছু পছন্দ ^{1 এর} উপর নির্ভর করে কেমন দেখায় : $\mathcal{H}$

যদি $\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"}$
সুতরাং $\texttt{"Pe011"}$ যদি আউটপুট হওয়া দরকার যদি এই জাতীয় $\mathcal{H}$ ব্ল্যাক বক্স ফাংশন হিসাবে দেওয়া হয়।
যদি $\mathcal{H}$ কেবল তার ইনপুট প্রথম 5 অক্ষর ফেরৎ, আউটপুট $\mathcal{H'}$ হল $\texttt{"00000"}$ । একইভাবে $\mathcal{H}$ যদি শেষ 5 টি অক্ষর দেয় তবে আউটপুট $\texttt{"00101"}$ ।
যদি $\mathcal{H}$ তার চরিত্রের কোডগুলি বাড়িয়ে এবং এই সংখ্যার প্রথম পাঁচটি সংখ্যা যেমন, $\mathcal{H}(\texttt{"PPCG123456"}) = \texttt{"56613"}$ , তবে $\mathcal{H}'(\texttt{"Programming Puzzles"}) = \texttt{"91579"}$ ।

^{1 সরলতার জন্য, সেই $\mathcal{H}$ আসলে না সংঘর্ষের প্রতিরোধী, যদিও এই আপনার জমা পরীক্ষার জন্য কোন ব্যাপার না হয়।}

code-golf function hashing

— Laikoni
সূত্র

স্যান্ডবক্স (মুছে ফেলা)

— লাইকনি

আমি অবশ্যই মজাদার বলব যে দেওয়া উদাহরণটিতে সর্বশেষ 'পূর্ণ' হ্যাশটি "ওএমজি ধাঁধা!" কার্যকরভাবে omgPzzles0। ভাল নির্বাচিত উদাহরণ ইনপুট!

— লাম্বদাবেতা

আমরা কি এইচ-এর ইনপুট ফর্ম্যাটটিতে কিছুটা নমনীয়তা ধরে নিতে পারি (যেমন এটি দৈর্ঘ্যের এন এর দুটি স্ট্রিং, অথবা এটির প্রথম দুটি 2 অক্ষর বিবেচনা করে এমন দীর্ঘতর স্ট্রিং লাগে)?

— ডেল্ডাড্ডার

"G P" বৈধ আউটপুটের মধ্যে যেমন স্থানের অক্ষর রয়েছে?

— অতিথি 271314

@ অতিথি 271314 স্থানটি যদি ফলাফল হ্যাশের অংশ হয় তবে এটি আউটপুট করা দরকার। যদি হ্যাশটি আসলে "জিপি" হয় তবে আপনি অভ্যন্তরীণ কোনও স্থান আউটপুট নাও করতে পারেন।

— লাইকনি

7

হাস্কেল , 91 90 86 বাইট

-1 বাইট লাইকোনি ধন্যবাদ
-4 বাইট 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?)

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

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

কেবল স্ট্রিং "00...0"( '0' $n$ বার) বরাদ্দ করেa

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

ফাংশনটি ?এর পুনরাবৃত্তির প্রয়োগ প্রয়োগ করে h: cহ্যাশ যা আমরা এ পর্যন্ত পেয়েছি (দৈর্ঘ্য $n$ ), zবাকী স্ট্রিং। যদি zখালি থাকে তবে আমরা কেবল ফিরে cআসি, অন্যথায় আমরা প্রথম $n$ অক্ষরগুলি গ্রহণ করি z(সম্ভবত জিরো দিয়ে প্যাডিং করব a), প্রিপেন্ড cএবং প্রয়োগ করি h। এটি নতুন হ্যাশ দেয় এবং তারপরে আমরা ?এই হ্যাশ এবং এর বাকি অক্ষরগুলিতে পুনরাবৃত্তভাবে কল করি z।

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

ফাংশনটি !আসলে চ্যালেঞ্জের সমাধান করা। লাগে n, hএবং s(অন্তর্নিহিত) ইনপুট হিসাবে। আমরা গণনা করি a?s, এবং আমাদের যা করতে হবে তা হ'ল nবাইনারি যুক্ত করা এবং hআরও একবার প্রয়োগ করা । mapM(:"1")a!!nবাইনারি উপস্থাপনা ফেরৎ $n$ ।

— Delfad0r
সূত্র

1

letপ্রহরীতে ব্যবহারের চেয়ে খাটো where: অনলাইনে চেষ্টা করে দেখুন!

— লাইকনি

2

মনে হচ্ছে mapM(\_->"01")aহতে পারে mapM(:"1")a।

— xnor

7

আর , 159 154 বাইট

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)

এটি অনলাইন চেষ্টা করুন!

ইশ! আর-এ স্ট্রিং চ্যালেঞ্জগুলির জবাব দেওয়া কখনও সুন্দর নয়, তবে এটি ভয়াবহ। এটি "সাধারণ" আর কোডটি কীভাবে না লিখবেন তার একটি শিক্ষণীয় উত্তর ...

0 বাইট ব্যয়ে একটি বাগ সংশোধন করার জন্য নেলহোনাফকে ধন্যবাদ !

অগ্রাধিকার পরিবর্তনের জন্য অপারেটরকে অদলবদল করার জন্য জে.ডোকে ধন্যবাদ , -4 বাইটের জন্য ভাল।

নীচের ব্যাখ্যাটি কোডের পূর্ববর্তী সংস্করণের জন্য, তবে নীতিগুলি একই রয়েছে।

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

— : Giuseppe
সূত্র

আমি মনে করি 0*(n-(?s)%%n)এন সমানভাবে বিভক্ত হলে কাজ করে না। কিন্তু 0*-((?s)%%-n)কাজ করা উচিত।

— nwellnhof

@ ননহ্নহফ আহ, অবশ্যই, আপনাকে ধন্যবাদ, স্থির।

— জিউসেপ 13

গৌণ পরিবর্তন, 155 বাইট

— জে.ডো

1

@ জে.ডো দুর্দান্ত! আমি অন্য বাইট পর থেকে seqহয়েছে 1তার যেমন fromডিফল্টরূপে যুক্তি।

— জিউসেপ

3

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

Try it online!

Not as clean as the bash solution, and highly improvable.

The function is f taking H as a function that replaces its string input with that string's hash, n as in the description, and x the input string and output buffer.

Description:

#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

— LambdaBeta
সূত্র

229 bytes

— ceilingcat

I think: 227 bytes (going off of ceilingcat's comment)

— Zacharý

3

রুবি , 78 বাইট

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

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে:

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

— গিগাবাইট
সূত্র

2

জেলি , 23 বাইট

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

এটি অনলাইন চেষ্টা করুন!

গ্রহণ $\mathcal H$ উপরের লাইনে, $s$ এটির বাম যুক্তি হিসাবে এবং $n$ তার সঠিক যুক্তি হিসাবে।

— এরিক দ্য আউটগল্ফার
সূত্র

2

বাশ , 127-tes বাইট

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

বর্ণনা:

Z=`printf %0*d $1`

এটি $1শূন্যের একটি স্ট্রিং তৈরি করে । এটি প্রিন্টফকে কল করে এবং অতিরিক্ত আর্গুমেন্ট প্রস্থে একটি পূর্ণসংখ্যা প্যাড করে এটি কাজ করে বলে কাজ করে । আমরা যে অতিরিক্ত যুক্তিটি পাস করি তা হ'ল $1প্রোগ্রাম / ফাংশন / স্ক্রিপ্টের পক্ষে যুক্তি যা এন।

R=$Z

এটি হ্যাশিং লুপের প্রস্তুতির জন্য Z, আমাদের শূন্য স্ট্রিংটিকে কেবল আমাদের ফলাফলের স্ট্রিংকে অনুলিপি করে।

while IFS= read -rn$1 c; do

এটি প্রতিটি $1(এন) অক্ষর সিটিতে পঠিত অক্ষরগুলি লোড করে ইনপুটটির উপরে লুপ করে । যদি ইনপুটটি শেষ হয় তবে সি কেবল খুব ছোট হয়ে যায় ends rবিকল্প নিশ্চিত করে যে ইনপুট যে কোন বিশেষ অক্ষর পাবেন না ব্যাশ-বুঝিয়ে দিলেন। এটি -εশিরোনামের মধ্যে - এটি rকঠোরভাবে প্রয়োজনীয় নয়, তবে ফাংশনটি আরও সঠিকভাবে ইনপুটটির সাথে মেলে।

R=$R$c$Z

এটি প্যাডিংয়ের জন্য শূন্যের সাথে ইনপুট থেকে আর-তে পড়া এন অক্ষরগুলিকে একত্রিত করে (বর্তমানে অনেক বেশি শূন্য)।

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

এটি হ্যাশ ফাংশনে ইনপুট হিসাবে এখানে স্ট্রিং ব্যবহার করে। সামগ্রী${R::2*$1} কিছুটা মজাদার বাশ প্যারামিটার প্রতিস্থাপন যা পড়ছে: আর, 0 থেকে শুরু করে কেবল 2n অক্ষর।

এখানে লুপটি শেষ হয় এবং আমরা এখানে দিয়ে শেষ করব:

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

এখানে একই বিন্যাসের স্ট্রিং ট্রিকটি 0 প্যাডের জন্য ব্যবহৃত হয়। bcআউটপুট বেস (অবেস) 2 এ সেট করে এটি বাইনারি রূপান্তর করতে ব্যবহৃত হয় ফলাফলটি হ্যাশ ফাংশন / প্রোগ্রামে পাস করা হয় যার আউটপুট ক্যাপচার হয় না এবং এভাবে ব্যবহারকারীকে প্রদর্শিত হয়।

— LambdaBeta
সূত্র

"127-ε" কেন? কেন শুধু "127" নয়?

— সলোমন উকো

আমি জানি না। আমি rপতাকাটির প্রয়োজনীয়তা সম্পর্কে বেড়াতে ছিলাম । আমি বুঝতে পেরেছি 1 বাইট আসলেই কিছু যায় আসে না তবে ধাক্কা দিলে আমি এটি শেভ করতে পারি।

— লাম্বদাবেতা

জন্য readকমান্ড?

— সলোমন উকো

কারণ এটি ব্যতীত ইনপুটটির একটি ignored উপেক্ষা করার পরিবর্তে ব্যাখ্যা করা হবে, সুতরাং তাদের পালাতে হবে।

— লাম্বদাবেতা

সে সম্পর্কে একটি নোট যোগ করতে পারেন?

— সলোমন উকো

2

পাইথ , 24 বাইট

যেহেতু পাইথ H কে কোনও ফাংশন নামের জন্য ব্যবহার করতে দেয় না, আমি তার yপরিবর্তে ব্যবহার করি ।

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

এটি অনলাইন চেষ্টা করুন! উদাহরণ এইচ এর "প্রতিটি দ্বিতীয় অক্ষর" সংস্করণ সহ is

— স্টিভেন এইচ।
সূত্র

2

পার্ল 6 , 79 68 বাইট

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

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

— nwellnhof
সূত্র

1

পরিষ্কার , 143 বাইট

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

এটি অনলাইন চেষ্টা করুন!

— Οurous
সূত্র

1

পাইথন 2 , 126 113 বাইট

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

এটি অনলাইন চেষ্টা করুন!

-13 ট্রিগারনোমেট্রি ধন্যবাদ ।

হ্যাঁ, এটি একটি ঘৃণা, কেন আমি কেবল একটি স্ট্রিংগুলিকে খণ্ডগুলিতে বিভক্ত করতে একটি বিল্ট-ইন ব্যবহার করতে পারি না ...? :-(

— এরিক দ্য আউটগল্ফার
সূত্র

কোডগলফ.স্ট্যাকেক্সেঞ্জাংআআআ / ১7395৯২২ / 695569696 একটি whileলুপটি আমার পক্ষে সেরা বিল্টিন আশা করা যায়। 104 বাইট

— স্টিভেন এইচ।

@StevenH। হ্যাঁ, বিশেষত যদি আপনি আসলে গল্ফিংয়ের দিকে মনোনিবেশ করেন। > _>

— এরিক দি আউটগল্ফার

'0'*~-nপরিবর্তে '0'*(len(s)%n)ছোট হয় (এবং সংক্ষিপ্ত ইনপুটগুলির পক্ষে আসলে সঠিক) actually

— nwellnhof

@ ননহ্নহোফ হ্যাঁ, তবে এটি অবশ্যই একই জিনিস নয়।

— এরিক আউটগল্ফার

আমি যথেষ্ট পরিষ্কার ছিল না। আপনার সমাধানটি Programming Puzz(16 টি অক্ষরের) মতো স্ট্রিংয়ের জন্য ভুল উত্তর দেয় । প্রতিস্থাপন করা হচ্ছে '0'*(len(s)%n)সঙ্গে '0'*~-nসংশোধন করা হয়েছে যে এবং 7 বাইট পরিমাণ সঞ্চয় হয়।

— nwellnhof

1

পাইথন 2 , 106 102 বাইট

একবারের জন্য, ফাংশন ল্যাম্বডাকে আউটগল্ফ করে। সহজ বাক্য গঠন ম্যানিপুলেশনের জন্য -4 বাইটস, জো কিংকে ধন্যবাদ।

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

এটি অনলাইন চেষ্টা করুন!

— স্টিভেন এইচ।
সূত্র

ফলাফলটি 'পি011' হওয়া উচিত নয়, 'ই011' নয়?

— ট্রিগারনোমেট্রি

এটা করা উচিত। সংশোধন করা হয়েছে!

— স্টিভেন এইচ।

নিউলাইনগুলির পরিবর্তে আধা-কলোন ব্যবহার করুন। -4 বাইট

— জো কিং

আমি বুঝতে পারি নি যে লুপগুলি পাশাপাশি কাজ করেছে, ধন্যবাদ!

— স্টিভেন এইচ।

1

জাপট , 27 বাইট

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

চেষ্টা করে দেখুন!

জাপট সরাসরি ইনপুট হিসাবে ফাংশন নেওয়ার কোনও সামর্থ্য খুঁজে পাইনি, সুতরাং এটি একটি স্ট্রিং নেয় যা জাপট কোড হিসাবে ব্যাখ্যা করা হয় এবং এটি কোনও ফাংশন সংজ্ঞায়িত করার প্রত্যাশা করে। বিশেষত, OvWতৃতীয় ইনপুট নেয় এবং এটিকে জাপট হিসাবে ব্যাখ্যা করে, তারপরে gএটি কল করে। এর OxWপরিবর্তে জাভাস্ক্রিপ্ট ফাংশন হিসাবে ইনপুটটিকে অনুমতি দেয় বা ফাংশনটি (কোনওভাবে) যদি ডাব্লুতে ইতিমধ্যে সঞ্চিত থাকে তবে এটি কেবল হতে পারে Wএবং 2 বাইট সংরক্ষণ করতে পারে । উপরের লিঙ্কটির কাজের উদাহরণ রয়েছে $\mathcal{H}$ যেটি বিজোড় সূচকগুলিতে অক্ষর নেয়, যখন এটি এক "চার্ট-কোডগুলি বহুগুণ করুন এবং ৫ টি সর্বোচ্চ সংখ্যার উদাহরণ নিন"।

জাপট যেভাবে ইনপুট নেয় তার কারণে, $s$ হবে U, $n$ হবে V, এবং $\mathcal{H}$ হবে W

ব্যাখ্যা:

ò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

— কামিল দ্রাকারী
সূত্র

0

গল্ফস্ক্রিপ্ট , 47 বাইট

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

এটি অনলাইন চেষ্টা করুন!

— wastl
সূত্র

0

ওকে , 41 বাইট

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

এটি অনলাইন চেষ্টা করুন!

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

— zgrep
সূত্র

নির্বিচারে দৈর্ঘ্য হ্যাশিং

কাজটি

উদাহরণ

হাস্কেল , 91 90 86 বাইট

ব্যাখ্যা

আর , 159 154 বাইট

C (gcc), 251 bytes

রুবি , 78 বাইট

কিভাবে এটা কাজ করে:

জেলি , 23 বাইট

বাশ , 127-tes বাইট

পাইথ , 24 বাইট

পার্ল 6 , 79 68 বাইট

ব্যাখ্যা

পরিষ্কার , 143 বাইট

পাইথন 2 , 126 113 বাইট

পাইথন 2 , 106 102 বাইট

জাপট , 27 বাইট

গল্ফস্ক্রিপ্ট , 47 বাইট

ওকে , 41 বাইট