শামিরের গোপন ভাগাভাগি পুনর্গঠন বাস্তবায়ন করুন


11

শামিরের গোপন ভাগাভাগি করার পরিকল্পনাটি কোনও গোপন বিষয়টিকে পুনর্গঠনের জন্য প্রয়োজনীয় কয়েকটি অংশে বিভক্ত করে রক্ষা করার এক সহজ উপায়।

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

ইনপুট

স্ট্যান্ডিন ব্যবহার করে ইনপুট করা হয়। প্রথমে একটি পূর্ণসংখ্যা আসে k, তারপরে কে লাইনগুলি অনুসরণ করে। এই লাইনের প্রত্যেকটিতে x yএকটি গোপন প্রতিনিধিত্ব করে এমন এক জোড়া পূর্ণসংখ্যা থাকে । f(x) = yমূল কথায় বহু গোপনীয় শব্দ যা গোপন তৈরিতে ব্যবহৃত হত।

প্রদত্ত গোপনীয় সংখ্যাগুলি সর্বদা সম্পর্কিত গোপনটি তৈরির জন্য যথেষ্ট।

আউটপুট

পুনর্গঠিত গোপন অবিরাম আউটপুট।

উদাহরণ

ইনপুট:

5         
1 564797566
2 804114535
4 1354242660
6 1818201132
7 503769263

আউটপুট:

1234

ইনপুট:

7
1 819016192
2 1888749673
3 1737609270
4 365594983
5 1628804870
6 1671140873
7 492602992

আউটপুট:

456457856

সম্পদ

উইকিপিডিয়া নিবন্ধ

কাগজ

সীমাবদ্ধ ক্ষেত্র উত্স: উইকিপিডিয়া

সীমাবদ্ধ ক্ষেত্রের গাণিতিক উত্স: উইকিপিডিয়া

ল্যাংরেঞ্জ বহুবচনীয় উত্স: উইকিপিডিয়া

সীমাবদ্ধ ক্ষেত্রের গাণিতিক সম্পর্কিত অধ্যায়

উত্তর:


4

বাশ, 271 অক্ষর

দ () {
[$ {1/0 /}] && {r $ (($ 2% $ 1)) $ 1; ((টি = ইউ, ইউ = ভি- $ 2 / $ 1 * ইউ, ভি = টি));
}
পড়া
((এন = 1928049029, এন = 0))
এক্স পড়ার সময় [$ n] y [$ n]
না ((ঢ ++,))
সম্পন্ন
জন্য ((ঝ n =; z- র = (z- র + L)% এন, I -;)) না
জন্য ((ঞ = ঢ, L = Y [আমি]; ঞ -;)) না
((প = 0, ভি = 1, D = এক্স [ঞ] -x [আমি], এম = n + ঘ))
r এমএন
[$ {d / 0 /}] && ((l = l * x [জে]% এন * (ইউ + এন)% এন))
সম্পন্ন
সম্পন্ন
প্রতিধ্বনি $ z

সর্বাধিক ক্ষেত্রে নিউলাইনগুলি প্রতিস্থাপন করা যেতে পারে, তবে আমি মনে করি না যে কোনও অপ্রয়োজনীয় সাদা জায়গা আছে।

(আমি আজকের আগে বুঝতে পারি নি যে বাশের পূর্ণসংখ্যাগুলি 64-বিট - খুব সহায়ক)।

বাশের জন্য পুনরাবৃত্ত জিসিডি (শোষণের বৈশ্বিক রাষ্ট্র) পুনরাবৃত্তের চেয়ে আরও বেশি সংযোগযোগ্য বলে মনে হয়। এটি বেশিরভাগ সোজা; আকর্ষণীয় কৌশলটি [ ${d/0/} ]&&fooকার্যকরভাবে হয়if [ $d -ne 0 ];then foo;fi


নিস! আমি কখনই এই সমস্যার কোনও উত্তর পাওয়ার আশা করিনি। +1
হুয়ান

@ জুয়ান, আমি এটি পার্লে করা শুরু করেছিলাম এবং ভেসে যাওয়ার চেয়ে পূর্ণসংখ্যা বিভাগ করতে বাধ্য করার কারণে আমি বিরক্ত হয়েছি। এবং আমি বাশকে যাইহোক ভাল জানি, সুতরাং এটিতে প্রাচীরের বিরুদ্ধে মাথা কম মারতে জড়িত।
পিটার টেলর

3

অক্টাভেতে 199 টি চরিত্র:

m=@(x)mod(x,1928049029);[d,l]=scanf('%d');c=d(1);e=repmat(int64(d(2:2:l)),1,c);[_,b]=gcd(e-e',1928049029*ones(c));b=eye(c)+m(e.*b);x=b(1,:);for i=2:c;x=m(x.*b(i,:));end;disp(m(sum(m(x'.*d(3:2:l)))))

3

গল্ফস্ক্রিপ্ট, 114 112 111 110 109 65 (86) অক্ষর

