Bugün oldukça basit bir meydan okuma:

Olumlu bir tamsayı alan ve satır ve sütun çarpanları her ikisi de 1'den N'ye kadar olan çarpım tablosunda görünen benzersiz sayıların sıralanmış bir listesini yazdırır veya döndüren bir program veya işlev yazın .

Liste, artan düzende (en küçükten büyüğe) veya azalan düzende (en büyüğünden en küçüğe) sıralanabilir ve herhangi bir makul biçimde çıkarılabilir.

Bayt cinsinden en kısa kod kazanır!

Örnek

N = 4 olduğunda, çarpım tablosu şöyle görünür:

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

Tablodaki benzersiz sayılardır 1, 2, 3, 4, 6, 8, 9, 12, 16. Bunlar zaten sıralandı, yani

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

N = 4 için kesin çıktınız olabilir. Ancak sıralama tersine çevrilebileceğinden ve biçimlendirmede bazı boşluklar bulunduğundan, bunlar geçerli çıktılar olacaktır:

[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

Test Kılıfları

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 bayt

S{*M^SQ2

Çevrimiçi deneyin.

Açıklama: SQdeğerlendirilen liste girişini ( Q) alır ve bir liste yapar [1, 2, ..., Q]. ^SQ2O listenin Kartezyen ürününü kendisi ile birlikte alır - tüm olası ürün kombinasyonları. *Mçarpım tablosundaki tüm olası sonuçları oluşturmak için tüm bu çiftleri bir araya S{getirir ve benzersiz kılar ve sıralar.

Python 2, 61 51 bayt

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

Bazı sözdizimini kısaltmak için xnor'a teşekkürler.

APL, 18 16 bayt

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

Bu isimsiz bir monadik fonksiyondur. Çıktı artan sıradadır.

Açıklama:

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

Bir sorun çözüldü ve Thomas Kwa sayesinde 2 bayt kurtarıldı!

CJam, 14 12 bayt

@Aditsu tarafından önerilen yeniliklerle en son sürüm:

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

Bu anonim bir işlevdir. Test etmek için gereken giriş / çıkış kodunu kullanarak çevrimiçi deneyin .

@Martin {,:)_ff*:|$}, aynı uzunluktaki başka bir şık çözüm ( ) önerdi . Ben bir tane aditsu kullandım çünkü orijinal çözümüme çok benziyordu.

Orijinal çözümümdeki temel fark, bu 0değeri başlangıçta 2 byte kazandıran orijinal dizide tutmasıdır . Bunun bir faydası olmayacağını düşünürdünüz, çünkü 0değeri sonuçtan kaldırmak zorundasınız . Fakat @ aditsu'nun fikrinin özü 0^, en sonunda olan ve bunun arasında kesin bir fark olduğu 0. Bu, kaldırır 0ve aynı zamanda ayarlanmış bir işlem olduğundan, yinelenen öğeleri çözüm kümesinden kaldırır. Daha önce kopyaları elimine etmek için zaten 2 bayta ihtiyacım olduğu için, çıkartmak 0aslında bedava.

Açıklama:

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

Octave, 22 bayt

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

Julia, 24 bayt

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

Bu bir tamsayıyı kabul eden ve bir tamsayı dizisi döndüren adsız bir işlevdir.

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 bayt

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

zsh, 86 56 bayt

30 (!) bayt tasarrufu için @Dennis sayesinde

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

Açıklama / 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)

Bu, Bash'de çalışmıyor çünkü Bash genişlemiyor {1..$1}- sadece kelimenin tam anlamıyla yorumluyor ( bunun yerine a=5; echo {1..$a}çıktılar ).{1..5}1 2 3 4 5

Ruby, 50 48 bayt

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

Her sayıyı n'ye kadar olan her bir sayı ile çarpmak için iç içe döngü kullanmak ve ardından diziyi sıralamak.

50 bayt

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

Kullanımı:

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

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

Bu, STDIN'den bir tamsayı okur ve STDOUT'a alanla ayrılmış bir liste yazar.

Çarpım tablosunu outer, bir vektöre örtük şekilde düzleştirerek ve kullanarak sıralayarak, kullanarak sortbenzersiz öğeler seçerek uniqueve kullanarak sınırlandırılmış baskı alanını kullanarak bir matris olarak oluştururuz cat.

Mathematica, 25 bayt

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

K, 17 bayt

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

Burada söylenecek fazla bir şey yok. Düzleştirilen ( ) çarpılmış kartezyen kendi ürününün ( ) t@<t:benzersiz öğelerini ( ?) N ( ) dahil olmak üzere ( ) sıralayın .,/t*\:t:1+!

Eylemde:

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

Haskell, 55 54 bayt

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

Kullanım örneği: f 4-> [1,2,3,4,6,8,9,12,16].

nub yinelenen öğeleri listeden kaldırır.

Düzenleme: @Zgarb gereksiz bir bulundu $.

J, 21 20 bayt

-1 bayt için @ Zgarb'a teşekkürler!

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

İlk J cevabım! Golf için bir şey varsa, golf ipuçları takdir edilmektedir.

Bu monadik bir fonksiyondur; dış ürünü listenin 1..inputkendisiyle çarpma , düzleştirme, benzersiz elemanlar alma ve sıralama yoluyla alıyoruz.

Kotlin, 70 bayt

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

Ungolfed versiyonu:

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

Şununla test et:

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

Shell + ortak yardımcı programları, 41

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

Veya alternatif olarak:

Bash + coreutils, 48

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

Bir aritmetik genişlemenin içinde ayraç genişlemesi oluşturur:

\$[{1..n}*{1..n}]$[1*1] $[1*2] ... $[1*n] ... $[n*n]değerlendirilen ve iletilen printf, her bir satıra bir tane basılan, borulara iletilen aritmetik açılımlara genişler sort.

Tırnakların dikkatli bir şekilde kullanılması, kaçar ve evalgenişlemelerin gereken sırada olmasını sağlar.

Veya alternatif olarak:

Saf Bash, 60

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

Pyth, 10

S{m*Fd^SQ2

Çevrimiçi Deneyin veya Test Suite çalıştırın

Minkolang 0.14 , 25 22 18 bayt

Bu soru gönderilmeden önce Kartezyen ürünlerini çok rahat kullandığımı hatırladım !

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

Burada dene.(Ters sırayla çıkışlar.)

açıklama

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 bayt

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

açıklama

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

Ölçek

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 bayt

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

Örnek kullanım:

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 bayt

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

Oldukça sıkıcı. Sadece listeyi filtreler [1..n*n]formun unsurlara a*bsahip ave biçinde [1..n]. Kullanarak filteraynı uzunlukta verir

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

Bir süre daha zeki concatMapveya daha zekice bir ürüne sahip olan ürünlerin listesini oluşturmaya çalıştım mapM, ancak daha uzun sonuçlara ulaştı. Daha karmaşık bir üyelik kontrolü, 1 byte daha uzun olan 52 baytta geldi, ancak belki de kısaltılabilir.

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

JAVA - 86 Bayt

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 bayt

S{sm*RdSdSQ

Bu Julia cevabına benzer. @Maltysen 'e teşekkürler

PHP, 74,73 70 bayt

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

Önceki:

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

% 100 çıktıyla ne yapacağından emin değil, ancak $ailgili sayıları içeren bir dizi içeriyor. $nnumara ile Geven olduğu $_GET['n']ile,register_globals=1

TeaScript , 37 35 karakter; 40 bayt

@Downgoat sayesinde 2 bayt kaydedildi

TeaScript, golf oynamak için JavaScript'tir.

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

Çevrimiçi deneyin!

Ungolfed ve açıklama

(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 bayt

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

Bu sayıları azalan sırayla yazdırır. Bu, optimal olmaktan uzak göründüğü için öneriler memnuniyetle karşılanmaktadır.

JavaScript (ES6), 86 bayt

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}

Kısaltmak için arıyorsunuz (belki iç içe döngüler deneyebilirsiniz).

Perl 5, 91 bayt

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

argümanı komut satırından geçirerek çalıştırılacak. Strictures ve uyarıları ile çalışan kısa bir açıklamadır.

Python, 124 102 bayt

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

Daha pitonik!

Perl 5, 67 bayt

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