Dada uma lista de expressões matemáticas que são verdadeiras e consistem em cálculos de módulo restante com dois números e um resultado, sua tarefa é produzir os primeiros nnúmeros que são verdadeiros para todas as declarações da lista.

Por exemplo:

[m % 3 = 0, m % 4 = 1, m % 5 = 3], onde% é o operador de módulo.

Para n= 3, os 3 primeiros números (contando de 0) que se encaixam na sequência são 33, 93, 153, portanto, o resultado seria esse (o formato é seu).

Regras / IO

1. Você pega um número positivo ne uma lista de verdades. Obviamente, o que você precisa é apenas o RHS da operação do módulo e o resultado.
2. ne os números na lista de verdades sempre estarão no intervalo 1 -> 2 ^ 31-1 , e também os resultados.
3. Você recebe entradas de qualquer forma conveniente e saídas de qualquer forma conveniente. Por exemplo, a entrada de: 3 [3 0, 4 1, 5 3]e saída: 33 93 153.
4. É garantido que a solução é matematicamente possível.
5. A fonte de entrada pode ser de um arquivo, parâmetros de função, stdin, etc ... O mesmo vale para a saída.
6. Sem brechas.
7. Isso é código-golfe, então a menor contagem de bytes vence.

Casos de teste

# 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

Implementação de referência em pseudo-código

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
}

Geléia , 7 bytes

%⁼⁴
0ç#

Este é um programa completo. Os argumentos são divisores, módulos de destino e número de soluções, nessa ordem.

Experimente online!

Como funciona

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 bytes

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

Tente

A entrada é ( number-of-values, list-of-divisors, list-of-remainders )

Expandido:

{   # 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 bytes

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

Uma função recursiva simples. Use currying na matriz primeiro e nsegundo, da seguinte maneira:

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 bytes

Recebe a entrada como um número inteiro ne uma matriz ade [modulo, remainder]matrizes com sintaxe de currying (n)(a).

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

Casos de teste

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 bytes

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

Exemplo de uso: 3 # [(8,0),(13,3),(14,8)]-> [120,848,1576].

Python, 67 bytes

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 bytes

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

Curry sobre a matriz de condições primeiro e o número de resultados em segundo. Editar: salvou 2 bytes por não manipular o caso zero.

Mathematica, 42 bytes

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

Função sem nome, retornando uma lista de números inteiros positivos e recebendo três entradas: a lista de módulos, a lista de restantes e o número nde números inteiros a serem retornados. Por exemplo, o segundo caso de teste é chamado por

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

e retorna {120, 848, 1576}.

O builtin #2~ChineseRemainder~#fornece a menor solução não negativa; para obter todas as soluções desejadas, adicionamos esse número a Range[0,#3-1]LCM@@#, que é o primeiro nmúltiplo não negativo do múltiplo menos comum de todos os módulos.

Até onde eu sei, o Mathematica não possui listas infinitas avaliadas preguiçosamente; portanto, essa implementação foi mais curta do que qualquer coisa que eu descobrisse que testava números inteiros não negativos um por um - mesmo com o tamanho do nome da função ChineseRemainder, e mesmo que um teste Mod[k,{8,13,14}]=={0,3,8}funcione perfeitamente bem.

PHP, 97 bytes

resposta mais longa até agora. Mas estou feliz por ter conseguido abaixo de 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++];

recebe entrada de argumentos separados da linha de comando,
imprime correspondências separadas e rastreadas por sublinhados.
O loop nunca quebra; pouco adequado para testadores online.

Corra como php -r 'code' <n> <modulo1> <result1> <modulo2> <result2> ....

demolir

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

notas

$argc==count($argv). Para três pares, existem 8 argumentos: o nome do arquivo $argv[0], n= $argv[1]e os modulo/ resultpares acima disso. $v=2incrementado 3 vezes dá 5> $argc/2.

Adicione um byte para uma saída limpa: Substitua &&$a[1]-->0?print$k._por ?$a[1]--?print$k._:die.

Pitão - 14 13 bytes

.f!fneT%ZhTQE

Experimente online aqui .

SmileBASIC, 102 bytes

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

Esta é a primeira vez que usei ONno SB. A razão pela qual eu usei aqui em vez de IF F GOTO@Lfoi para poder colocá- ?Tlo na mesma linha, economizando 1 byte.

Python, 59 bytes

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

m é uma lista de expressões em forma de sequência, como ["i % 4 == 1", ...]

Experimente on-line (com um intervalo menor, para que realmente termine)

PHP, 91 bytes

Tome a lista como matriz associativa

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

Experimente online!