Dados dos enteros positivos, A y B, ilustran su mínimo común múltiplo generando dos líneas de guiones ( -
) con LCM de longitud (A, B) después de reemplazar cada guión Ath en la primera línea y cada guión Bth en la segunda línea con barras verticales ( |
)
De esta manera, el final de cada línea será el único lugar donde se |
alinean dos.
Por ejemplo, si A = 6 y B = 4, LCM (6, 4) = 12, entonces:
two lines of 12 dashes: ------------ ------------ replace every 6th dash in the first line with a vertical bar: -----|-----| ------------ replace every 4th dash in the second line with a vertical bar: -----|-----| ---|---|---|
Por lo tanto, el resultado final sería
-----|-----| ---|---|---|
El orden de los números de entrada debe corresponder al orden de las líneas.
El código más corto en bytes gana.
Casos de prueba
A B
line for A
line for B
1 1
|
|
1 2
||
-|
2 1
-|
||
2 2
-|
-|
6 4
-----|-----|
---|---|---|
4 6
---|---|---|
-----|-----|
2 3
-|-|-|
--|--|
3 2
--|--|
-|-|-|
3 6
--|--|
-----|
2 5
-|-|-|-|-|
----|----|
4 3
---|---|---|
--|--|--|--|
10 10
---------|
---------|
10 5
---------|
----|----|
10 6
---------|---------|---------|
-----|-----|-----|-----|-----|
24 8
-----------------------|
-------|-------|-------|
7 8
------|------|------|------|------|------|------|------|
-------|-------|-------|-------|-------|-------|-------|
6 8
-----|-----|-----|-----|
-------|-------|-------|
13 11
------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|
----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|
Respuestas:
Python 3, 80 bytes
Ahorré 1 byte gracias a Halvard Hummel y 1 byte gracias a Jonathan Allan.
¡Pruébalo en línea!
¡Pruébalo en línea! (82 bytes - respuesta inicial)
Esto es lo mejor que podría hacer en Python 2 (81 bytes). Parece que no puedo comentar sobre esa respuesta, solo publicaré esto aquí:
¡Pruébalo en línea!
¡Primer intento aquí, probablemente subóptimo!
fuente
Haskell , 57 bytes
Pruébalo en línea!
fuente
0^0=1
truco antes - inteligenteJalea , 12 bytes
Pruébalo en línea!
fuente
MATL ,
1615 bytesLa entrada es un vector de columna con los dos números. Pruébalo en línea!
Como beneficio adicional, la entrada puede contener más de dos números . Pruébalo en línea!
Explicación
fuente
He
?[1; 1]
, debido a cómo MATL (AB) maneja la forma de la matriz con la indexación. (Alternativamente, la transposición podría reemplazarseHe
al final, por lo que inicialmente estaba allí)R ,
109105bytesPruébalo en línea!
Función anónima. Calcula
l=lcm(a,b)
, a continuación, genera un intervalo de0
al
pora
, a continuación, a partirl
de2*l
porb
, el establecimiento de los índices para|
impresión y como una matriz conl
columnas.fuente
Python 2 , 66 bytes
Pruébalo en línea!
fuente
C, 72 bytes
fuente
Casco , 12 bytes
Pruébalo en línea!
Sí, hay un mcm incorporado en Husk. No, no lo necesito.
Bonificación: funciona con cualquier cantidad de valores de entrada
Explicación
fuente
Mathematica, 63 bytes
Pruébalo en línea!
y otra versión que user202729 realmente quiere ver publicada
Mathematica, 59 bytes
este usa un caracter especial
\[Divides]
∣
fuente
\[Divides]
lugar delMod
operador para representar la divisibilidad, lo que ahorra 4 bytes. También Mathics TIO no debe imprimir el{Null, Null}
.05AB1E , 13 bytes
Utiliza la codificación 05AB1E . Pruébalo en línea!
fuente
.¿Lε²¹‚%_„-|è}øJ»
.APL (Dyalog) , 22 bytes
Asume
⎕IO←0
. Toma A, B como argumento correcto. Bonificación: maneja la lista de entrada de cualquier longitud.Pruébalo en línea!
{
...}
lambda anónimo donde⍵
representa el argumento correcto'|-'[
...]
indexe la cadena con:∧/
LCM a través de la entrada⍳
primero que muchos dedos (0 a N-1)⍵∘.|
tabla de resto de división con la entrada vertical y horizontalmente×
signum⌽
voltear horizontalmentefuente
⎕IO←0
, ya que ese es el valor predeterminado allí.Octava ,
4638 bytes-8 bytes gracias a varias sugerencias de Luis Mendo
Pruébalo en línea!
fuente
JavaScript (ES6), 69 bytes
Se ejecuta recursivamente hasta que
A
sea divisible por ambosa
yb
, generando un guión o una tubería en función dea
la divisibilidad porA
.La función se llama a sí misma, intercambiando
a
yb
.La
S
variable evita que la función se llame a sí misma infinitamente.Casos de prueba:
Mostrar fragmento de código
Respuestas anteriores:
JavaScript (ES8), 91 bytes
Utiliza los algoritmos:
Se llama recursivamente solo una vez para generar la segunda línea.
Casos de prueba:
Mostrar fragmento de código
JavaScript (ES6), 93 bytes
Mismo algoritmo que antes, usando en
repeat
lugar depadStart
.fuente
padStart
era ES8?f=(a,b,A=1)=>(A%a?'-':'|')+(A%a|A%b?f(a,b,A+1):a<0?'':`\n`+f(-b,a))
Scala, 98 bytes
Pruébalo en línea
fuente
*(a-1)
estar Jugamos al golf a*~-a
y*(b-1)
a*~-b
? Además, ¿podría agregar un enlace TIO con el código de prueba? (Ah, y ese avatar no me parece muy cúbico.; P)*~-a
es grande, pero por desgracia Scala requiere más soportes:*(~(-a))
dejar claro que las concatenaciones*~-
,*~
,~-
no son nombres de funciones de fantasía. Agregué un enlace TIO.~-
pueden ser nombres de funciones en Scala. Recuerdo que alguien mencionó eso antes hace bastante tiempo. Eso es lamentable con respecto al golf. Nuevamente bienvenido, y buena primera respuesta.Java (OpenJDK 8) , 103 bytes
Pruébalo en línea!
110 bytes, n valores de entrada
Pruébalo en línea!
fuente
Java 8,
125118117 bytes-7 bytes gracias a @Nevay .
-1 byte comenzando con una nueva línea final (
A="",B="\n"
reemplazada porA="\n",B=A
).Explicación:
Pruébalo aquí.
fuente
a->b->{String A="",B="\n",k="|";for(int i=0;!A.endsWith(k)|!B.endsWith(k);B+=i%b<1?k:"-")A+=++i%a<1?k:"-";return A+B;}
!A.endsWith(t)|!B.endsWith(t)
cuando estaba buscando una forma corta de verificar si ambos terminan con|
... Y comenzar B con una nueva línea en lugar de ponerla entre ellos en el regreso también es inteligente.Python 2 ,
9688 bytesEditar: Guardado 4 bytes gracias a @Leaky Nun
Editar: Guardado 4 bytes gracias a @Rod
Pruébalo en línea!
fuente
[...]
con'\n'.join(...)
para arreglar.Python 2 , 89 bytes
No es la entrada más corta de Python 2, sino un enfoque diferente al
gcd
que aún puede ser golfable.Pruébalo en línea!
fuente
Haskell ,
6660 bytesPruébalo en línea!
Mismo largo:
Vieja solución:
fuente
'\n':
.C (gcc) ,
12199939289 bytesEsto debería ser mucho más corto, hmmmm ...
Pruébalo en línea!
fuente
J , 20 bytes
Pruébalo en línea!
fuente
SOGL V0.12 ,
1916 bytesPruébalo aquí!
Explicación:
fuente
Apilado ,
4238 bytesPruébalo en línea!
Entrada en forma de un par de números. Todos los casos de prueba juntos se parecen a los edificios.
Explicación
Este primero toma el
lcm
de los dos números de entradaz
. Luego, para cada númerok
, generamosz / k
cadenas de-
longitudk - 1
, agregando|
al final de cada una y generando cada una.Intentos contados anteriores
42 bytes:
[:...lcm@z:[:z\/\#-'-'*\rep'|'+''#`out]"!]
Otros intentos
43 bytes:
[:...lcm@z:[:z\/\#-'-'*\rep'|'#`'|'+out]"!]
45 bytes:
['@lcm'!#~@z,[:z\/\#-'-'*\rep'|'#`'|'+out]"!]
45 bytes:
[:...lcm@x[x'-'*\#<$betailmap'|'#`'|'+out]"!]
53 bytes:
[:...lcm'-'*@z#-'.'*'('\+')'+'.'+[z\'$1|'repl out]"!]
54 bytes:
[:...lcm@x{!x'-'*('('n#-'.'*').')''#`'$1|'repl out}"!]
fuente
JavaScript (ES6), 89
Evaluación de la LCM con adicciones repetidas.
Menos golf
Prueba
fuente
VBA (Excel),
144142 bytes-2 bytes. gracias Sir Washington Guedes.
fuente
Ruby ,
6457 bytes-7 bytes gracias a G B.
Pruébalo en línea!
fuente
Carbón ,
323029 bytesPruébalo en línea! El enlace es a la versión detallada del código. Editar: guardado 1 byte gracias a @ ASCII-only.
fuente
Hojas de cálculo de Google, 77 bytes
Fórmula de hoja de trabajo anónima que toma entradas del rango
A1:B1
y salidas a la celda que llama-4 Bytes gracias a @EngineerToast
fuente
LCM(A1,B1)
a soloLCM(1:1)
para guardar 4 bytes. Creo que es razonable suponer una hoja de inicio en blanco y especificar dónde están las entradas y la fórmula.Excel VBA, 79 bytes
Función de ventana inmediata anónima de VBE que toma la entrada del rango
[A1:B1]
y emite una visualización de su LCM a la ventana inmediata de VBE.Este es un puerto de mi respuesta de Google Sheets .
fuente
Japt , 12 bytes
Intérprete Japt
Entradas como una matriz de números. Salidas como un conjunto de cadenas. El indicador -R mejora ligeramente el aspecto de la salida, pero no es necesario para la lógica.
Explicación:
Gracias adicionales a Shaggy por encontrar algunos bytes para guardar.
fuente