Ziemlich einfache Herausforderung heute:

Schreiben Sie ein Programm oder eine Funktion, die eine positive ganze Zahl N aufnimmt und eine sortierte Liste der in der Multiplikationstabelle angezeigten eindeutigen Zahlen ausgibt oder zurückgibt, deren Zeilen- und Spaltenmultiplikanden beide im Bereich von 1 bis einschließlich N liegen.

Die Liste kann in aufsteigender Reihenfolge (kleinste bis größte) oder absteigender Reihenfolge (größte bis kleinste) sortiert und in jedem vernünftigen Format ausgegeben werden.

Der kürzeste Code in Bytes gewinnt!

Beispiel

Wenn N = 4 ist, sieht die Multiplikationstabelle folgendermaßen aus:

   1  2  3  4
  -----------
1| 1  2  3  4
 |
2| 2  4  6  8
 |
3| 3  6  9 12
 |
4| 4  8 12 16

Die eindeutigen Nummern in der Tabelle sind 1, 2, 3, 4, 6, 8, 9, 12, 16. Diese sind also schon sortiert

1, 2, 3, 4, 6, 8, 9, 12, 16

könnte Ihre genaue Ausgabe für N = 4 sein. Da die Sortierung jedoch umgekehrt werden kann und die Formatierung etwas Spielraum bietet, wären dies auch gültige Ausgaben:

[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

Testfälle

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

Probieren Sie es online aus.

Erklärung: SQNimmt die ausgewertete Listeneingabe ( Q) und erstellt eine Liste [1, 2, ..., Q]. ^SQ2nimmt das kartesische Produkt dieser Liste mit - alle möglichen Produktkombinationen. *MMultipliziert alle diese Paare, um alle möglichen Ergebnisse in der Multiplikationstabelle zu bilden, S{macht sie eindeutig und sortiert sie.

Python 2, 61 51 Bytes

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

Vielen Dank an xnor für die Kürzung der Syntax.

APL, 18 16 Bytes

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

Dies ist eine unbenannte monadische Funktion. Die Ausgabe erfolgt in aufsteigender Reihenfolge.

Erläuterung:

             ⍳⍵]}   ⍝ 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

Problem behoben und 2 Bytes dank Thomas Kwa gespeichert!

CJam, 14 12 Bytes

Neueste Version mit von @aditsu vorgeschlagenen Verbesserungen:

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

Dies ist eine anonyme Funktion. Probieren Sie es online aus , mit Eingabe- / Ausgabe-Code, der zum Testen benötigt wird.

@Martin schlug eine andere sehr elegante Lösung ( {,:)_ff*:|$}) mit der gleichen Länge vor. Ich habe das von aditsu verwendet, da es meiner ursprünglichen Lösung viel ähnlicher war.

Der Hauptunterschied zu meiner ursprünglichen Lösung besteht darin, dass dadurch der 0Wert in der ursprünglichen Reihenfolge beibehalten wird, wodurch am Anfang 2 Bytes gespart werden. Sie würden denken, dass dies nicht helfen würde, weil Sie den 0Wert aus dem Ergebnis entfernen müssen . Aber der Kern von @aditsus Idee ist 0^das Ende, was ein fester Unterschied zu ist 0. Dies entfernt die 0und eliminiert gleichzeitig, da es sich um eine Mengenoperation handelt, doppelte Elemente aus der Lösungsmenge. Da ich bereits 2 Bytes benötigt habe, um die Duplikate zu entfernen, ist das Entfernen 0dann im Wesentlichen kostenlos.

Erläuterung:

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

Oktave, 22 Bytes

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

Julia, 24 Bytes

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

Dies ist eine anonyme Funktion, die eine Ganzzahl akzeptiert und ein Ganzzahl-Array zurückgibt.

Ungolfed:

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

danke an @Dennis für das Speichern von 30 (!) Bytes

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

Erklärung / ungolfed:

