Учитывая список математических выражений, которые все верны и состоят из вычислений по модулю остатка с двумя числами и результатом, ваша задача - получить первые nчисла, которые верны для всех операторов в списке.

Например:

[m % 3 = 0, m % 4 = 1, m % 5 = 3]где% - оператор по модулю.

Для n= 3 первые 3 числа (считая от 0), которые соответствуют последовательности 33, 93, 153, таким образом, ваш результат будет таким (отформатируйте до вас).

Правила / IO

1. Вы берете положительное число nи список истин. Конечно, все, что вам нужно, - это только RHS операции по модулю и результат.
2. nи числа в списке истин всегда будут в диапазоне 1 -> 2 ^ 31-1 , как и результаты.
3. Вы берете ввод в любой удобной форме и вывод в любой удобной форме. Например, входной сигнал: 3 [3 0, 4 1, 5 3]и выход: 33 93 153.
4. Гарантируется, что решение математически возможно.
5. Источник ввода может быть из файла, параметров функции, стандартного ввода и т. Д. То же самое относится и к выводу.
6. Нет лазеек.
7. Это код-гольф, поэтому выигрывает самое низкое число байтов.

Testcases

# Input in the form <n>, <(d r), (d2 r2), ...>
# where <d> = RHS of the modulo expression and <r> the result of the expression. Output in the next line.

5, (3 2), (4 1), (5 3)
53 113 173 233 293

3, (8, 0), (13, 3), (14, 8)
120 848 1576

Ссылочная реализация в псевдокоде

n = (an integer from stdin)
truths = (value pairs from stdin)
counter = 0

while n != 0 {
    if matches_criterias(counter, truths) {
        print counter
        n -= 1
    }

    counter += 1
}

Желе , 7 байт

%⁼⁴
0ç#

Это полная программа. Аргументы - это делители, целевые модули и количество решений в указанном порядке.

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

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

0ç#  Main link.
     Left argument: D (array of divisors)
     Right argument: M (array of target moduli)
     Third argument: n (number of solutions)

0ç#  Execute the helper link with k = 0, 1, 2, ... as left argument and D as the
     right one until n of them return 1. Yield the array of matches.


%⁼⁴  Helper link. Left argument: k. Right argument: D

%    Compute k % d for each d in D.
 ⁼⁴  Compare the result with M.

Perl 6 , 33 байта

{grep((*X%@^b)eqv@^c,0..*)[^$^a]}

Попытайся

Вход ( number-of-values, list-of-divisors, list-of-remainders )

Expanded:

{   # bare block lambda with placeholder parameters ｢$a｣ ｢@b｣ ｢@c｣

  grep(

    # WhateverCode lambda:
    (

      *        # the value being tested

      X%       # cross modulus

      @^b      # with the divisors ( second parameter )

    )

    eqv        # is that list equivalent with

    @^c        # the expected remainders ( third parameter )

    # end of WhateverCode lambda

    ,

    0 .. *     # Range of all Integers starting with 0

  )[ ^$^a ]    # grab up-to ｢$a｣ values ( first parameter )
               # ( ｢^$a｣ is the same as ｢0 ..^ $a｣ )
}

JavaScript (ES6), 71 68 байт

a=>f=(n,m=0)=>n?a.some(x=>m%x[0]-x[1],++m)?f(n,m):[m,...f(n-1,m)]:[]

Простая рекурсивная функция. Используйте, каррируя в массиве first и nsecond, примерно так:

g=a=>f=(n,m=0)=>n?a.some(x=>m%x[0]-x[1],++m)?f(n,m):[m,...f(n-1,m)]:[]
g([[3, 2], [4, 1], [5, 3]])(5)

JavaScript (ES6), 74 70 69 байт

Принимает входной сигнал в виде целого числа nи массив aиз [modulo, remainder]массивов с выделкой синтаксиса (n)(a).

n=>a=>eval('for(i=r=[];a.some(([b,c])=>i%b-c)||--n*r.push(i);i++);r')

Контрольные примеры

let f =

n=>a=>eval('for(i=r=[];a.some(([b,c])=>i%b-c)||--n*r.push(i);i++);r')

console.log(f(5)([[3, 2], [4, 1], [5, 3]]))
console.log(f(3)([[8, 0], [13, 3], [14, 8]]))

Haskell, 47 байтов

