Gib Kredit, wem Kredit gebührt .

Ziel Gegeben eine ganze Zahl N > 0, aus den kleinsten ganzen Zahlen sind A, Bund Cso , dass:

1. Alle von A, Bund Csind streng größer als N;
2. 2teilt A;
3. 3teilt B;
4. und 4teilt C.

Dies ist ein Code-Golf, also gewinnt die kürzeste Antwort in Bytes. Sie können eine Sprache verwenden, die nach dieser Herausforderung erstellt / aktualisiert wurde, sie ist jedoch strengstens nicht konkurrierend.

Testfälle

N => A, B, C
1 => 2, 3, 4
4 => 6, 6, 8
43 => 44, 45, 44
123 => 124, 126, 124
420 => 422, 423, 424
31415 => 31416, 31416, 31416
1081177 => 1081178, 1081179, 1081180

Gelee , 8 Bytes

~%2r4¤+‘

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

~%2r4¤+‘  Main link. Argument: n (integer)

~         Bitwise NOT; yield ~n = -(n + 1).
     ¤    Combine the three links to the left into a niladic chain:
  2         Yield 2.
   r4       Yield the range from 2 to 4, i.e., [2, 3, 4].
 %        Yield the remainder of the division of ~n by 2, 3 and 4.
          In Python/Jelly, -(n + 1) % k = k - (n + 1) % k if n, k > 0.
       ‘  Yield n + 1.
      +   Add each modulus to n + 1.

Python 2, 32 Bytes

lambda n:[n+2&-2,n/3*3+3,n+4&-4]

Bitarithmetik für 2 und 4, modulare Arithmetik für 3.

Ich habe vier 7-Byte-Ausdrücke für das nächste Vielfache von koben gefunden, naber keinen kürzeren:

n-n%k+k
~n%k-~n
n/k*k+k
~n/k*-k

Beliebige gibt 34 Bytes beim Kopieren für k=2,3,4und 33 Bytes, wenn kombiniert:

[n/2*2+2,n/3*3+3,n/4*4+4]
[n/k*k+k for k in 2,3,4]

Aber 2 und 4 sind Zweierpotenzen, mit denen Bit-Tricks die letzten 1 oder 2 Bytes auf Null setzen können.

n+2&-2
n+4&-4

Dies ergibt 6 Bytes (anstelle von 7), um das nächste Vielfache zu erhalten (insgesamt 32 Bytes) for k in 2,3,4.

Leider sieht das vielversprechend aus n|1+1und n|3+1muss die Addition erst erledigt werden, so dass das Inkrementieren der Ausgabe Klammern braucht.

Julia, 16 Bytes

n->n-n%(r=2:4)+r

Probieren Sie es online!

MATL, 15 10 9 Bytes

2:4+t5M\-

Probieren Sie es online!

Erläuterung:

2:4          #The array [2, 3, 4]
   +         #Add the input to each element, giving us [12, 13, 14]
    t        #Duplicate this array
     5M      #[2, 3, 4] again
       \     #Modulus on each element, giving us [0, 1, 2]
        -    #Subtract each element, giving us [12, 12, 12]

MATL, 8 Bytes

Qt_2:4\+

