Dar crédito a quien se le debe el crédito .

Objetivo Dado un número entero N > 0, los números enteros más pequeños A, By Cde modo que:

1. Todos A, By Cson estrictamente mayor que N;
2. 2divisiones A;
3. 3divisiones B;
4. y 4se divide C.

Este es un código de golf, por lo que gana la respuesta más corta en bytes. Puede usar un lenguaje creado / actualizado después de este desafío, pero es estrictamente no competitivo.

Casos de prueba

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

Jalea , 8 bytes

~%2r4¤+‘

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

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

Aritmética de bits para 2 y 4, aritmética modular para 3.

Encontré cuatro expresiones de 7 bytes para el siguiente múltiplo de karriba npero ninguno más corto:

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

Cualquiera da 34 bytes cuando se copian k=2,3,4y 33 bytes si se combinan:

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

Pero, 2 y 4 son potencias de 2 que permiten que los trucos de bits pongan a cero los últimos 1 o 2 bytes.

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

Esto da 6 bytes (en lugar de 7) para obtener el siguiente múltiplo, para 32 bytes en general, superando el for k in 2,3,4.

Desafortunadamente, el aspecto prometedor n|1+1y n|3+1la adición se realizan primero, por lo que incrementar la salida toma paréntesis.

Julia, 16 bytes

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

Pruébalo en línea!

MATL, 15 10 9 bytes

2:4+t5M\-

Pruébalo en línea!

Explicación:

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\+

Utiliza el algoritmo Jelly de Denis, ¡me sorprende que tenga la misma longitud!

Pruébelo en línea o verifique todos los casos de prueba .

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

Otro enfoque ligeramente diferente

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

05AB1E , 8 bytes

Código:

>D(3L>%+

Pruébalo en línea! .

Rubí, 27 bytes

Mapas 2, 3 y 4 al siguiente múltiplo anterior n.

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

CJam, 15 bytes

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

Pruébalo en línea! o verificar todos los casos de prueba .

Pyke, 11 9 8 bytes

3FODQRc+

Pruébalo aquí!

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

Esta es una función sin nombre que toma un solo entero como entrada y devuelve una lista de los múltiplos.

La Ceilingfunción toma un segundo parámetro opcional que le dice que se redondee al siguiente múltiplo del número dado. Afortunadamente, también se enhebra automáticamente sobre su segundo argumento de modo que podamos darle una lista de valores y, a su vez, obtendremos múltiplos redondeados para todos esos.

Octava, 20 bytes

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

Ejemplos:

octave:60> f(123)
ans =

   124   126   124

octave:61> f(1081177)
ans =

   1081178   1081179   1081180

octave:62> f(420)
ans =

   422   423   424

Vale la pena señalar que podemos hacer esto hasta 9 sin agregar bytes adicionales:

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

Salida (2520 es el entero positivo más pequeño divisible por todos los números de un solo dígito):

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

Laberinto , 19 bytes

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

Pruébalo en línea!

Esto genera los resultados en el orden C, B, Aseparado por saltos de línea.

Explicación

Como de costumbre, una breve cartilla de laberinto:

• Labyrinth tiene dos pilas de enteros de precisión arbitraria, main y aux (iliary), que inicialmente se rellenan con una cantidad infinita (implícita) de ceros. Solo usaremos main para esta respuesta.
• El código fuente se asemeja a un laberinto, donde el puntero de instrucción (IP) sigue los corredores cuando puede (incluso en las esquinas). El código comienza en el primer carácter válido en el orden de lectura, es decir, en la esquina superior izquierda en este caso. Cuando la IP llega a cualquier forma de unión (es decir, varias celdas adyacentes además de la que proviene), elegirá una dirección basada en la parte superior de la pila principal. Las reglas básicas son: gire a la izquierda cuando sea negativo, siga adelante cuando sea cero, gire a la derecha cuando sea positivo. Y cuando uno de estos no es posible porque hay un muro, entonces la IP tomará la dirección opuesta. La IP también se da vuelta cuando llega a callejones sin salida.

A pesar de los dos no-ops ( ") que hacen que el diseño parezca un poco derrochador, estoy bastante contento con esta solución, porque su flujo de control es bastante sutil.

La IP comienza en la esquina superior izquierda a la :derecha. Inmediatamente llegará a un callejón sin salida ?y se dará la vuelta, de modo que el programa realmente comience con este código lineal:

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

Eso significa que ahora tenemos tres copias de nen la pila principal, pero su profundidad es 4. Eso es conveniente porque significa que podemos apilar la profundidad para recuperar el multiplicador actual mientras trabajamos a través de las copias de la entrada.

La IP ahora entra en un bucle 3x3 (en sentido horario). Tenga en cuenta que #, lo que empuja la profundidad de la pila, siempre empujará un valor positivo de modo que sepamos que la IP siempre girará hacia el este en este punto.

El cuerpo del bucle es este:

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

Después de recorrer el bucle (hasta !) tres veces, todas las copias nse agotan y se revela el cero debajo. Debido a la "parte inferior (que de otro modo parece bastante inútil), esta posición es un cruce. Eso significa que con un cero en la parte superior de la pila, el IP intenta ir en línea recta (oeste), pero debido a que hay un muro, en realidad gira 180 grados y se mueve hacia el este como si hubiera tocado un callejón sin salida.

Como resultado, ahora se ejecuta el siguiente bit:

"   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

Banco de pruebas.

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

Gracias a Dennis por un byte!

JavaScript (ES6), 26 bytes

Curiosamente, portar la respuesta Ruby de @ KevinLau o la respuesta Python de @ xnor da como resultado la misma longitud:

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

Tengo una ligera preferencia por el puerto de la respuesta Rubí ya que funciona hasta 2 ⁵³ -3, mientras que el puerto de la respuesta Python sólo funciona hasta 2 ³¹ -5.

C, 50 46 bytes

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

¡Gracias a Neil y nwellnhof por guardar 4 bytes!

Decepcionantemente largo. Siento que hay un truco que cambia un poco aquí y que no conozco, pero aún no puedo encontrarlo. Devuelve un puntero a una matriz que contiene los tres elementos. Programa completo:

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+#iestablece la entrada a 1 + input; Esto se debe a que debemos trabajar en los números estrictamente mayores que la entrada. 234inicializa la cinta con nuestros valores de iteración y 1øsalta al comienzo de la siguiente línea.

2a: bucle

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

i(coloca la entrada en STOS y crea 2[una nueva pila con los 2 elementos principales. ¤duplica la pila y ,hace módulo. Si hay un resto, q!^salga del bucle para ir a (b). De lo contrario, estamos bien para imprimir. $elimina la cosita extra, ]cierra la pila y la æimprime muy bien. l0wq!~termina si la pila contiene cero miembros.

2b: ese otro bucle

          >(1+)31j
        q!^

(1+)agrega 1 al STOS y 31jsalta a la parte del bucle que no toma cosas de la pila. Y lucro.

Ese espacio en blanco extra realmente me está molestando. Toma un GIF.

Retina, 62 43 26 bytes

17 bytes gracias a @Martin Büttner .

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

(Tenga en cuenta la nueva línea final).

Pruébalo en línea!

Entrada en unario 1, salida en unario en 1separado por nuevas líneas.

Versión anterior de 43 bytes:

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

Pruébalo en línea!

Entrada en unario, salida en unario separada por punto y coma ( ;).

Versión anterior de 62 bytes:

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

Pruébalo en línea!

Entrada en unario, salida en unario separada por punto y coma ( ;).

Octava, 27 22 20 bytes

MATLAB y Octave:

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

Mejor (las soluciones son equivalentes, pero una puede superar a la otra cuando se juega más), MATLAB y Octave:

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

Solo en octava:

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

Prueba aquí .

Minkolang 0.15 , 17 bytes

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

Pruébalo aquí!

Explicación

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=?;

Espera Nestar presente en la pila al inicio del programa. Pruébalo en línea!

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}

El caso general produce una respuesta general:

f[r]

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

R, 30 26 bytes

(Reducido 4 bytes gracias a @Neil)

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

Esto (al igual que el resto de las respuestas, supongo) agrega 2: 4 a la entrada y reduce el resto después de ejecutar el módulo en los mismos números.

UGL , 51 31 25 24 bytes

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

Pruébalo en línea!

Versión anterior de 25 bytes:

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

Pruébalo en línea!

Versión anterior de 31 bytes:

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

Pruébalo en línea!

Versión anterior de 51 bytes:

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

Pruébalo en línea!

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*]`

Pruébalo en línea!

Solución alternativa de 22 bytes:

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

Pruébalo en línea!

En realidad, 22 bytes

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

Pruébalo en línea!

Dato curioso: se encontraron y corrigieron 3 errores en el intérprete de Actually al escribir este programa.

Dato no tan divertido: esos 3 errores impidieron que esta solución fuera mucho más corta.

Explicación:

╗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&([*>:@<.@%~)

Pruébalo en línea!