(                      # 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)

Dies funktioniert in Bash nicht, da Bash nicht erweitert wird {1..$1}- es wird nur wörtlich interpretiert (also a=5; echo {1..$a}Ausgaben {1..5}statt 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}

Ungolfed:

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

Multiplizieren Sie mit der verschachtelten Schleife jede Zahl mit jeder anderen Zahl bis zu n, und sortieren Sie dann das Array.

50 Bytes

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

Verwendung:

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

Dies liest eine Ganzzahl von STDIN und schreibt eine durch Leerzeichen getrennte Liste nach STDOUT.

Wir erstellen die Multiplikationstabelle als Matrix mit outer, glätten sie implizit in einen Vektor und sortieren mit sort, wählen eindeutige Elemente mit uniqueund drucken den durch begrenzten Raum mit cat.

Mathematica, 25 Bytes

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

K, 17 Bytes

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

Hier gibt es nicht viel zu sagen. Sortieren ( t@<t:) Sie die eindeutigen Elemente ( ?) des abgeflachten ( ,/) multiplizierten kartesischen Eigenprodukts ( t*\:t:) von 1 bis einschließlich N ( 1+!).

In Aktion:

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

Anwendungsbeispiel: f 4-> [1,2,3,4,6,8,9,12,16].

nub Entfernt doppelte Elemente aus einer Liste.

Edit: @Zgarb hat einen überflüssigen gefunden $.

J, 21-20 Bytes

Danke an @Zgarb für -1 Byte!

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

Meine erste Antwort! Golftipps sind erwünscht, wenn es etwas zum Golfen gibt.

Dies ist eine monadische Funktion; Wir nehmen das äußere Produkt durch Multiplikation der Liste 1..inputmit sich selbst, reduzieren, nehmen eindeutige Elemente und sortieren.

Kotlin, 70 Bytes

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

Ungolfed-Version:

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

Teste es mit:

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

Shell + gemeinsame Dienstprogramme, 41

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

Oder alternativ:

Bash + Coreutils, 48

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

Konstruiert eine geschweifte Klammer innerhalb einer arithmetischen Erweiterung:

\$[{1..n}*{1..n}]erweitert sich auf die arithmetischen Erweiterungen, $[1*1] $[1*2] ... $[1*n] ... $[n*n]die ausgewertet und an übergeben werden printf, wodurch eine pro Zeile ausgegeben wird, an die weitergeleitet wird sort.

Sorgfältige Verwendung von Anführungszeichen, Escape-Zeichen und evalSicherstellung, dass die Erweiterungen in der erforderlichen Reihenfolge erfolgen.

Oder alternativ:

Pure Bash, 60

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

Pyth, 10

S{m*Fd^SQ2

Probieren Sie es online aus oder führen Sie eine Testsuite aus

Minkolang 0.14 , 25 22 18 Bytes

Ich erinnerte mich, dass ich kartesische Produkte sehr bequem implementiert hatte, bevor diese Frage gestellt wurde !

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

Probieren Sie es hier aus. (Ausgänge in umgekehrter Reihenfolge.)

Erläuterung

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 bis 90 Byte

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)`)

Erläuterung

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
`)

Prüfung

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

Anwendungsbeispiel:

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

Ziemlich langweilig. Filtert einfach die Liste [1..n*n]nach den Elementen des Formulars a*bmit aund bin [1..n]. Verwenden filterergibt die gleiche Länge

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

Ich habe eine Weile versucht, die Liste der Produkte mit etwas Klügerem wie concatMapoder zu generieren mapM, habe aber nur längere Ergebnisse erzielt. Eine komplexere Überprüfung der Mitgliedschaft ergab 52 Bytes, 1 Byte länger, kann aber möglicherweise verkürzt werden.

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

Ungolfed

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

Dies ähnelt der Julia-Antwort. Vielen Dank an @Maltysen

PHP, 74,73 70 Bytes

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

Ungolfed:

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

Bisherige:

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

Nicht 100% sicher, was mit der Ausgabe geschehen soll, $aenthält aber ein Array mit den entsprechenden Zahlen. $nist die Nummer geven via $_GET['n'], mitregister_globals=1

TeaScript , 37 35 Zeichen; 40 Bytes

2 Bytes dank @Downgoat gespart

TeaScript ist JavaScript zum Golfen.

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

Probieren Sie es online!

Ungolfed und Erklärung

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

Dies druckt die Zahlen in absteigender Reihenfolge. Vorschläge sind willkommen, da dies alles andere als optimal aussieht.

JavaScript (ES6), 86 Byte

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}

Versuchen Sie es zu verkürzen (vielleicht versuchen Sie es mit Schachtelschleifen).

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";

wird ausgeführt, indem das Argument in der Befehlszeile übergeben wird. Es gibt eine ganze Reihe von Erklärungen, die mit Einschränkungen und Warnungen einhergehen.

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

Pythonischer!

Perl 5, 67 Bytes

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