Dada una lista de expresiones matemáticas que son verdaderas y consisten en cálculos de módulo restante con dos números y un resultado, su tarea es producir los primeros nnúmeros que son verdaderos para todas las declaraciones en la lista.

Por ejemplo:

[m % 3 = 0, m % 4 = 1, m % 5 = 3], donde% es el operador del módulo.

Para n= 3, los primeros 3 números (contando desde 0) que se ajustan a la secuencia son 33, 93, 153, por lo tanto, su resultado sería ese (formatee hasta usted).

Reglas / IO

1. Tomas un número positivo ny una lista de verdades. Por supuesto, las cosas que necesita tomar son solo el RHS de la operación del módulo y el resultado.
2. ny los números en la lista de verdades siempre estarán en el rango 1 -> 2 ^ 31-1 , y también lo son los resultados.
3. Usted toma la entrada en cualquier forma conveniente y la salida en cualquier forma conveniente. Por ejemplo, la entrada: 3 [3 0, 4 1, 5 3]y salida: 33 93 153.
4. Se garantiza que la solución es matemáticamente posible.
5. La fuente de entrada puede ser de un archivo, parámetros de función, stdin, etc. Lo mismo ocurre con la salida.
6. No hay escapatorias.
7. Este es el código de golf, por lo que gana el conteo de bytes más bajo.

Casos de prueba

# 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

Implementación de referencia en pseudocó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
}

Jalea , 7 bytes

%⁼⁴
0ç#

Este es un programa completo. Los argumentos son divisores, módulos de destino y número de soluciones, en ese orden.

Pruébalo en línea!

Cómo 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]}

Intentalo

La entrada es ( 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)]:[]

Una simple función recursiva. Utilice curry en la matriz primero y nsegundo, así:

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

Toma la entrada como un entero ny una matriz ade [modulo, remainder]matrices con sintaxis curry (n)(a).

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

Casos de prueba

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]

Ejemplo 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 el conjunto de condiciones primero y el número de resultados segundo. Editar: guardado 2 bytes al no manejar el caso cero.

Mathematica, 42 bytes

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

Función sin nombre, que devuelve una lista de enteros positivos y toma tres entradas: la lista de módulos, la lista de restos y el número nde enteros a devolver. Por ejemplo, el segundo caso de prueba es invocado por

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

y vuelve {120, 848, 1576}.

El builtin #2~ChineseRemainder~#da la solución no negativa más pequeña; para obtener todas las soluciones deseadas, agregamos este número a Range[0,#3-1]LCM@@#, que es el primer nmúltiplo no negativo del mínimo común múltiplo de todos los módulos.

Hasta donde yo sé, Mathematica no tiene listas infinitas evaluadas perezosamente, por lo que esta implementación fue más corta que cualquier cosa que encontré que probara enteros no negativos uno por uno, incluso con la longitud del nombre de la función ChineseRemainder, y aunque una prueba como Mod[k,{8,13,14}]=={0,3,8}funciona perfectamente bien.

PHP, 97 bytes

La respuesta más larga hasta ahora. Pero me alegro de poder llegar a menos 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++];

toma datos de argumentos de línea de comando separados,
imprime coincidencias separadas y seguidas por guiones bajos.
El bucle nunca se rompe; apenas adecuado para probadores en línea.

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

Descompostura

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 tres pares hay 8 argumentos: el nombre de archivo $argv[0], n= $argv[1]y los modulo/ resultpares por encima de eso. $v=2incrementado 3 veces da 5> $argc/2.

Agregue un byte para una salida limpia: reemplace &&$a[1]-->0?print$k._con ?$a[1]--?print$k._:die.

Pyth - 14 13 bytes

.f!fneT%ZhTQE

Pruébelo en línea aquí .

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 es la primera vez que uso ONen SB. La razón por la que lo usé aquí en lugar de IF F GOTO@Lfue para poder ponerlo ?Tdespués en la misma línea, ahorrando 1 byte.

Python, 59 bytes

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

m es una lista de expresiones en forma de cadena como ["i % 4 == 1", ...]

Pruébelo en línea (con un rango más corto, para que realmente termine)

PHP, 91 bytes

Tome la lista como matriz asociativa

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

Pruébalo en línea!