আপনি যদি এই সপ্তাহে ফলাফল পাওয়ার বিষয়ে চিন্তা না করেন তবে 65 টি চর যথেষ্ট:

~](;2/0\:X{~\.X{0=}%^\{\.@- 1928049029:P.,\@{@*\%(!}++?**}+/+P%}/

তবে আপনি যদি দক্ষতার সন্ধান করেন তবে এটি 86 টি অক্ষরে কিছুটা লম্বা:

~](;2/0\:X{~\.X{0=}%^\{\[.0](@-[1928049029:P%P]{.~/{\.(;@@~@*-+\}+2*.1=}do;0=*}+/+P%}/

এটি আমার ব্লগে এখানে পুনরাবৃত্তি করতে চেয়ে অনেক বেশি বিশদে বিচ্ছিন্ন করা হয়েছে ।


মূলত আমার কাজ নয়, তবে নাবের কাছ থেকে প্রচুর পরিমাণে আঁকানো 47 টি চর দেয়:

n%(!\:A{~A{~;.3$- 1928049029:N((?1or**}/\/+N%}/

দ্রষ্টব্য: আমি কেবল এই কোডটি সম্পর্কে যুক্তি দিয়েছি: সময় এবং এটির মেমরির পরিমাণ এবং দৈর্ঘ্যের দিক দিয়ে চালানোর চেষ্টা করা অর্থহীন।


3

গল্ফস্ক্রিপ্ট - 52 46 (67)

46 টি অক্ষরে মডুলার বিপরীতগুলির জন্য একটি ব্রুট ফোর্স পদ্ধতির। বারবার একটি prec (N-2) নির্বিচারে নির্ভুলতা পূর্ণসংখ্যার সাথে গণনা করে।

n%(!\:A{~A{~;.3$-.!+1928049029:N((?**}/\/+N%}/

বর্ধিত ইউক্লিডিয়ান অ্যালগরিদম বাস্তবায়ন করতে কেবল আমাদের অতিরিক্ত 15 টি অক্ষর খরচ হয়।

n%(!\:A{~A{~;.3$-:|!1\1928049029:N{@2$|3$/*-\|\:|%.}do;;**}/\/+N%}/

এই কোডটি আমার ব্লগ পোস্টে সম্পূর্ণরূপে বিশদ সহ মডিউলার গুণিত বিপরীত গণনার জন্য কিছু বিকল্প রয়েছে।


1
ভাল লাগছে, তবে আমি মনে করি এখনও কমপক্ষে দু'টি অক্ষর সংরক্ষণ করতে হবে। {*N%2<}সঙ্গে প্রতিস্থাপন{*N%1=} ব্লগে যেমন এবং আপনার খানা করতে (;পরে N,। তবে তারপরে পারফরম্যান্সটি হ'ল অপ্রাসঙ্গিক এন্ট্রির জন্য আপনি এক্সফেনেন্সেশনের মডুলার দিকটি নিয়ে বিরক্ত না করে ফারম্যাট এর সামান্য উপপাদ্যটি ব্যবহার করতে পারেন - কেবল এটি চূড়ান্ত পরিচ্ছন্নতার জন্য ছেড়ে দিন - তাই রসিপ হয়ে যায় N((?
পিটার টেলর

1
@Peter: {*N%1=}+ ডিনোমিনেটর শূন্যের সাথে কেস মিস করবে, যা পরিচালনা করতে কমপক্ষে 3 টি অক্ষর লাগবে। কেবল এক্স ^ (এন -2) করার ক্ষেত্রে ভাল ধরা যদিও আমরা এটি ব্যবহার করে 46 টি অক্ষর পেতে পারি।
ন্যাব

2

লুয়া 444 চারস

উইকির পৃষ্ঠায় উদাহরণের জন্য কাজ করে

3
2 1942
4 3402
5 4414

তবে কোনওভাবেই এই পৃষ্ঠায় উদাহরণগুলির জন্য কাজ করে না। কেউ যদি ত্রুটি খুঁজে পাবে?

নন-গল্ফ করা সংস্করণ:

-- Reconstruct shamir secret
-- convention, poly = {[0]=a0,a1,...,an}
i=io.read
f=math.fmod
w=1928049029
k=i():match"%d+"
x={} -- Will contain X values
y={} -- Will contain Y values
p={} -- will contain lagrange polynomials

-- Read data
for j=0,k-1 do
    x[j],y[j]=i():match("(%d+) (%d+)")
    print(j,x[j],y[j])
end
-- Multiplication and scaling function
function mul(p,q,s)
    -- multiply polies
    r={} -- poly to be returned
    for k=0,#p do 
        for l=0,#q do
            r[l+k]=r[l+k] or 0 -- if the coeff for degree l+k of x doesn't exist, put 0
            p[k]=p[k] or 0 -- if p hasn't got a coeff for x^k
            q[l]=q[l] or 0 -- idem for q
            r[l+k]=(r[l+k]+s*p[k]*q[l]%w -- calculate increment for coeff for x^(l+k) 
        end
    end
    -- Debugging
    io.write"Multiplied "
    printPoly(p)
    io.write"With       "
    printPoly(q)
    io.write("And scaling factor ",tostring(s),"\n")
    io.write"Yielding   "
    printPoly(r)
    return r
end

function printPoly(p) -- "Pretty" printing of the polynomial
    for k=#p,1,-1 do
        io.write(tostring(p[k] or 0),"x^",tostring(k),"+")
    end
    io.write(p[0])
    io.write"\n"
end
function egcd(a,b)
    if a == 0 then
        return b, 0, 1
    else
        local g, y, x = egcd(b % a, a)
        return g, x - math.floor(b / a) * y, y
    end
end

function inv(a,m)
    a=a>=0 and a or a+m
    local g,x,y = egcd(a,m)
    if g== 1 then
        return x%m
    else
        print(a,"has no inverse mod",m)
    end
end


-- generate lagrange polynomials
for j=0,#x do
    print("j=",j,"*********")
    for m=0,k-1 do
        if m~=j then -- if m==j, continue
            p[j]=p[j]or{[0]=1} -- if this poly doesn't exist, take 1
            p[j]=mul( p[j], {[0]=-x[m],1},inv(x[j]-x[m],w))-- multiply with (x-x_m)/(x_j-x_m)
            io.write"---------------------------------\n"
        end
    end
end
r=0 -- Result for x^0
for k=0,#p do
    print("l_"..k)
    printPoly(p[k]) -- print l_k
    r=r+f(y[k]*p[k][0],w) -- add coeff for x^0 to result
end
print("Secret was",f(r,w)) -- display result

গল্ফড (সসীম ক্ষেত্র ব্যবহার করছে না), ৪৪৪ টি চর:

i=io.read f=math.fmod w=1928049029 k=i():match"%d+"x={}y={}p={}for j=0,k-1 do x[j],y[j]=i():match("(%d+) (%d+)")end
function mul(p,q,s)r={}for k=0,#p do for l=0,#q do r[l+k]=r[l+k]or 0 p[k]=p[k]or 0 q[l]=q[l]or 0 r[l+k]=f(r[l+k]+s*p[k]*q[l],w)end end return r end
for j=0,#x do for m=0,k-1 do if m~=j then p[j]=p[j]or{[0]=1}p[j]=mul(p[j],{[0]=-x[m],1},1/(x[j]-x[m]))end end end r=0 for k=0,#p do r=r+f(y[k]*p[k][0],w)end
print(f(r,w))

উইকিপিডিয়া উদাহরণ একটি সীমাবদ্ধ ক্ষেত্র ব্যবহার করে না, যা সত্যিই লজ্জাজনক, এটি আরও অনেক শিক্ষামূলক হতে পারে। এটি সম্ভবত আপনার ত্রুটির উত্স।
এআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআআ।

2

জাভা, 435 407 অক্ষর

import java.util.*;public class G{public static void main(String[]args){Scanner s=new Scanner(System.in);int i,k,n=s.nextInt();long N=1928049029L,x[]=new long[n],y[]=new long[n],z=0,l,c;for(i=n;i-->0;){x[i]=s.nextInt();y[i]=s.nextInt();}for(i=n;i-->0;){l=y[i];for(long j:x)if(x[i]!=j){c=1;for(long a=N+j-x[i],b=N,d=0,t;b>0;){t=d;d=c-a/b*d;c=t;t=b;b=a%b;a=t;}l=l*j%N*(c+N)%N;}z+=l;}System.out.println(z%N);}}

Ungolfed:

import java.util.*;
public class G {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int i,k,n=s.nextInt();
        long N=1928049029L,x[]=new long[n],y[]=new long[n],z=0,l,c;
        for (i=n; i-->0;) {
            x[i]=s.nextInt();
            y[i]=s.nextInt();
        }
        for (i=n; i-->0;) {
            l=y[i];
            for (long j:x)
                if (x[i]!=j) {
                    // Extended Euclid algorithm - iterative version -
                    // to find the reciprocal of j-x[i] (mod N)
                    c=1;
                    for (long a=N+j-x[i], b=N, d=0, t; b>0;) {
                        t=d; d=c-a/b*d; c=t;
                        t=b; b=a%b; a=t;
                    }
                    l = l*j%N;
                    l = l*(c+N)%N;
                }
                z+=l;
        }
        System.out.println(z%N);
    }
}

2

হাস্কেল, 183

p=1928049029
a#0=(1,0)
a#b=let(s,t)=b#mod a b in(t,s-div a b*t)
s d=sum[y*product[z*fst((z-x)#p)|[z,_]<-d,z/=x]|[x,y]<-d]
main=interact$show.(`mod`p).s.map(map read.words).tail.lines
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.