Desafío bastante simple hoy:
Escriba un programa o función que tome un entero positivo N e imprima o devuelva una lista ordenada de los números únicos que aparecen en la tabla de multiplicación cuyos multiplicandos de fila y columna varían de 1 a N inclusive.
La lista se puede ordenar en orden ascendente (de menor a mayor) o en orden descendente (de mayor a menor), y se puede generar en cualquier formato razonable.
¡El código más corto en bytes gana!
Ejemplo
Cuando N = 4, la tabla de multiplicar se ve así:
1 2 3 4
-----------
1| 1 2 3 4
|
2| 2 4 6 8
|
3| 3 6 9 12
|
4| 4 8 12 16
Los números únicos en la tabla son 1, 2, 3, 4, 6, 8, 9, 12, 16
. Estos ya están ordenados, así que
1, 2, 3, 4, 6, 8, 9, 12, 16
podría ser su salida exacta para N = 4. Pero dado que la clasificación se puede revertir y hay un margen de maniobra en el formato, estas también serían salidas válidas:
[16,12,9,8,6,4,3,2,1]
1
2
3
4
6
8
9
12
16
16 12 9 8 4 3 2 1
Casos de prueba
N=1 -> [1]
N=2 -> [1, 2, 4]
N=3 -> [1, 2, 3, 4, 6, 9]
N=4 -> [1, 2, 3, 4, 6, 8, 9, 12, 16]
N=5 -> [1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 20, 25]
N=6 -> [1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20, 24, 25, 30, 36]
N=7 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 24, 25, 28, 30, 35, 36, 42, 49]
N=8 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 24, 25, 28, 30, 32, 35, 36, 40, 42, 48, 49, 56, 64]
N=9 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 24, 25, 27, 28, 30, 32, 35, 36, 40, 42, 45, 48, 49, 54, 56, 63, 64, 72, 81]
N=10 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 24, 25, 27, 28, 30, 32, 35, 36, 40, 42, 45, 48, 49, 50, 54, 56, 60, 63, 64, 70, 72, 80, 81, 90, 100]
N=11 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 27, 28, 30, 32, 33, 35, 36, 40, 42, 44, 45, 48, 49, 50, 54, 55, 56, 60, 63, 64, 66, 70, 72, 77, 80, 81, 88, 90, 99, 100, 110, 121]
N=12 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 27, 28, 30, 32, 33, 35, 36, 40, 42, 44, 45, 48, 49, 50, 54, 55, 56, 60, 63, 64, 66, 70, 72, 77, 80, 81, 84, 88, 90, 96, 99, 100, 108, 110, 120, 121, 132, 144]
fuente
Respuestas:
Pyth, 8 bytes
Pruébalo en línea.
Explicación:
SQ
toma la entrada de la lista evaluada (Q
) y hace una lista[1, 2, ..., Q]
.^SQ2
toma el producto cartesiano de esa lista consigo mismo: todas las combinaciones de productos posibles.*M
multiplica todos estos pares para formar todos los resultados posibles en la tabla de multiplicación y loS{
hace único y lo ordena.fuente
M
. +1Python 2,
6151 bytesGracias a xnor por acortar algo de sintaxis.
fuente
set(...)
puede ser simplemente un conjunto de compilación{...}
. Además, las funciones están permitidas de forma predeterminada aquí, por lo que puede escribirlambda n:...
.f=lambda n:n*[0]and sorted(set(range(n,n*n+n,n)+f(n-1)))
.APL,
1816 bytesEsta es una función monádica sin nombre. La salida está en orden ascendente.
Explicación:
¡Se solucionó un problema y se guardaban 2 bytes gracias a Thomas Kwa!
fuente
CJam,
1412 bytesÚltima versión con mejoras propuestas por @aditsu:
Esta es una función anónima. Pruébelo en línea , con el código de entrada / salida necesario para probarlo.
@ Martin propuso otra solución muy elegante (
{,:)_ff*:|$}
) con la misma longitud. Usé el de aditsu porque era mucho más similar a mi solución original.La principal diferencia con mi solución original es que esto mantiene el
0
valor en la secuencia original, lo que ahorra 2 bytes al inicio. Pensarías que esto no ayudaría, porque debes eliminar el0
valor del resultado. Pero el núcleo de la idea de @ aditsu es0^
el final, que es una diferencia establecida con0
. Esto elimina0
y, al mismo tiempo, dado que es una operación de conjunto, elimina elementos duplicados del conjunto de solución. Como ya necesitaba 2 bytes para eliminar los duplicados antes, eliminarlos0
es esencialmente gratis.Explicación:
fuente
{2m*::)::*_&$}
,{)2m*::*_&$0-}
{,:)_ff*:|$}
{)2m*::*0^$}
Octava, 22 bytes
fuente
Julia, 24 bytes
Esta es una función anónima que acepta un número entero y devuelve una matriz entera.
Sin golf:
fuente
MATLAB, 24 bytes
fuente
zsh,
8656 bytesgracias a @Dennis por guardar 30 (!) bytes
Explicación / sin golf:
Esto no funciona en Bash porque Bash no se expande
{1..$1}
, solo lo interpreta literalmente (por lo tanto,a=5; echo {1..$a}
produce salidas en{1..5}
lugar de1 2 3 4 5
).fuente
Ruby,
5048 bytesSin golf:
Usando el bucle anidado para multiplicar cada número con cualquier otro número hasta ny luego ordenando la matriz.
50 bytes
Uso:
fuente
R, 39 bytes
Esto lee un número entero de STDIN y escribe una lista delimitada por espacios en STDOUT.
Creamos la tabla de multiplicar como una matriz usando
outer
, implícitamente aplanar en un vector y ordenar usandosort
, seleccionar elementos únicos usandounique
e imprimir espacio delimitado usandocat
.fuente
Mathematica, 25 bytes
fuente
K, 17 bytes
No hay mucho que decir aquí. Clasifique (
t@<t:
) los elementos únicos (?
) del,/
autoproducto cartesiano aplanado ( ) multiplicado (t*\:t:
) de 1 hasta N (1+!
) incluido .En acción:
fuente
Haskell,
5554 bytesEjemplo de uso:
f 4
->[1,2,3,4,6,8,9,12,16]
.nub
elimina elementos duplicados de una lista.Editar: @Zgarb encontró un superfluo
$
.fuente
J,
2120 bytes¡Gracias a @Zgarb por -1 byte!
Mi primera respuesta J! Los consejos de golf son apreciados, si hay algo para el golf.
Esta es una función monádica; tomamos el producto externo multiplicando la lista
1..input
consigo mismo, aplanamos, tomamos elementos únicos y ordenamos.fuente
Kotlin, 70 bytes
Versión sin golf:
Pruébalo con:
fuente
Shell + utilidades comunes, 41
O alternativamente:
Bash + coreutils, 48
Construye una expansión de llaves dentro de una expansión aritmética:
\$[{1..n}*{1..n}]
se expande a las expansiones aritméticas$[1*1] $[1*2] ... $[1*n] ... $[n*n]
que se evalúan y pasan aprintf
, que imprime una por línea, a la que se canalizasort
.Uso cuidadoso de citas, escapes y
eval
asegurar que las expansiones sucedan en el orden requerido.O alternativamente:
Pure Bash, 60
fuente
Pyth, 10
Pruébelo en línea o ejecute un conjunto de pruebas
fuente
Minkolang 0.14 ,
252218 bytes¡Recordé que implementé productos cartesianos muy convenientemente antes de que se publicara esta pregunta !
Pruébalo aquí. (Salidas en orden inverso).
Explicación
fuente
JavaScript (ES6),
9290 bytesExplicación
Prueba
fuente
Perl 6 , 27 bytes
Ejemplo de uso:
fuente
Haskell, 51 bytes
Bastante aburrido. Simplemente filtra la lista
[1..n*n]
a los elementos del formularioa*b
cona
yb
en[1..n]
. Utilizandofilter
da la misma longitudIntenté durante un tiempo generar la lista de productos con algo más inteligente como
concatMap
omapM
, pero solo obtuve resultados más largos. Una verificación de membresía más sofisticada llegó a 52 bytes, 1 byte más, pero quizás se puede acortar.fuente
(*)<$>..<*>..
como esteJAVA - 86 bytes
Sin golf
fuente
Pyth, 11 bytes
Esto es similar a la respuesta de Julia. Gracias a @Maltysen
fuente
PHP,
74,7370bytesSin golf:
Anterior:
while(($j=$i++)<$n)for(;$j++<$n;)$a[]=$i*$j;$a=array_unique($a);sort($a);
No estoy 100% seguro de qué hacer con la salida, pero
$a
contiene una matriz con los números correspondientes.$n
es el número geven vía$_GET['n']
, conregister_globals=1
fuente
TeaScript ,
3735 caracteres; 40 bytesGuardado 2 bytes gracias a @Downgoat
TeaScript es JavaScript para jugar al golf.
Pruébalo en línea!
Sin golfos y explicación
fuente
r
lugar deA.r
generar rangosC, 96 bytes
Esto imprime los números en orden descendente. Las sugerencias son bienvenidas ya que esto parece lejos de ser óptimo.
fuente
JavaScript (ES6), 86 bytes
Buscando acortarlo (tal vez intente anidar bucles).
fuente
Perl 5, 91 bytes
para ejecutarse pasando el argumento en la línea de comando. Son pocas las declaraciones que faltan con restricciones y advertencias.
fuente
Python,
124102 bytesMás pitón!
fuente
l.append(i*j)
en la misma línea que if condicional. Creo que termina siendo 102 bytes en total.+=
lugar deappend
.list(set(l))
no se garantiza que se resuelva.Perl 5, 67 bytes
fuente