Donnez crédit à qui le crédit est dû .

Objectif Étant donné un nombre entier N > 0, les plus petits entiers A, Bet de Ctelle sorte que:

1. Tous A, Bet Csont strictement supérieur N;
2. 2divise A;
3. 3divise B;
4. et 4divise C.

Il s'agit d'un code-golf, donc la réponse la plus courte en octets l'emporte. Vous pouvez utiliser un langage créé / mis à jour après ce défi, mais il est strictement non concurrentiel.

Cas de test

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

Gelée , 8 octets

~%2r4¤+‘

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça marche

~%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 octets

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

Arithmétique des bits pour 2 et 4, arithmétique modulaire pour 3.

J'ai trouvé quatre expressions de 7 octets pour le prochain multiple de kci - dessus nmais aucune plus courte:

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

Any donne 34 octets lors de la copie k=2,3,4et 33 octets s'ils sont combinés:

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

Mais, 2 et 4 sont des puissances de 2 qui permettent aux tours de bits de remettre à zéro les 1 ou 2 derniers octets.

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

Cela donne 6 octets (au lieu de 7) pour obtenir le prochain multiple, pour 32 octets au total, en battant le for k in 2,3,4.

Malheureusement, l'aspect prometteur n|1+1et n|3+1l'ajout sont effectués en premier, donc l'incrémentation de la sortie prend des parenthèses.

Julia, 16 octets

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

Essayez-le en ligne!

MATL, 15 10 9 octets

2:4+t5M\-

Essayez-le en ligne!

Explication:

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 octets

Qt_2:4\+

Utilise l'algorithme Jelly de Denis, je suis surpris que ce soit la même longueur!

Essayez-le en ligne ou vérifiez tous les cas de test .

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 octets

Une autre approche légèrement différente

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

05AB1E , 8 octets

Code:

>D(3L>%+

Essayez-le en ligne! .

Rubis, 27 octets

Mappe 2, 3 et 4 au multiple suivant ci-dessus n.

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

CJam, 15 octets

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

Essayez-le en ligne! ou vérifiez tous les cas de test .

Pyke, 11 9 8 octets

3FODQRc+

Essayez-le ici!

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 octets

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

Il s'agit d'une fonction sans nom qui prend en entrée un seul entier et renvoie une liste des multiples.

La Ceilingfonction prend un second paramètre facultatif qui lui dit d'arrondir au multiple suivant du nombre donné. Heureusement, il enfile également automatiquement son deuxième argument afin que nous puissions lui donner une liste de valeurs et à son tour, nous obtiendrons des multiples arrondis pour tous ceux-ci.

Octave, 20 octets

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

Exemples:

octave:60> f(123)
ans =

   124   126   124

octave:61> f(1081177)
ans =

   1081178   1081179   1081180

octave:62> f(420)
ans =

   422   423   424

Il convient de noter que nous pouvons le faire jusqu'à 9 sans ajouter d'octets supplémentaires:

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

Sortie (2520 est le plus petit entier positif divisible par tous les nombres à un chiffre):

octave:83> f(2520)
ans =

   2522   2523   2524   2525   2526   2527   2528   2529

Haskell, 27 octets

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

Labyrinthe , 19 octets

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

Essayez-le en ligne!

Cela génère les résultats dans l'ordre C, B, Aséparé par des sauts de ligne.

Explication

Comme d'habitude, une courte introduction au Labyrinthe:

• Labyrinth possède deux piles d'entiers de précision arbitraire, principale et auxiliaire (iliaire), qui sont initialement remplis d'une quantité infinie (implicite) de zéros. Nous n'utiliserons que main pour cette réponse.
• Le code source ressemble à un labyrinthe, où le pointeur d'instruction (IP) suit les couloirs quand il le peut (même dans les coins). Le code commence au premier caractère valide dans l'ordre de lecture, c'est-à-dire dans le coin supérieur gauche dans ce cas. Lorsque l'IP arrive à n'importe quelle forme de jonction (c'est-à-dire plusieurs cellules adjacentes en plus de celle dont elle est issue), elle choisira une direction basée sur le haut de la pile principale. Les règles de base sont les suivantes: tourner à gauche lorsque négatif, continuer à avancer à zéro, tourner à droite lorsqu'il est positif. Et lorsque l'un d'eux n'est pas possible car il y a un mur, l'IP prendra la direction opposée. L'IP se retourne également en cas d'impasse.

Malgré les deux non-ops (" ) qui rendent la mise en page un peu inutile, je suis assez satisfait de cette solution, car son flux de contrôle est en fait assez subtil.

L'IP commence dans le coin supérieur gauche à :droite. Il atteindra immédiatement une impasse sur le ?et se retournera, de sorte que le programme démarre réellement avec ce morceau de code linéaire:

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

Cela signifie que nous avons maintenant trois exemplaires de n sur la pile principale, mais sa profondeur est 4. C'est pratique car cela signifie que nous pouvons la profondeur de la pile pour récupérer le multiplicateur actuel tout en travaillant à travers les copies de l'entrée.

L'IP entre désormais dans une boucle 3x3 (dans le sens des aiguilles d'une montre). Notez que# , ce qui pousse la profondeur de pile, poussera toujours une valeur positive telle que nous savons que l'IP se tournera toujours vers l'est à ce point.

