Dê crédito a quem é devido .

Objetivo Dado um número inteiro N > 0, os menores inteiros A, Be, Cde modo que:

1. Todos A, Be Csão estritamente maior que N;
2. 2divide A;
3. 3divide B;
4. e 4divide C.

Este é um código-golfe, então a resposta mais curta em bytes vence. Você pode usar um idioma criado / atualizado após esse desafio, mas é estritamente não competitivo.

Casos de teste

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

Gelatina , 8 bytes

~%2r4¤+‘

Experimente online! ou verifique todos os casos de teste .

Como 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 e 4, aritmética modular para 3.

Encontrei quatro expressões de 7 bytes para o próximo múltiplo kacima, nmas nenhum mais curto:

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

Qualquer um fornece 34 bytes quando copia k=2,3,4e 33 bytes se combinados:

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

Porém, 2 e 4 são potências de 2 que permitem que truques de bits zerem os últimos 1 ou 2 bytes.

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

Isso fornece 6 bytes (em vez de 7) para obter o próximo múltiplo, totalizando 32 bytes, superando o for k in 2,3,4.

Infelizmente, a aparência promissora n|1+1e n|3+1a adição são feitas primeiro, portanto, incrementar a saída leva parênteses.

Julia, 16 bytes

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

Experimente online!

MATL, 15 10 9 bytes

2:4+t5M\-

Experimente online!

Explicação:

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

Usa o algoritmo de Denis Jelly, estou surpreso que seja do mesmo tamanho!

Experimente online ou verifique todos os casos de teste .

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

Outra abordagem ligeiramente diferente

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

05AB1E , 8 bytes

Código:

>D(3L>%+

Experimente online! .

Ruby, 27 bytes

Mapeia 2, 3 e 4 para o próximo múltiplo acima n.

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

CJam, 15 bytes

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

Experimente online! ou verifique todos os casos de teste .

Pyke, 11 9 8 bytes

3FODQRc+

Experimente aqui!

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 é uma função sem nome que recebe um único número inteiro como entrada e retorna uma lista dos múltiplos.

A Ceilingfunção usa um segundo parâmetro opcional que informa para arredondar para o próximo múltiplo do número fornecido. Felizmente, ele também encadeia automaticamente seu segundo argumento, para que possamos fornecer uma lista de valores e, por sua vez, obteremos múltiplos arredondados para todos eles.

Oitava, 20 bytes

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

Exemplos:

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 ressaltar que podemos fazer isso até 9 sem adicionar bytes extras:

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

Saída (2520 é o menor número positivo positivo igualmente divisível por todos os números de um 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]]

Labirinto , 19 bytes

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

Experimente online!

Isso gera os resultados na ordem C, B, Aseparada por alimentações de linha.

Explicação

Como de costume, uma breve cartilha de labirinto:

• O labirinto possui duas pilhas de números inteiros de precisão arbitrária, principal e auxiliar (iliária), que são inicialmente preenchidos com uma quantidade infinita (implícita) de zeros. Usaremos apenas main para esta resposta.
• O código fonte se assemelha a um labirinto, onde o ponteiro de instrução (IP) segue os corredores quando pode (mesmo nos cantos). O código começa no primeiro caractere válido em ordem de leitura, ou seja, no canto superior esquerdo neste caso. Quando o IP chega a qualquer forma de junção (ou seja, várias células adjacentes além daquela de onde veio), ele selecionará uma direção com base no topo da pilha principal. As regras básicas são: vire à esquerda quando negativo, continue em frente quando zero, vire à direita quando positivo. E quando uma dessas opções não for possível porque existe uma parede, o IP seguirá na direção oposta. O IP também muda ao atingir becos sem saída.