Verwendet Denis 'Jelly-Algorithmus, ich bin überrascht, dass er dieselbe Länge hat!

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Q    % takes implicit input and increments by one
t_   % duplicate, and negate top of stack (so it's -(n+1))
2:4  % push vector [2 3 4]
\    % mod(-(n+1),[2 3 4])
+    % add result to input+1
     % implicit display

Matlab, 33 Bytes

Ein etwas anderer Ansatz

@(a)feval(@(x)a+1+mod(-a-1,x),2:4)

05AB1E , 8 Bytes

Code:

>D(3L>%+

Probieren Sie es online! .

Ruby, 27 Bytes

Ordnet 2, 3 und 4 dem nächsten Vielfachen oben zu n.

->n{(2..4).map{|e|n+e-n%e}}

CJam, 15 Bytes

5,2>rif{1$/)*N}

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Pyke, 11 9 8 Bytes

3FODQRc+

Probieren Sie es hier aus!

3FODQRc+
         - Q = input()
3F       - for i in range(3): # for i in [0,1,2]
  O      -  i += 2
    Q c  -   Q-(Q%i)
       + -  i+^

Mathematica, 21 Bytes

Ceiling[#+1,{2,3,4}]&

Dies ist eine unbenannte Funktion, die eine einzelne Ganzzahl als Eingabe verwendet und eine Liste der Vielfachen zurückgibt.

Die CeilingFunktion benötigt einen optionalen zweiten Parameter, der sie auf das nächste Vielfache der angegebenen Zahl aufrundet. Zum Glück fädelt es auch automatisch sein zweites Argument ein, sodass wir ihm eine Liste von Werten geben können, und wir werden für all diese wiederum Vielfache aufrunden.

Oktave, 20 Bytes

@(n)n-mod(n,d=2:4)+d

Beispiele:

octave:60> f(123)
ans =

   124   126   124

octave:61> f(1081177)
ans =

   1081178   1081179   1081180

octave:62> f(420)
ans =

   422   423   424

Bemerkenswert ist, dass wir dies bis zu 9 tun können, ohne zusätzliche Bytes hinzuzufügen:

@(n)n-mod(n,d=2:9)+d

Ausgabe (2520 ist die kleinste positive ganze Zahl, die durch alle einstelligen Zahlen gleichmäßig teilbar ist):

octave:83> f(2520)
ans =

   2522   2523   2524   2525   2526   2527   2528   2529

Haskell, 27 Bytes

f n=[div n d*d+d|d<-[2..4]]

Labyrinth , 19 Bytes

:?
:
#/)
\ #
!"*@
"

Probieren Sie es online!

Dies gibt die Ergebnisse in der C, B, Adurch Zeilenvorschübe getrennten Reihenfolge aus.

Erläuterung

Wie immer ein kurzer Labyrinth-Primer:

• Labyrinth hat zwei Stapel von Ganzzahlen mit willkürlicher Genauigkeit, main und aux (iliary), die anfänglich mit einer (impliziten) unendlichen Menge von Nullen gefüllt sind. Wir werden main nur für diese Antwort verwenden.
• Der Quellcode ähnelt einem Labyrinth, in dem der Anweisungszeiger (IP) nach Möglichkeit Korridoren folgt (sogar um Ecken). Der Code beginnt beim ersten gültigen Zeichen in der Lesereihenfolge, in diesem Fall also in der linken oberen Ecke. Wenn die IP zu einer beliebigen Art von Junction gelangt (dh zu mehreren benachbarten Zellen zusätzlich zu derjenigen, von der sie stammt), wählt sie eine Richtung aus, die auf der Oberseite des Hauptstapels basiert. Die Grundregeln sind: links abbiegen, wenn negativ, weiterfahren, wenn null, rechts abbiegen, wenn positiv. Und wenn eine davon nicht möglich ist, weil es eine Mauer gibt, dann geht die IP in die entgegengesetzte Richtung. Die IP dreht sich auch um, wenn Sackgassen getroffen werden.

Trotz der beiden No-Ops (" ), die das Layout etwas verschwenderisch erscheinen lassen, bin ich mit dieser Lösung ziemlich zufrieden, da der Steuerungsfluss tatsächlich ziemlich subtil ist.

Die IP beginnt in der oberen linken Ecke auf der :rechten Seite. Es wird sofort eine Sackgasse auf dem ?und umdrehen, so dass das Programm tatsächlich mit diesem linearen Stück Code beginnt:

:   Duplicate top of main stack. This will duplicate one of the implicit zeros
    at the bottom. While this may seem like a no-op it actually increases
    the stack depth to 1, because the duplicated zero is *explicit*.
?   Read n and push it onto main.
:   Duplicate.
:   Duplicate.

Das heißt, wir haben jetzt drei Kopien nauf dem Hauptstapel, aber die Tiefe ist 4. Das ist praktisch, weil wir so die Stapeltiefe bestimmen können, um den aktuellen Multiplikator abzurufen, während wir die Kopien der Eingabe durcharbeiten.

Die IP tritt nun in eine (im Uhrzeigersinn) 3x3-Schleife ein. Beachten Sie, dass #die Stapeltiefe immer einen positiven Wert liefert, sodass wir wissen, dass die IP an diesem Punkt immer nach Osten zeigt.

Der Schleifenkörper lautet wie folgt:

#   Push the stack depth, i.e. the current multiplier k.
/   Compute n / k (rounding down).
)   Increment.
#   Push the stack depth again (this is still k).
*   Multiply. So we've now computed (n/k+1)*k, which is the number
    we're looking for. Note that this number is always positive so
    we're guaranteed that the IP turns west to continue the loop.
"   No-op.
!   Print result. If we've still got copies of n left, the top of the 
    stack is positive, so the IP turns north and does another round.
    Otherwise, see below...
\   Print a linefeed.
    Then we enter the next loop iteration.

Nachdem die Schleife !dreimal (bis zu ) durchlaufen wurde, sind alle Kopien von nverbraucht, und die Null darunter wird angezeigt. Aufgrund der" am unteren Rand (die sonst ziemlich nutzlos erscheint) ist diese Position eine Abzweigung. Das heißt, mit einer Null oben auf dem Stapel versucht die IP, geradeaus (nach Westen) zu fahren, aber da es eine Wand gibt, dreht sie sich tatsächlich um 180 Grad und bewegt sich nach Osten zurück, als hätte sie eine Sackgasse erreicht.

Infolgedessen wird jetzt das folgende Bit ausgeführt:

"   No-op.
*   Multiply two zeros on top of the stack, i.e. also a no-op.
    The top of the stack is now still zero, so the IP keeps moving east.
@   Terminate the program.

Matlab, 50 Bytes

@(a)arrayfun(@(k)find(~rem(a+1:a+k,k))+a,[2 3 4])

Pyth, 11 10 Bytes

m*dh/QdtS4

Testsuite.

       tS4  generate range [2, 3, 4]
m           for d in range...
 *dh/Qd       d*(1+input/d)

Danke an Dennis für ein Byte!

JavaScript (ES6), 26 Byte

Interessanterweise führt die Portierung von @ KevinLaus Ruby-Antwort oder @ xnors Python-Antwort zu derselben Länge:

n=>[2,3,4].map(d=>n+d-n%d)
n=>[n+2&-2,n+3-n%3,n+4&-4]

Ich bevorzuge leicht den Port der Ruby-Antwort, da er bis zu 2 ⁵³ -3 funktioniert, während der Port der Python-Antwort nur bis zu 2 ³¹ -5 funktioniert .

C 50 46 Bytes

i;f(int*a,int n){for(i=1;++i<5;*a++=n+i-n%i);}

Vielen Dank an Neil und Nwellnhof für das Speichern von 4 Bytes!

Enttäuschend lange. Ich habe das Gefühl, dass es hier einen etwas wechselnden Hack gibt, von dem ich nichts weiß, den ich aber noch nicht finde. Gibt einen Zeiger auf ein Array zurück, das die drei Elemente enthält. Volles Programm:

i;f(int*a,int n){for(i=1;++i<5;*a++=n+i-n%i);}

int main()
{
    int array[3];
    int n=10;
    f(array, n);
    printf("A:%d\tB:%d\tC:%d\n",array[0],array[1],array[2]);
    return 0;
}

Reng, 40 Bytes

i1+#i2341ø>(1+)31j
i(2[¤,  q!^$]æl0eq!~

1: init

i1+#i2341ø

i1+#isetzt den Eingang auf 1 + input; das liegt daran, dass wir an den zahlen arbeiten sollen, die strikt größer sind als die eingabe. 234initialisiert das Band mit unseren Iterationswerten und1ø springt zum Anfang der nächsten Zeile.

2a: Schleife

i(2[¤,  q!^$]æl0eq!~

i(Setzt die Eingabe in den STOS und erstellt 2[einen neuen Stapel mit den beiden obersten Elementen. ¤dupliziert den Stapel und ,macht Modul. Wenn es einen Rest gibt, q!^bricht die Schleife ab, um zu (b) zu gelangen. Andernfalls können wir problemlos drucken. $Entfernt das Extra-Ding, ]schließt den Stapel und ædruckt es schön. l0wq!~wird beendet, wenn der Stack null Mitglieder enthält.

2b: diese andere Schleife

          >(1+)31j
        q!^

(1+)addiert 1 zum STOS und 31jspringt zu dem Teil der Schleife, der keine Daten vom Stapel nimmt. Und profitiere.

Dieses zusätzliche Leerzeichen stört mich wirklich. Nimm ein GIF.

Retina, 62 43 26 Bytes

17 Bytes dank @Martin Büttner .

^
1111
M! & `(11 +): (\ 1 *)
:

(Beachten Sie den abschließenden Zeilenumbruch.)

Probieren Sie es online!

Eingabe in unary in 1, Ausgabe in 1unary in durch Zeilenumbrüche getrennt.

Vorherige 43-Byte-Version:

.+
11:$&;111:$&;1111:$&
\b(1+):(\1*)1*
$1$2

Probieren Sie es online!

Eingabe in unary, Ausgabe in unary, durch Semikolon ( ;) getrennt.

Vorherige 62-Byte-Version:

.+
$&11;$&111;$&1111
((11)+)1*;((111)+)1*;((1111)+)1*
$1;$3;$5

Probieren Sie es online!

Eingabe in unary, Ausgabe in unary, durch Semikolon ( ;) getrennt.

Oktave, 27 22 20 Bytes

MATLAB und Octave:

f=2:4;@(x)f.*ceil((x+1)./f)

Besser (Lösungen sind gleichwertig, aber eine kann die andere übertreffen, wenn weiter Golf gespielt wird), MATLAB und Octave:

@(x)x-rem(x,2:4)+(2:4)
f=2:4;@(x)x+f-rem(x,f)

Nur in der Oktave:

@(x)x-rem(x,h=2:4)+h

Versuchen Sie es hier .

Minkolang 0,15 , 17 Bytes

n$z3[zi2+$d%-+N].

Probieren Sie es hier aus!

Erläuterung

n$z                  Take number from input and store in register
   3[                Open for loop that repeats 3 times
     z               Push value in register on stack
      i2+            Loop counter plus 2
         $d          Duplicate stack
           %-+       Mod, subtract, add
              N      Output as number
               ].    Close for loop and stop.

> <> 31 Bytes

&2v
:&\&
?!\1+:{:}%
ao\n1+:5=?;

Erwartet N, beim Programmstart auf dem Stack vorhanden zu sein. Probieren Sie es online!

Mathematica 28 Bytes

f@n_:=n-n~Mod~#+#&/@{2,3,4}

f[1]
f[4]
f[43]
f[123]
f[420]
f[31415]
f[1081177]

{2, 3, 4}

{6, 6, 8}

{44, 45, 44}

{124, 126, 124}

{422, 423, 424}

{31416, 31416, 31416}

{1081178, 1081179, 1081180}

Der allgemeine Fall liefert eine allgemeine Antwort:

f[r]

{2 + r - Mod [r, 2], 3 + r - Mod [r, 3], 4 + r - Mod [r, 4]}

R 30 26 Bytes

(Reduzierte 4 Bytes dank @Neil)

N=scan();cat(N+2:4-N%%2:4)

Dies (ähnlich wie der Rest der Antworten, denke ich) fügt 2: 4 zur Eingabe hinzu und reduziert den Rest, nachdem modulo auf den gleichen Zahlen ausgeführt wurde.

UGL , 51 31 25 24 Bytes

icu$l_u^^/%_u^*ocO$dddd:

Probieren Sie es online!

Vorherige 25-Byte-Version:

iRcu$l_u$r^/%_u*ocO$dddd:

Probieren Sie es online!

Vorherige 31-Byte-Version:

iRcuuulu$cuuuuuu%-r^/%_u*oddcO:

Probieren Sie es online!

Vorherige 51-Byte-Version:

i$$cuuu/%_ucuuu*@cuuuu/%_ucuuuu*@cuu/%_ucuu*ocOocOo

Probieren Sie es online!

Java 70 57

a->System.out.print(a/2*2+2+" "+(a/3*3+3)+" "+(a/4*4+4))

Golfscript, 22 Bytes

~..2/)2*@3/)3*@4/)4*]`

Probieren Sie es online!

Alternative 22-Byte-Lösung:

~..[4 2 3]{.@@/)*@}/]`

Probieren Sie es online!

Eigentlich 22 Bytes

╗52x"╝1`;╛@%Y@╜<*`╓"£M

Probieren Sie es online!

Unterhaltsame Tatsache: Beim Schreiben dieses Programms wurden 3 Fehler im Interpreter von Actually gefunden und behoben.

Keine so lustige Tatsache: Diese 3 Bugs verhinderten, dass diese Lösung viel kürzer wurde.

Erläuterung:

╗52x"╝1`;╛@%Y@╜<*`╓"£M
╗                       push input to reg0
 52x                    push range(2,5) ([2,3,4])
    "╝1`;╛@%Y@╜<*`╓"£M  map (for n in [2,3,4]):
     ╝                    push n to reg1
      1`;╛@%Y@╜<*`╓       find the smallest integer k where:
        ;╛@%Y               k is divisible by n and...
             @╜<*           is greater than the input

J, 18 Bytes

2 3 4&([*>:@<.@%~)

Probieren Sie es online!