Le corps de la boucle est le suivant:

#   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.

Après que la boucle a été parcourue (jusqu'à !) trois fois, toutes les copies den sont utilisées et le zéro en dessous est révélé. En raison "du bas (qui semble autrement assez inutile), cette position est une jonction. Cela signifie qu'avec un zéro au-dessus de la pile, l'IP essaie d'aller tout droit (ouest), mais parce qu'il y a un mur, il fait un virage à 180 degrés et recule vers l'est comme s'il avait atteint une impasse.

Par conséquent, le bit suivant est maintenant exécuté:

"   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 octets

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

Pyth, 11 10 octets

m*dh/QdtS4

Suite de tests.

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

Merci à Dennis pour un octet!

JavaScript (ES6), 26 octets

Il est intéressant de porter la réponse Ruby de @ KevinLau ou la réponse Python @ xnor de la même longueur:

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

J'ai une légère préférence pour le port de la réponse Ruby car il fonctionne jusqu'à 2 ⁵³ -3 tandis que le port de la réponse Python ne fonctionne que jusqu'à 2 ³¹ -5.

C, 50 46 octets

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

Merci à Neil et nwellnhof pour avoir économisé 4 octets!

Décevamment long. J'ai l'impression qu'il y a un hack décalé ici que je ne connais pas, mais je ne le trouve pas encore. Renvoie un pointeur sur un tableau contenant les trois éléments. Programme complet:

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 octets

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

1: init

i1+#i2341ø

i1+#idéfinit l'entrée sur 1 + input; c'est parce que nous devons travailler sur des nombres strictement supérieurs à l'entrée. 234initialise la bande avec nos valeurs d'itération, et1ø saute au début de la ligne suivante.

2a: boucle

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

i(place l'entrée au STOS et 2[crée une nouvelle pile avec les 2 premiers éléments. ¤duplique la pile et ,fait le module. S'il y a un reste, q!^sort de la boucle pour aller en (b). Sinon, nous pouvons imprimer. $supprime le truc supplémentaire, ]ferme la pile et l' æimprime bien.l0wq!~se termine si la pile ne contient aucun membre.

2b: cette autre boucle

          >(1+)31j
        q!^

(1+)ajoute 1 au STOS et 31jsaute à la partie de la boucle qui ne prend pas de trucs de la pile. Et le profit.

Cet espace supplémentaire me dérange vraiment. Prenez un GIF.

Rétine, 62 43 26 octets

17 octets grâce à @Martin Büttner .

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

(Notez la nouvelle ligne de fin.)

Essayez-le en ligne!

Entrée en unaire dans 1, sortie en unaire en 1séparée par des retours à la ligne.

Version précédente de 43 octets:

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

Essayez-le en ligne!

Entrée en unaire, sortie en unaire séparée par un point-virgule ( ;).

Version précédente de 62 octets:

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

Essayez-le en ligne!

Entrée en unaire, sortie en unaire séparée par un point-virgule ( ;).

Octave, 27 22 20 octets

MATLAB et Octave:

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

Mieux (les solutions sont équivalentes, mais l'une peut surpasser l'autre lors de la poursuite du golf), MATLAB et Octave:

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

Uniquement en Octave:

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

Essayez ici .

Minkolang 0,15 , 17 octets

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

Essayez-le ici!

Explication

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 octets

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

S'attend Nà être présent sur la pile au démarrage du programme. Essayez-le en ligne!

Mathematica 28 octets

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}

Le cas général donne une réponse générale:

f[r]

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

R, 30 26 octets

(Réduction de 4 octets grâce à @Neil)

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

Cela (comme pour le reste des réponses, je suppose) ajoute 2: 4 à l'entrée et réduit le reste après avoir exécuté modulo sur les mêmes nombres.

UGL , 51 31 25 24 octets

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

Essayez-le en ligne!

Version précédente de 25 octets:

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

Essayez-le en ligne!

Version précédente de 31 octets:

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

Essayez-le en ligne!

Version précédente de 51 octets:

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

Essayez-le en ligne!

Java 70 57

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

Golfscript, 22 octets

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

Essayez-le en ligne!

Solution alternative à 22 octets:

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

Essayez-le en ligne!

En fait, 22 octets

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

Essayez-le en ligne!

Fait amusant: 3 bogues dans l'interprète d'Actually ont été trouvés et corrigés lors de l'écriture de ce programme.

Fait pas si amusant: ces 3 bogues ont empêché cette solution d'être beaucoup plus courte.

Explication:

╗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 octets

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

Essayez-le en ligne!