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]

Pyth, 8 bytes

S{*M^SQ2

Pruébalo en línea.

Explicación: SQtoma la entrada de la lista evaluada ( Q) y hace una lista [1, 2, ..., Q]. ^SQ2toma el producto cartesiano de esa lista consigo mismo: todas las combinaciones de productos posibles. *Mmultiplica todos estos pares para formar todos los resultados posibles en la tabla de multiplicación y lo S{hace único y lo ordena.

Python 2, 61 51 bytes

lambda n:sorted({~(i%n)*~(i/n)for i in range(n*n)})

Gracias a xnor por acortar algo de sintaxis.

APL, 18 16 bytes

{y[⍋y←∪,∘.×⍨⍳⍵]}

Esta es una función monádica sin nombre. La salida está en orden ascendente.

Explicación:

             ⍳⍵]}   ⍝ Get the integers from 1 to the input
         ∘.×⍨       ⍝ Compute the outer product of this with itself
        ,           ⍝ Flatten into an array
       ∪            ⍝ Select unique elements
     y←             ⍝ Assign to y
 {y[⍋               ⍝ Sort ascending

¡Se solucionó un problema y se guardaban 2 bytes gracias a Thomas Kwa!

CJam, 14 12 bytes

Última versión con mejoras propuestas por @aditsu:

{)2m*::*0^$}

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 0valor en la secuencia original, lo que ahorra 2 bytes al inicio. Pensarías que esto no ayudaría, porque debes eliminar el 0valor del resultado. Pero el núcleo de la idea de @ aditsu es 0^el final, que es una diferencia establecida con 0. Esto elimina 0y, 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, eliminarlos 0es esencialmente gratis.

Explicación:

{     Start anonymous function.
  )     Increment to get N+1.
  2m*   Cartesian power, to get all pairs of numbers in range [0, N].
  ::*   Reduce all pairs with multiplication.
  0^    Remove 0, and remove duplicates at the same time since this is a set operation.
  $     Sort the list.
}     End anonymous function.

Octava, 22 bytes

