Dato un elenco di espressioni matematiche che sono tutte vere e consistono in calcoli del resto del modulo con due numeri e un risultato, il tuo compito è quello di produrre i primi nnumeri che sono veri per tutte le istruzioni nell'elenco.

Per esempio:

[m % 3 = 0, m % 4 = 1, m % 5 = 3], dove% è l'operatore modulo.

Per n= 3, sono i primi 3 numeri (contando da 0) che si adattano alla sequenza 33, 93, 153, quindi il tuo risultato sarebbe quello (formato fino a te).

Regole / IO

1. Prendi un numero positivo ne un elenco di verità. Naturalmente, le cose che devi prendere sono solo l'RHS dell'operazione modulo e il risultato.
2. ne i numeri nell'elenco delle verità saranno sempre compresi nell'intervallo 1 -> 2 ^ 31-1 , così come i risultati.
3. Prendi input in qualsiasi forma conveniente e output in qualsiasi forma conveniente. Ad esempio, l'ingresso: 3 [3 0, 4 1, 5 3]ed uscita: 33 93 153.
4. È garantito che la soluzione è matematicamente possibile.
5. La fonte di input può provenire da un file, parametri di funzione, stdin, ecc ... Lo stesso vale per l'output.
6. Nessuna scappatoia.
7. Questo è code-golf, quindi vince il numero di byte più basso.

Casi test

# 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

Implementazione di riferimento in pseudo-codice

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
}

Gelatina , 7 byte

%⁼⁴
0ç#

Questo è un programma completo. Gli argomenti sono divisori, moduli target e numero di soluzioni, in questo ordine.

Provalo online!

Come funziona

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 byte

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

Provalo

L'input è ( number-of-values, list-of-divisors, list-of-remainders )

Allargato:

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

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

Una semplice funzione ricorsiva. Utilizzare curry nell'array prima e nseconda, in questo modo:

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 byte

Accetta l'input come numero intero ne una matrice adi [modulo, remainder]array con sintassi di curry (n)(a).

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

Casi test

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 byte

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

Esempio di utilizzo: 3 # [(8,0),(13,3),(14,8)]-> [120,848,1576].

Python, 67 byte

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 byte

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

Curioso per primo l'array di condizioni e il numero di risultati secondo. Modifica: salvato 2 byte non gestendo il caso zero.

Mathematica, 42 byte

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

Funzione senza nome, che restituisce un elenco di numeri interi positivi e accetta tre input: l'elenco dei moduli, l'elenco dei resti e il numero ndi numeri interi da restituire. Ad esempio, il secondo caso di test viene invocato da

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

e ritorna {120, 848, 1576}.

Il built-in #2~ChineseRemainder~#offre la più piccola soluzione non negativa; per ottenere tutte le soluzioni desiderate, aggiungiamo questo numero a Range[0,#3-1]LCM@@#, che è i primi nmultipli non negativi del multiplo meno comune di tutti i moduli.

Mathematica non ha elenchi infiniti valutati pigramente per quanto ne so, quindi questa implementazione è stata più breve di qualsiasi cosa ho trovato che ha testato interi non negativi uno per uno, anche con la lunghezza del nome della funzione ChineseRemainder, e anche se un test come Mod[k,{8,13,14}]=={0,3,8}funziona perfettamente bene.

PHP, 97 byte

la risposta più lunga finora. Ma sono contento di averlo sotto i 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++];

accetta input da argomenti della riga di comando separati,
stampa le corrispondenze separate e seguite da caratteri di sottolineatura.
Il ciclo non si interrompe mai; a malapena adatto per tester online.

Corri come php -r 'code' <n> <modulo1> <result1> <modulo2> <result2> ....

abbattersi

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

Appunti

$argc==count($argv). Per tre coppie ci sono 8 argomenti: il nome file $argv[0], n= $argv[1]e le modulo/ resultcoppie sopra. $v=2incrementato 3 volte dà 5> $argc/2.

Aggiungi un byte per un'uscita pulita: sostituisci &&$a[1]-->0?print$k._con ?$a[1]--?print$k._:die.

Pyth - 14 13 byte

.f!fneT%ZhTQE

Provalo online qui .

SmileBASIC, 102 byte

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

Questa è la prima volta che uso ONin SB. Il motivo per cui l'ho usato qui invece è IF F GOTO@Lstato per poterlo inserire ?Tsulla stessa riga, risparmiando 1 byte.

Python, 59 byte

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

m è un elenco di espressioni in forma di stringa come ["i % 4 == 1", ...]

Provalo online (con una gamma più breve, quindi finirà effettivamente)

PHP, 91 byte

Prendi l'elenco come array associativo

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

Provalo online!