Angesichts einer Liste von mathematischen Ausdrücken, die alle zutreffen und aus Modulo-Restberechnungen mit zwei Zahlen und einem Ergebnis bestehen, müssen Sie die ersten nZahlen ermitteln, die für alle Aussagen in der Liste zutreffen.

Beispielsweise:

[m % 3 = 0, m % 4 = 1, m % 5 = 3], wobei% der Modulo-Operator ist.

Für n= 3 sind die ersten 3 Zahlen (beginnend mit 0), die zur Sequenz passen 33, 93, 153, daher wäre das Ergebnis das (Format nach Belieben).

Regeln / IO

1. Du nimmst eine positive Zahl n und eine Liste von Wahrheiten. Natürlich sind die Dinge, die Sie mitnehmen müssen, nur die RHS der Modulo-Operation und das Ergebnis.
2. nund die Zahlen in der Liste der Wahrheiten werden immer im Bereich 1 -> 2 ^ 31-1 liegen , und so sind die Ergebnisse.
3. Sie nehmen Eingaben in beliebiger Form entgegen und geben sie in beliebiger Form aus. Zum Beispiel, Eingang: 3 [3 0, 4 1, 5 3]und Ausgang: 33 93 153.
4. Es ist garantiert, dass die Lösung mathematisch möglich ist.
5. Die Eingabequelle kann aus einer Datei, Funktionsparametern, stdin usw. stammen. Gleiches gilt für die Ausgabe.
6. Keine Lücken.
7. Das ist Code-Golf, also gewinnt die niedrigste Bytezahl.

Testfälle

# 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

Referenzimplementierung in Pseudocode

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
}

Gelee , 7 Bytes

%⁼⁴
0ç#

Dies ist ein volles Programm. Argumente sind Teiler, Zielmodul und Anzahl der Lösungen in dieser Reihenfolge.

Probieren Sie es online!

Wie es funktioniert

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]}

Versuch es

Die Eingabe ist ( number-of-values, list-of-divisors, list-of-remainders )

Erweitert:

{   # 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)]:[]

Eine einfache rekursive Funktion. Verwenden Sie, indem Sie zuerst und dann im Array nwie folgt vorgehen :

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

Übernimmt Eingaben als Ganzzahl nund als Array avon [modulo, remainder]Arrays mit aktueller Syntax (n)(a).

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

Testfälle

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]

Anwendungsbeispiel: 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 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

Wurde zuerst über das Bedingungsfeld und dann über die Anzahl der Ergebnisse gewechselt. Bearbeiten: 2 Bytes werden gespeichert, indem der Null-Fall nicht behandelt wird.

Mathematica, 42 Bytes

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

Unbenannte Funktion, die eine Liste positiver Ganzzahlen zurückgibt und drei Eingaben vornimmt: die Liste der Module, die Liste der verbleibenden nZahlen und die Anzahl der zurückzugebenden Ganzzahlen. Beispielsweise wird der zweite Testfall von aufgerufen

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

und kehrt zurück {120, 848, 1576}.

Das eingebaute #2~ChineseRemainder~#gibt die kleinste nichtnegative Lösung; Um alle gewünschten Lösungen zu erhalten, addieren wir diese Zahl zu Range[0,#3-1]LCM@@#, die das erste nnichtnegative Vielfache des am wenigsten verbreiteten Vielfachen aller Module ist.

Soweit ich weiß, hat Mathematica keine trägen unendlichen Listen ausgewertet. Daher war diese Implementierung kürzer als alles, was ich fand, dass nichtnegative Ganzzahlen einzeln getestet wurden - selbst mit der Länge des Funktionsnamens ChineseRemainderund obwohl ein Test wie Mod[k,{8,13,14}]=={0,3,8}perfekt funktioniert Gut.

PHP, 97 Bytes

längste Antwort bisher. Aber ich bin froh, dass ich es unter 100 schaffen konnte.

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++];

Nimmt Eingaben von separaten Befehlszeilenargumenten entgegen,
druckt Übereinstimmungen getrennt und mit Unterstrichen.
Schleife bricht nie; Für Online-Tester kaum geeignet.

Laufen wie php -r 'code' <n> <modulo1> <result1> <modulo2> <result2> ... .

Nervenzusammenbruch

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

Anmerkungen

$argc==count($argv). Für drei Paare gibt es 8 Argumente: den Dateinamen $argv[0], n= $argv[1]und das modulo/ result-Paar darüber. $v=23-mal erhöht ergibt 5>$argc/2 .

Fügen Sie ein Byte für einen sauberen Exit hinzu: Ersetzen &&$a[1]-->0?print$k._durch ?$a[1]--?print$k._:die.

Pyth - 14 13 Bytes

.f!fneT%ZhTQE

Probieren Sie es hier online aus .

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

Dies ist das erste Mal, dass ich ONSB benutzt habe. Der Grund, warum ich es hier anstelle von verwendet habe, IF F GOTO@Lwar, dass ich ?Tes in dieselbe Zeile stellen und 1 Byte sparen konnte.

Python, 59 Bytes

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

m ist eine Liste von Ausdrücken in Stringform wie ["i % 4 == 1", ...]

Probieren Sie es online aus (mit einer kürzeren Reichweite, damit es tatsächlich zu Ende geht)

PHP, 91 Bytes

Nehmen Sie die Liste als assoziatives Array

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

Probieren Sie es online!