Учитывая n(количество игроков), t(пороговое значение) и s(секрет), выведите nсекреты, сгенерированные алгоритмом Shamir's Secret Sharing .

Алгоритм

Для целей этой задачи вычисления будут выполняться в GF (251) (конечное поле размера 251, также известное как mod 251 целых чисел ). Обычно поле выбирается таким образом, чтобы его размер был больше простого числа n. Чтобы упростить задачу, размер поля будет постоянным. 251был выбран, потому что это наибольшее простое число, представимое 8-битным целым числом без знака.

1. Генерация t-1случайных целых чисел в (включительно) диапазоне [0, 250]. Добавьте эти с ₁ через в _Т-1 .
2. Построить t-1полином i-й степени, используя sв качестве значения константы и случайные целые числа из шага 1 в качестве коэффициентов степеней x: f (x) = s + x * a ₁ + x ² * a ₂ + ... + x ^{t- 1} * _Т-1 .
3. Выход (f(z) mod 251)для каждого zв (включительно) диапазоне [1, n].

Реализация эталона

#!/usr/bin/env python
from __future__ import print_function
import random
import sys

# Shamir's Secret Sharing algorithm
# Input is taken on the command line, in the format "python shamir.py n t s"

n, t, s = [int(x) for x in sys.argv[1:4]]
if t > n:
    print("Error: t must be less than or equal to n")
    exit()
if n not in range(2, 251):
    print("Error: n must be a positive integer less than 251")
    exit()
if t not in range(2, 251):
    print("Error: t must be a positive integer less than 251")
    exit()
if s not in range(251):
    print("Error: s must be a non-negative integer less than 251")
    exit()
p = 251
a = [random.randrange(0, 251) for x in range(t-1)]

def f(x):
    return s + sum(c*x**(i+1) for i,c in enumerate(a))

# Outputting the polynomial is for explanatory purposes only, and should not be included
#  in the output for the challenge
print("f(x) = {0} + {1}".format(s, ' + '.join('{0}*x^{1}'.format(c, i+1) for i,c in enumerate(a))))
for z in range(1, n+1):
    print(f(z) % p)

верификация

Следующий фрагмент стека может быть использован для проверки выходных данных:

var validate = function() {
  $('#nts-error').attr('hidden', parseInt($('#n').val()) >= parseInt($('#t').val()));
  $('#check').prop('disabled', parseInt($('#n').val()) < parseInt($('#t').val()));
};

// the following function is taken from https://rosettacode.org/wiki/Combinations#JavaScript
var combinations = function(arr, k) {
  var i,
    subI,
    ret = [],
    sub,
    next;
  for (i = 0; i < arr.length; i++) {
    if (k === 1) {
      ret.push([arr[i]]);
    } else {
      sub = combinations(arr.slice(i + 1, arr.length), k - 1);
      for (subI = 0; subI < sub.length; subI++) {
        next = sub[subI];
        next.unshift(arr[i]);
        ret.push(next);
      }
    }
  }
  return ret;
};

// The following code is taken from https://en.wikipedia.org/wiki/Shamir%27s_Secret_Sharing#Javascript_example with the modification that the prime is 251, not 257

var prime = 251;

/* Gives the decomposition of the gcd of a and b.  Returns [x,y,z] such that x = gcd(a,b) and y*a + z*b = x */
function gcdD(a, b) {
  if (b == 0) return [a, 1, 0];
  else {
    var n = Math.floor(a / b),
      c = a % b,
      r = gcdD(b, c);
    return [r[0], r[2], r[1] - r[2] * n];
  }
}

/* Gives the multiplicative inverse of k mod prime.  In other words (k * modInverse(k)) % prime = 1 for all prime > k >= 1  */
function modInverse(k) {
  k = k % prime;
  var r = (k < 0) ? -gcdD(prime, -k)[2] : gcdD(prime, k)[2];
  return (prime + r) % prime;
}

/* Join the shares into a number */
function join(shares) {
  var accum, count, formula, startposition, nextposition, value, numerator, denominator;
  for (formula = accum = 0; formula < shares.length; formula++) {
    /* Multiply the numerator across the top and denominators across the bottom to do Lagrange's interpolation
     * Result is x0(2), x1(4), x2(5) -> -4*-5 and (2-4=-2)(2-5=-3), etc for l0, l1, l2...
     */
    for (count = 0, numerator = denominator = 1; count < shares.length; count++) {
      if (formula == count) continue; // If not the same value
      startposition = shares[formula][0];
      nextposition = shares[count][0];
      numerator = (numerator * -nextposition) % prime;
      denominator = (denominator * (startposition - nextposition)) % prime;
    }
    value = shares[formula][1];
    accum = (prime + accum + (value * numerator * modInverse(denominator))) % prime;
  }
  return accum;
}

