오늘날 매우 간단한 도전 :

양의 정수 N을 취하고 행과 열의 배수가 모두 1에서 N까지 인 곱셈표에 나타나는 고유 번호 의 정렬 된 목록을 인쇄하거나 반환하는 프로그램 또는 함수를 작성하십시오 .

목록은 오름차순 (가장 작은 것부터 큰 것까지) 또는 내림차순 (가장 큰 것부터 작은 것)으로 정렬 될 수 있으며 임의의 합리적인 형식으로 출력 될 수 있습니다.

바이트 단위의 가장 짧은 코드가 이깁니다!

예

N = 4 인 경우 곱셈표는 다음과 같습니다.

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

표의 고유 번호는 1, 2, 3, 4, 6, 8, 9, 12, 16입니다. 이것들은 이미 정렬되어 있으므로

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

N = 4에 대한 정확한 출력 일 수 있습니다.하지만 정렬이 취소되고 서식에 약간의 여유가 있기 때문에 올바른 출력이 될 수 있습니다.

[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

테스트 사례

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 바이트

S{*M^SQ2

온라인으로 사용해보십시오.

설명 : SQ평가 된 목록 입력 ( Q)을 가져 와서 목록을 만듭니다 [1, 2, ..., Q]. ^SQ2가능한 모든 제품 조합과 함께 해당 목록의 데카르트 곱을 가져옵니다. *M이 쌍을 모두 곱하여 곱셈표에 가능한 모든 결과를 S{만들어 고유하게 정렬합니다.

파이썬 2, 61 51 바이트

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

일부 구문을 단축 한 xnor에게 감사합니다.

APL, 18 16 바이트

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

이것은 명명되지 않은 모나 딕 함수입니다. 출력은 오름차순입니다.

설명:

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

Thomas Kwa 덕분에 문제를 해결하고 2 바이트를 절약했습니다!

CJam, 14 12 바이트

@aditsu에서 제안한 개선 사항이 포함 된 최신 버전 :

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

이것은 익명의 기능입니다. 테스트에 필요한 입 / 출력 코드와 함께 온라인으로 사용해보십시오 .

@Martin {,:)_ff*:|$}은 같은 길이의 또 다른 매우 우아한 솔루션 ( )을 제안했습니다 . 나는 원래 솔루션과 훨씬 유사하기 때문에 aditsu가 사용했습니다.

내 원래 솔루션과의 주요 차이점 0은 원래 순서대로 값을 유지 하여 시작시 2 바이트를 절약한다는 것입니다. 0결과 에서 값 을 제거해야하기 때문에 이것이 도움이되지 않을 것이라고 생각할 것입니다 . 그러나 @aditsu의 아이디어의 핵심은 0^끝에 0있습니다. 이것은을 제거하고 0동시에 세트 작업이므로 솔루션 세트에서 중복 요소를 제거합니다. 중복을 제거하기 위해 이미 2 바이트가 필요했기 때문에를 제거하는 0것은 본질적으로 자유입니다.

설명:

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

옥타브, 22 바이트

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

줄리아, 24 바이트

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

이것은 정수를 받아들이고 정수 배열을 반환하는 익명 함수입니다.

언 골프 드 :

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 바이트

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

zsh, 86 56 바이트

30 (!) 바이트를 절약 한 @Dennis 덕분에

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

설명 / 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)

Bash는 확장되지 않기 때문에 Bash에서는 작동하지 않습니다. Bash는 {1..$1}문자 그대로 해석하기 때문에 ( 대신에 a=5; echo {1..$a}출력 ).{1..5}1 2 3 4 5

루비, 50 48 바이트

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

언 골프 드 :

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

중첩 루프를 사용하여 각 숫자에 n까지의 모든 숫자를 곱한 다음 배열을 정렬합니다.

50 바이트

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

용법:

->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 바이트

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

STDIN에서 정수를 읽고 공백으로 구분 된 목록을 STDOUT에 씁니다.

을 사용하여 곱셈표를 행렬로 만들고 outer묵시적으로 벡터로 전개하고을 사용하여 정렬하고을 사용하여 sort고유 한 요소를 선택 unique하고을 사용하여 구분 된 공백을 인쇄합니다 cat.

Mathematica, 25 바이트

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

K, 17 바이트

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

말할 것도 많지 않습니다. 평탄화 ( ) 된 곱한 직교 자체 곱 ( t@<t:)의 고유 항목 ( ?)을 최대 1 (N) (포함)까지 정렬합니다 ( ).,/t*\:t:1+!

실제로 :

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

하스켈, 55 54 바이트

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

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

nub 목록에서 중복 요소를 제거합니다.

편집 : @ Zgarb는 불필요한 것을 발견했습니다 $.

J, 21 20 바이트

-1 바이트를위한 @Zgarb에게 감사합니다!

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

나의 첫번째 J 답변! 골프에 관심이 있다면 골프 팁을 부탁드립니다.

이것은 모나 딕 함수입니다. 우리는 목록 1..input과 그 자체 를 곱하여 외적을 취하고 평평하게하고 독특한 요소를 취하고 정렬합니다.

코 틀린, 70 바이트

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

언 골프 버전 :

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

다음과 같이 테스트하십시오.

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

쉘 + 공통 유틸리티, 41

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

또는 대안으로 :

배쉬 + 코어 유틸리티, 48

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

산술 확장 안에 괄호 확장을 구성합니다.

\$[{1..n}*{1..n}]$[1*1] $[1*2] ... $[1*n] ... $[n*n]평가되고 전달되는 산술 확장으로 확장됩니다.이 확장 은 printf한 줄에 하나씩 인쇄됩니다 sort.

따옴표를주의해서 사용하고 이스케이프하고 eval필요한 순서대로 확장이 이루어 지도록합니다.

또는 대안으로 :

순수한 배쉬, 60

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

피스, 10

S{m*Fd^SQ2

온라인으로 시도 하거나 테스트 스위트를 실행하십시오

Minkolang 0.14 , 25 22 18 바이트

이 질문을 게시하기 전에 직교 제품을 매우 편리하게 구현했음을 기억 했습니다 !

1nLI20P[x*1R]sS$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.

자바 스크립트 (ES6), 92 90 바이트

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

설명

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

테스트

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>

펄 6 , 27 바이트

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

사용법 예 :

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

하스켈, 51 바이트

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

꽤 지루합니다. 그냥 목록 필터 [1..n*n]형태의 요소 a*b와 a와 b의를 [1..n]. 사용 filter하면 길이가 같습니다

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

concatMapor 와 같은 더 영리한 제품 목록을 생성하려고 잠시 시도했지만 mapM더 긴 결과 만 얻었습니다. 보다 정교한 멤버쉽 확인은 52 바이트로 1 바이트 더 길었지만 단축 될 수 있습니다.

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

자바-86 바이트

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

언 골프

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 바이트

S{sm*RdSdSQ

이것은 Julia 답변과 유사합니다. @Maltysen에게 감사합니다

PHP, 74,73 70 바이트

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

언 골프 드 :

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

너무 이른:

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

출력으로 무엇을 해야할지 100 % 확실하지 않지만 $a해당 숫자가있는 배열을 포함합니다. $n을 통한 숫자 $_GET['n']입니다.register_globals=1

TeaScript , 37 35 자; 40 바이트

@Downgoat 덕분에 2 바이트 절약

TeaScript는 골프를위한 JavaScript입니다.

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

온라인으로 사용해보십시오!

언 골프와 설명

(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 바이트

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

숫자를 내림차순으로 인쇄합니다. 제안이 최적과는 거리가 멀기 때문에 환영합니다.

자바 스크립트 (ES6), 86 바이트

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}

짧게하려고하면 중첩 루프를 시도 할 수도 있습니다.

펄 5, 91 바이트

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

명령 행에 인수를 전달하여 실행됩니다. 엄격한 경고와 함께 실행하기에는 부족한 선언입니다.

파이썬, 124102 바이트

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

더 pythonic!

펄 5, 67 바이트

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