n#l=take n[i|i<-[0..],all(\(d,r)->mod i d==r)l]

Пример использования: 3 # [(8,0),(13,3),(14,8)]-> [120,848,1576].

Python, 67 байт

lambda n,r:[k for k in range(2**32)if all(k%d==m for d,m in r)][:n]

JavaScript (ES6), 72 70 байт

a=>g=(n,i,r=[],m=a.some(e=>i%e[0]^e[1]))=>n?g(n-!m,-~i,m?r:[...r,i]):r

Вычисляется сначала по массиву условий и второму числу результатов. Изменить: 2 байта сохранены, не обрабатывая нулевой регистр.

Mathematica, 42 байта

#2~ChineseRemainder~#+Range[0,#3-1]LCM@@#&

Безымянная функция, возвращающая список положительных целых чисел и получающая три входа: список модулей, список остатков и число nвозвращаемых целых чисел. Например, второй контрольный пример вызывается

#2~ChineseRemainder~#+Range[0,#3-1]LCM@@#&[{8,13,14},{0,3,8},3]

и возвращается {120, 848, 1576}.

Встроенный #2~ChineseRemainder~#дает наименьшее неотрицательное решение; чтобы получить все желаемые решения, мы добавляем это число Range[0,#3-1]LCM@@#, которое является первым nнеотрицательным кратным числа наименьшего общего кратного всех модулей.

Насколько я знаю, Mathematica не имеет лениво вычисляемых бесконечных списков, поэтому эта реализация оказалась короче всего, что я обнаружил, когда тестировал неотрицательные целые числа один за другим, даже с длиной имени функции ChineseRemainder, и даже при том, что подобный тест Mod[k,{8,13,14}]=={0,3,8}работает отлично Что ж.

PHP, 97 байт

самый длинный ответ до сих пор. Но я рад, что смог получить его ниже 100.

for($a=$argv;++$k;)for($i=$v=2;$m=$a[$i++];$v>$argc/2&&$a[1]-->0?print$k._:0)$v+=$k%$m==$a[$i++];

принимает входные данные из отдельных аргументов командной строки,
печатает совпадения, разделенные и завершенные подчеркиванием.
Петля никогда не ломается; едва подходит для онлайн-тестеров.

Беги как php -r 'code' <n> <modulo1> <result1> <modulo2> <result2> ....

сломать

for($a=$argv;++$k;)         // loop $k up from 1
    for($i=$v=2;                // $i = argument index, $v=2+ number of satisfied equations
        $m=$a[$i++];            // loop through modulo/result pairs
        $v>$argc/2                  // 2. if $v>argument-count/2
        &&$a[1]-->0                 // and match count not exhausted
            ?print$k._                  // print match
            :0                          // else do nothing
        )
            $v+=$k%$m==$a[$i++];    // 1. if $k%modulo==result, increment $v

Примечания

$argc==count($argv), Для трех пар есть 8 аргументов: имя файла $argv[0], n= $argv[1]и пары modulo/ resultнад этим. $v=2увеличение в 3 раза дает 5> $argc/2.

Добавьте один байт для чистого выхода: замените &&$a[1]-->0?print$k._на ?$a[1]--?print$k._:die.

Pyth - 14 13 байт

.f!fneT%ZhTQE

Попробуйте это онлайн здесь .

SmileBASIC, 102 байта

DEF V N,M
FOR K=1TO N@L
T=T+1F=0FOR J=1TO LEN(M)F=F||T MOD M[J-1]-M[J]J=J+1NEXT
ON!F GOTO @L?T
NEXT
END

Это первый раз, когда я использовал ONв SB. Причина, по которой я использовал его здесь вместо того, IF F GOTO@Lзаключалась в том, что я мог поставить ?Tпосле него одну и ту же строку, сэкономив 1 байт.

Python, 59 байт

lambda n,m:[i for i in range(2**31)if all(map(eval,m))][:n]

m это список выражений в виде строки, как ["i % 4 == 1", ...]

Попробуйте онлайн (с более коротким диапазоном, чтобы он действительно закончился)

PHP, 91 байт

Взять список как ассоциативный массив

<?for($t=1;$r<$_GET[1];$i+=$t=!$t?:print+$i._.!++$r)foreach($_GET[0]as$k=>$v)$t*=$i%$k==$v;

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