Apesar das duas no-ops ( ") que fazem o layout parecer um pouco inútil, estou muito feliz com esta solução, porque seu fluxo de controle é realmente bastante sutil.

O IP começa no canto superior esquerdo à :direita. Ele chegará imediatamente a um beco sem saída ?e será girado, para que o programa realmente comece com esse trecho de código linear:

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

Isso significa que agora temos três cópias nna pilha principal, mas é profundo 4. Isso é conveniente porque significa que podemos usar a profundidade da pilha para recuperar o multiplicador atual enquanto trabalhamos nas cópias da entrada.

O IP agora entra em um loop 3x3 (no sentido horário). Observe que #, o que aumenta a profundidade da pilha, sempre gera um valor positivo, de modo que sabemos que o IP sempre girará para o leste neste momento.

O corpo do loop é 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.

Após o loop ter sido percorrido (até !) três vezes, todas as cópias nsão usadas e o zero abaixo é revelado. Devido à parte "inferior (que de outra forma parece bastante inútil), essa posição é uma junção. Isso significa que, com um zero no topo da pilha, o IP tenta seguir em frente (oeste), mas, como há um muro, ele faz uma curva de 180 graus e volta para o leste como se tivesse atingido um beco sem saída.

Como resultado, o seguinte bit agora é executado:

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

Pitão, 11 10 bytes

m*dh/QdtS4

Suíte de teste.

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

Obrigado ao Dennis por um byte!

JavaScript (ES6), 26 bytes

É interessante portar a resposta Ruby de @ KevinLau ou a resposta Python de @ xnor com o mesmo comprimento:

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

Eu tenho uma ligeira preferência pela porta da resposta Ruby, pois ela funciona até 2 ⁵³ -3, enquanto a porta da resposta Python funciona apenas até 2 ³¹ -5.

C, 50 bytes 46

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

Agradecimentos a Neil e nwellnhof por salvar 4 bytes!

Desapontadoramente longo. Eu sinto que há algum truque de mudança de bits aqui que eu não conheço, mas ainda não consigo encontrá-lo. Retorna um ponteiro para uma matriz que contém os três 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+#idefine a entrada para 1 + input; isso ocorre porque devemos trabalhar com números estritamente maiores que a entrada. 234inicializa a fita com nossos valores de iteração e 1øpula para o início da próxima linha.

2a: loop

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

i(coloca a entrada no STOS e cria 2[uma nova pilha com os 2 principais elementos. ¤duplica a pilha e ,modula. Se houver um restante, q!^interrompa o ciclo para ir para (b). Caso contrário, estamos bem para imprimir. $remove a coisa extra, ]fecha a pilha e a æimprime bem. l0wq!~termina se a pilha não contiver zero membros.

2b: esse outro loop

          >(1+)31j
        q!^

(1+)adiciona 1 ao STOS e 31jsalta para a parte do loop que não tira coisas da pilha. E lucro.

Esse espaço em branco extra está realmente me incomodando. Pegue um GIF.

Retina, 62 43 26 bytes

17 bytes graças a @Martin Büttner .

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

(Observe a nova linha à direita.)

Experimente online!

Entrada em unário 1, saída em unário em 1separado por novas linhas.

Versão anterior de 43 bytes:

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

Experimente online!

Entrada em unário, saída em unário separado por ponto e vírgula ( ;).

Versão anterior de 62 bytes:

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

Experimente online!

Entrada em unário, saída em unário separado por ponto e vírgula ( ;).

Oitava, 27 22 20 bytes

MATLAB e oitava:

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

Melhor (as soluções são equivalentes, mas uma pode superar a outra quando jogar mais golfe), MATLAB e Octave:

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

Somente na oitava:

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

Tente aqui .

Referência 0.15 , 17 bytes

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

Experimente aqui!

Explicação

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 na pilha no início do programa. Experimente 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}

O caso geral produz uma resposta geral:

f[r]

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

R, 30 26 bytes

(Redução de 4 bytes graças a @Neil)

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

Isso (da mesma forma que o restante das respostas, eu acho) adiciona 2: 4 à entrada e reduz o restante depois de executar o módulo nos mesmos números.

UGL , 51 31 25 24 bytes

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

Experimente online!

Versão anterior de 25 bytes:

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

Experimente online!

Versão anterior de 31 bytes:

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

Experimente online!

Versão anterior de 51 bytes:

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

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

Experimente online!

Solução alternativa de 22 bytes:

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

Experimente online!

Na verdade, 22 bytes

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

Experimente online!

Curiosidade: 3 bugs no intérprete do Actually foram encontrados e corrigidos ao escrever este programa.

Fato não tão divertido: Esses 3 erros impediram que esta solução fosse muito mais curta.

Explicação:

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

Experimente online!