$('#check').click(
  function() {
    var good = true;
    var problem = [];
    var n = parseInt($('#n').val());
    var t = parseInt($('#t').val());
    var s = parseInt($('#s').val());
    combinations([...Array(n + 1).keys()].slice(1), t).forEach(
      function(xArr) {
        var xfArr = xArr.map(
          function(x) {
            return [x, parseInt($('#f' + x).val())];
          }
        );
        var L = join(xfArr);
        if (L !== s) {
          good = false;
          problem.push(xArr);
        }
      }
    );
    $('#valid').html(good ? "True" : ("False (problematic secret sets: {" + problem.map(
      function(elem) {
        return "[" + elem.join(', ') + "]";
      }) + "})"));
  }
);

$('#n').change(
  function() {
    var inputHTML = "";
    for (var i = 1; i <= parseInt($('#n').val()); i++) {
      inputHTML += 'f(' + i + '): <input type="number" min="0" max="250" value="0" id="f' + i + '"><br>\r\n';
    }
    $('#inputs').html(inputHTML);
    validate();
  }
);

$('#t').change(
  function() {
    validate();
  }
);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
n:
<input type="number" min="2" max="250" value="6" id="n">t:
<input type="number" min="2" max="250" value="3" id="t">s:
<input type="number" min="0" max="250" value="230" id="s">
<br>
<div id="nts-error" hidden="true">t must be less than or equal to n!</div>
<br>
<br>
<div id="inputs">
  f(1):
  <input type="number" min="0" max="250" value="35" id="f1">
  <br>f(2):
  <input type="number" min="0" max="250" value="95" id="f2">
  <br>f(3):
  <input type="number" min="0" max="250" value="159" id="f3">
  <br>f(4):
  <input type="number" min="0" max="250" value="227" id="f4">
  <br>f(5):
  <input type="number" min="0" max="250" value="48" id="f5">
  <br>f(6):
  <input type="number" min="0" max="250" value="124" id="f6">
</div>
<br>
<input type="submit" id="check" value="Verify">
<br>
<br>Valid:
<div id="valid"></div>

правила

• sбудет неотрицательным целым числом меньше чем 251, nи tбудет положительным целым числом меньше 251и больше чем 1. Кроме того, вы гарантированно, что входные данные являются действительными (то естьt <= n ).
• Ввод и вывод могут быть в любом разумном, однозначном и согласованном формате.
• Случайные числа должны выбираться из равномерного распределения - каждое возможное значение должно иметь равную вероятность выбора.

Желе , 15 байт

251©xX€⁵0¦ḅЀ%®

Ожидает t , n и s в качестве аргументов командной строки. Попробуйте онлайн!

Как это устроено

251©xX€⁵0¦ḅЀ%®  Main link. Left argument: t. Right argument: n Third argument: s

251©             Yield 251 and copy it to the register.
    x            Repeat [251] t times.
     X€          Random choice each; pseudo-randomly choose t integers from
                 [1, ..., 251]. Since 251 = 0 (mod 251), this is equivalent to
                 choosing them from [0, ..., 250].
       ⁵0¦       Replace the last generated integer (index 0) with s (⁵).
          ḅЀ    Interpret the resulting array as a base-k number, for each k in
                 [1, ..., n], and convert to integer.
              ®  Yield 251 from the register.
             %   Take the generated integers modulo 251.

Mathematica, 59 56 байт

