Enteros más pequeños después de N divisible por 2, 3 y 4

22

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
Conor O'Brien
fuente
¿Podemos (consistentemente) generar los resultados en un orden diferente (por ejemplo C B A) si se especifica claramente en la respuesta?
Martin Ender
@ MartinBüttner eso es aceptable
Conor O'Brien

Respuestas:

17

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.
Dennis
fuente
26

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.

xnor
fuente
1
De las posibles variantes, mi preferencia es n+k-n%k.
Neil
¿Hace n&3+1la adición también primero?
Tim
@Tim Yup, lo mismo con todas las operaciones booleanas.
xnor
12

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]
DJMcMayhem
fuente
3
¡Buena respuesta! Puede guardar un byte utilizando 5M(portapapeles automático de entradas de función) en lugar del segundo 2:4.
David
@David ¡Gracias por el consejo!
DJMcMayhem
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
David
fuente
Pues maldita sea. Estaba realmente orgulloso de mi solución de 10 bytes, pero no puedo superar esto. Además, curiosidades divertidas: este es exactamente mi voto número 300. = D
DJMcMayhem
Ahh, pero esto solo estaba tomando el algoritmo de Agawa / Dennis, no es mi propia idea.
David
1
a veces sigo mirando a esos caracteres elementales mandarinoides unicode mientras me rasco la cabeza y luego digo "por el bien de todo lo legible es un código ejecutable bifurcado"? jaja, qué bueno que tenga mi voto a favor + me uniré al tren matl pronto.
Abr001am
@ Agawa001 ¡Deberías! Dado que conoce bien Matlab, debería encontrarlo bastante sencillo, la gran diferencia es que MATL se basa en la pila. ¡También hay una sala de chat MATL si necesita ayuda!
David
@ David que la naturaleza a base de crepes de MAT hace más mal knowignly miedo que el propio Matlab prima es un lenguaje de golf amigable con respecto a su interactability de alto nivel, así que imagina ....
Abr001am
6

Matlab, 33 bytes

Otro enfoque ligeramente diferente

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

05AB1E , 8 bytes

Código:

>D(3L>%+

Pruébalo en línea! .

Adnan
fuente
Ah, no noté que ya había una respuesta 05AB1E que es bastante similar a la que tenía. Lo he eliminado, y lo sugeriré como un -1 golf aquí en su lugar: ±D2xŸ%α( 2xŸes solo una alternativa para usted 3L>; y otras dos alternativas de igual byte podrían ser Ƶ…So 4L¦).
Kevin Cruijssen
5

Rubí, 27 bytes

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

->n{(2..4).map{|e|n+e-n%e}}
Tinta de valor
fuente
4

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+^
Azul
fuente
4

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.

Martin Ender
fuente
4

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
dcsohl
fuente
4

Haskell, 27 bytes

f n=[div n d*d+d|d<-[2..4]]
Michael Klein
fuente
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.
Martin Ender
fuente
3

Matlab, 50 bytes

@(a)arrayfun(@(k)find(~rem(a+1:a+k,k))+a,[2 3 4])
Abr001am
fuente
Como mínimo, puede usar en 2:4lugar de [2 3 4].
Suever
3

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!

Pomo de la puerta
fuente
3

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 53 -3, mientras que el puerto de la respuesta Python sólo funciona hasta 2 31 -5.

Neil
fuente
)-> ]como creo
Qwertiy
@Qwertiy Whoops, perdón por el error tipográfico.
Neil
3

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;
}
DJMcMayhem
fuente
Miré el bit-twiddling de @ xnor, pero debes desenrollar el bucle para lo que termina costando un byte en general.
Neil
¿No da como n + i - n % i++resultado un comportamiento indefinido?
nwellnhof
También s/a[i-2]/*a++/para guardar dos bytes.
nwellnhof
@nwellnhof Bah, pensé en eso cuando desenrollé su bucle, pero no se me ocurrió que podría usarlo de todos modos.
Neil
2
@Neil Pero el comportamiento indefinido se puede solucionar sin agrandar el código. Aquí hay una versión aún más corta que utiliza declaraciones de funciones K&R:f(a,n,i)int*a;{for(i=1;++i<5;)*a++=n+i-n%i;}
nwellnhof
3

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

REENNNNNGGG

Conor O'Brien
fuente
3

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 ( ;).

Monja permeable
fuente
26 si se permite la salida en el orden opuesto: retina.tryitonline.net/… ... De lo contrario, 33 aunque creo que debe haber una forma más corta que evite la clasificación inversa: retina.tryitonline.net/…
Martin Ender
¿Eso es suficiente para calificar como una respuesta separada?
Leaky Nun
No sé, sigue siendo la misma idea, simplemente reemplacé la generación manual de la lista con el uso de coincidencias superpuestas.
Martin Ender
Conor confirmó que la solución de 26 bytes es válida.
Martin Ender
3

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

bers
fuente
Mi respuesta final es, básicamente, que uno aquí :( codegolf.stackexchange.com/a/80028/52795
eros
3

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.
El'endia Starman
fuente
+ es división ??
Downgoat
@Downgoat: Whoops. > _>
El'endia Starman
2

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

DavidC
fuente
2

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.

David Arenburg
fuente
1
Como no sé el idioma, ¿hay alguna razón por la que no lo usas N+2:4-N%%2:4?
Neil
@Neil Porque no lo he pensado, supongo. Gracias sin embargo.
David Arenburg
2

Java 70 57

a->System.out.print(a/2*2+2+" "+(a/3*3+3)+" "+(a/4*4+4))
Con suerte
fuente
No conozco Java, pero tal vez puedas eliminar el espacio =en blanco alrededorint a = new Integer(z[0]);
Conor O'Brien
1

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
Mego
fuente