@(n)unique((a=1:n)'*a)

Julia, 24 bytes

n->sort(∪((x=1:n)*x'))

Esta es una función anónima que acepta un número entero y devuelve una matriz entera.

Sin golf:

function f(n::Integer)
    # Construct a UnitRange from 1 to the input
    x = 1:n

    # Compute the outer product of x with itself
    o = x * transpose(x)

    # Get the unique elements, implicitly flattening
    # columnwise into an array
    u = unique(o)

    # Return the sorted output
    return sort(u)
end

MATLAB, 24 bytes

@(n)unique((1:n)'*(1:n))

zsh, 86 56 bytes

gracias a @Dennis por guardar 30 (!) bytes

(for a in {1..$1};for b in {1..$1};echo $[a*b])|sort -nu

Explicación / sin golf:

(                      # begin subshell
  for a in {1..$1}     # loop through every pair of multiplicands
    for b in {1..$1}
      echo $[a*b]      # calculate a * b, output to stdout
) | sort -nu           # pipe output of subshell to `sort -nu', sorting
                       # numerically (-n) and removing duplicates (-u for uniq)

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 de 1 2 3 4 5).

Ruby, 50 48 bytes

->n{c=*r=1..n;r.map{|i|c|=r.map{|j|i*j}};c.sort}

Sin golf:

->n {
  c=*r=1..n
  r.map { |i| c|=r.map{|j|i*j} }
  c.sort
}

Usando el bucle anidado para multiplicar cada número con cualquier otro número hasta ny luego ordenando la matriz.

50 bytes

->n{r=1..n;r.flat_map{|i|r.map{|j|i*j}}.uniq.sort}

Uso:

->n{c=*r=1..n;r.map{|i|c|=r.map{|j|i*j}};c.sort}[4]
=> [1, 2, 3, 4, 6, 8, 9, 12, 16]

R, 39 bytes

cat(unique(sort(outer(n<-1:scan(),n))))

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 usando sort, seleccionar elementos únicos usando uniquee imprimir espacio delimitado usando cat.

Mathematica, 25 bytes

Union@@Array[1##&,{#,#}]&

K, 17 bytes

t@<t:?,/t*\:t:1+!

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:

  t@<t:?,/t*\:t:1+!5
1 2 3 4 5 6 8 9 10 12 15 16 20 25

Haskell, 55 54 bytes

import Data.List
f n=sort$nub[x*y|x<-[1..n],y<-[1..x]]

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

J, 21 20 bytes

¡Gracias a @Zgarb por -1 byte!

/:~@~.@,@(1*/~@:+i.)

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..inputconsigo mismo, aplanamos, tomamos elementos únicos y ordenamos.

Kotlin, 70 bytes

val a={i:Int->(1..i).flatMap{(1..i).map{j->it*j}}.distinct().sorted()}

Versión sin golf:

val a: (Int) -> List<Int> = { 
    i -> (1..i).flatMap{ j -> (1..i).map{ k -> j * k } }.distinct().sorted()
}

Pruébalo con:

fun main(args: Array<String>) {
    for(i in 1..12) {
        println(a(i))
    }
}

Shell + utilidades comunes, 41

seq -f"seq -f%g*%%g $1" $1|sh|bc|sort -nu

O alternativamente:

Bash + coreutils, 48

eval printf '%s\\n' \$[{1..$1}*{1..$1}]|sort -nu

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 a printf, que imprime una por línea, a la que se canaliza sort.

Uso cuidadoso de citas, escapes y evalasegurar que las expansiones sucedan en el orden requerido.

O alternativamente:

Pure Bash, 60

eval a=($(eval echo [\$[{1..$1}*{1..$1}\]]=1))
echo ${!a[@]}

Pyth, 10

S{m*Fd^SQ2

Pruébelo en línea o ejecute un conjunto de pruebas

Minkolang 0.14 , 25 22 18 bytes

¡Recordé que implementé productos cartesianos muy convenientemente antes de que se publicara esta pregunta !

1nLI20P[x*1R]sS$N.

Pruébalo aquí. (Salidas en orden inverso).

Explicación

1                     Push a 1 onto the stack
 n                    Take number from input (n)
  L                   Pushes 1,2,...,n onto the stack
   I                  Pushes length of stack so 0P knows how many items to pop
    2                 Pushes 2 (the number of repeats)
     0P               Essentially does itertools.product(range(1,n+1), 2)
       [              Open for loop that repeats n^2 times (0P puts this on the stack)
        x             Dump (I know each product has exactly two numbers
         *            Multiply
          1R          Rotate 1 step to the right
            ]         Close for loop
             s        Sort
              S       Remove duplicates ("set")
               $N.    Output whole stack as numbers and stop.

JavaScript (ES6), 92 90 bytes

n=>eval(`for(r=[],a=n;a;a--)for(b=n;b;)~r.indexOf(x=a*b--)||r.push(x);r.sort((a,b)=>a-b)`)

Explicación

n=>eval(`                 // use eval to remove need for return keyword
  for(r=[],a=n;a;a--)     // iterate for each number a
    for(b=n;b;)           // iterate for each number b
      ~r.indexOf(x=a*b--) // check if it is already in the list, x = value
      ||r.push(x);        // add the result
  r.sort((a,b)=>a-b)      // sort the results by ascending value
                          // implicit: return r
`)

Prueba

N = <input type="number" oninput="result.innerHTML=(

n=>eval(`for(r=[],a=n;a;a--)for(b=n;b;)~r.indexOf(x=a*b--)||r.push(x);r.sort((a,b)=>a-b)`)

)(+this.value)" /><pre id="result"></pre>

Perl 6 , 27 bytes

{squish sort 1..$_ X*1..$_} # 27
{unique sort 1..$_ X*1..$_} # 27
{sort unique 1..$_ X*1..$_} # 27

Ejemplo de uso:

say {squish sort 1..$_ X*1..$_}(3); # (1 2 3 4 6 9)␤

my $code = {squish sort 1..$_ X*1..$_}

for 1..100 -> \N { say $code(N) }

my &code = $code;

say code 4; # (1 2 3 4 6 8 9 12 16)␤

Haskell, 51 bytes

f n=[i|i<-[1..n*n],elem i[a*b|a<-[1..n],b<-[1..n]]]

Bastante aburrido. Simplemente filtra la lista [1..n*n]a los elementos del formulario a*bcon ay ben [1..n]. Utilizandofilter da la misma longitud

f n=filter(`elem`[a*b|a<-[1..n],b<-[1..n]])[1..n*n]

Intenté durante un tiempo generar la lista de productos con algo más inteligente como concatMapo mapM, 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.

f n=[k|k<-[1..n*n],any(\a->k`mod`a<1&&k<=n*a)[1..n]]

JAVA - 86 bytes

Set a(int a){Set s=new TreeSet();for(;a>0;a--)for(int b=a;b>0;)s.add(a*b--);return s;}

Sin golf

Set a(int a){
    Set s = new TreeSet();
    for (;a>0;a--){
        for(int b = a;b>0;){
            s.add(a*b--);
        }
    }
    return s;
}

Pyth, 11 bytes

S{sm*RdSdSQ

Esto es similar a la respuesta de Julia. Gracias a @Maltysen

PHP, 74,73 70bytes

while($i++<$j=$n)while($j)$a[]=$i*$j--;$a=array_unique($a);sort($a);

print_r($a); // Not counted, but to verify the result

Sin golf:

while($i++<$j=$n)
    while($j)
        $a[]=$i*$j--;

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 $acontiene una matriz con los números correspondientes. $nes el número geven vía $_GET['n'], conregister_globals=1

TeaScript , 37 35 caracteres; 40 bytes

Guardado 2 bytes gracias a @Downgoat

TeaScript es JavaScript para jugar al golf.

(b+r(1,+x¬)ßam(z=>z*l±s`,`.u¡s»l-i)

Pruébalo en línea!

Sin golfos y explicación

(b+r(1,+x+1)m(#am(z=>z*l)))s(',').u()s(#l-i)
              // Implicit: x = input number
r(1,+x+1)     // Generate a range of integers from 1 to x.
m(#           // Map each item "l" in this range "a" to:
 am(z=>       //  a, with each item "z" mapped to
  z*l))       //   z * l.
(b+      )    // Parse this as a string by adding it to an empty string.
s(',')        // Split the string at commas, flattening the list.
.u()          // Take only the unique items from the result.
s(#l-i)       // Sort by subtraction; the default sort sorts 10, 12, 100, etc. before 2.
              // Implicit: output last expression

C, 96 bytes

i,a[1<<16];main(n){for(scanf("%d",&n);i<n*n;a[~(i%n)*~(i++/n)]="%d ");while(i)printf(a[i--],i);}

Esto imprime los números en orden descendente. Las sugerencias son bienvenidas ya que esto parece lejos de ser óptimo.

JavaScript (ES6), 86 bytes

n=>{n++;a=[];for(j=1;j<n;j++)for(i=1;i<n;i++)if(a.indexOf(i*j)<0)a.push(i*j);return a}

Buscando acortarlo (tal vez intente anidar bucles).

Perl 5, 91 bytes

for my $y (1 .. $ARGV[0]){
    map {$s{$n}++ unless($s{$n=$y*$_}) } ($y .. $ARGV[0])
}
print join(" ", sort {$a<=>$b} keys %s) . "\n";

para ejecutarse pasando el argumento en la línea de comando. Son pocas las declaraciones que faltan con restricciones y advertencias.

Python, 124 102 bytes

n=input()
l=[1]
for i in range(1,n+1):
 for j in range(1,n+1):l.append(i*j)
print sorted(list(set(l)))

Más pitón!

Perl 5, 67 bytes

for$i(1..($n=pop)){$a{$_*$i}++for 1..$n}map say,sort{$a<=>$b}keys%a