Mod[Power~Array~{#2,#-1}.RandomInteger[250,#-1]+#3,251]&

Принимает три аргумента в порядке t , n и s . Создает 2d-массив с n строками и t -1 столбцами. Каждый вектор строки j , пронумерованный от 1 до n , содержит степени от j до j ^{t -1} . Затем создается вектор случайных целых коэффициентов в диапазоне от 0 до 250 со значениями t -1. Это умножается на матрицу с 2d-массивом, а затем добавляется s поэлементно и берется модуль 251, чтобы получить значение многочлена в каждой из n точек.

CJam, 27 25 байтов

{,:)@({;251mr}%@+fb251f%}

Проверьте это здесь.

Pyth, 24 байта

J+EmOK251tEm%s.e*b^dkJKS

Попробуйте онлайн!

Порядок ввода: n s tразделенный переводом строки.

JavaScript, 181 байт

(n,t,s)=>{r=Array(t-1).fill(0).map($=>{return Math.random()*251});f=(x=>{p = 0;r.map((k,c)=>p+=k*Math.pow(x, c));return s+p});_=Array(t-1).fill(0);_.map((l,i)=>_[i]=f(i));return _;}

Ungolfed:

(n, t, s) => {
    r = Array(t - 1).fill(0).map($ =>{return Math.random() * 251});
    f = (x => {
        p = 0;
        r.map((k, c) => p += k * Math.pow(x, c));
        return s + p
    });
    _ = Array(t - 1).fill(0);
    _.map((l, i) => _[i] = f(i));
    return _;
}

Я не знаю, как правильно это проверить, но я знаю, что было сложно заставить JS отображать новый массив, поскольку, очевидно, .mapпропускает неопределенные значения. Если кто-нибудь увидит какие-либо способы улучшения или недостатки, не стесняйтесь, дайте мне знать.

C #, 138 134 байта

(n,t,s)=>new int[n+1].Select((_,x)=>(s+new int[t-1].Select(k=>new Random(e).Next(251)).Select((c,i)=>c*Math.Pow(x+1,i+1)).Sum())%251);

C # лямбда, где входные intи выходные данные IEnumerable<double>. Вы можете попробовать мой код на .NetFiddle .

Я не уверен на 100% в правильности моего алгоритма, пожалуйста, прокомментируйте, если я что-то неправильно понял.

4 байта , сохраненный с помощью @ рэггами в трюке .

MATL , 20 19 байтов

251tliq3$Yrihi:ZQw\

Входной заказ t, s, n.

Попробуйте онлайн!

объяснение

251t    % Push 251 twice
l       % Push 1
iq      % Take input t. Subtract 1
3$Yr    % Generate t-1 random integers in [1 2 ... 251]
ih      % Take input s. Concatenate with the random integers
i:      % Take input n. Generate range [1 2 ... n]
ZQ      % Evvaluate polynomial at those values
w       % Swap to move copy og 251 to the top of the stack
\       % Modulo. Implicitly display

Юлия, 48 байтов

f(n,t,s)=(1:n).^(0:t-1)'*[s;rand(0:250,t-1)]%251

Попробуйте онлайн!

JavaScript (ES6), 116 байт

(n,t,s)=>[...Array(n)].map((_,i)=>++i&&t.reduce((r,a)=>r*i+a)%251,t=[...Array(t)].map(_=>--t?Math.random()*251|0:s))

Я хотел бы думать, что это один из редких случаев, когда reduceудары map.

Python 3 с NumPy , 103 байта

from numpy import*
lambda n,t,s:[poly1d(append(random.randint(0,251,t-1),s))(i+1)%251for i in range(n)]

Я могу честно сказать, что я никогда не ожидал использовать NumPy для кода гольфа ...

Анонимная функция, которая принимает входные данные через аргумент и возвращает список.

Как это устроено

from numpy import*         Import everything in the NumPy library
lambda n,t,s...            Function with input number of players n, threshold value t and
                           secret s
random.randint(0,251,t-1)  Generate a NumPy array R of t-1 random integers in [0,250]
append(...,s)              Append s to R
poly1d(...)                Generate a polynomial p of order t-1 with coefficients R and
                           constant term s
...for i in range(n)       For all integers i in [0,n-1]...
...(i+1)                   ...evaluate p(i+1), so for all integers in [1,n]...
...%251                    ...and take modulo 251
...:[...]                  return as list

Попробуйте это на Ideone

J , 32 30 байт

251|(1+i.@{.)p.~{:0}251?@#~1&{

Принимает список со значениями n , t и s .

Сохраненный 2 байта, используя заменить на индекс 0 идеи от @ Денниса решения .

объяснение

251|(1+i.@{.)p.~{:0}251?@#~1&{  Input: [n t s]
                           1&{  Select at index 1 (t)
                    251  #~     Create that many copies of 251
                       ?@       Generate that many random integers in [0, 251)
                {:              Get the tail of the input (s)
                  0}            Replace the value at index 0 of the random integer list
                                with s to make a coefficient list of the polynomial
          {.                    Get the head of the input (n)
       i.@                      Make the range [0, n-1]
     1+                         Add 1 to each to get [1, n]
             p.~                Evaluate the polynomial at each value [1, n]
251|                            Take each value mod 251 and return

Java 8, 224 байта:

(n,t,s)->{int[]W=new int[t-1];for(int i=0;i<t-1;i++){W[i]=new java.util.Random().nextInt(251);};long[]O=new long[n];for(int i=1;i<=n;i++){long T=0;for(int h=1;h<t;h++){T+=W[h-1]*Math.pow(i,h);}O[i-1]=((T+s)%251);}return O;};

Java 8 лямбда-выражение. Выводит разделенный запятыми массив целых чисел и прекрасно работает до тех пор, пока значения в выходном массиве не выйдут за пределы диапазона типа данных Java longили 64-разрядного целого числа со знаком, при котором они -200выводятся в массив.

Попробуйте онлайн! (Ideone)