একটি গুণ টেবিল অনন্য সংখ্যা বাছাই

Question

আজ খুব সহজ চ্যালেঞ্জ:

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা ইতিবাচক পূর্ণসংখ্যা N এ নিয়ে যায় এবং গুণক সারণীতে প্রদর্শিত অনন্য সংখ্যার একটি সাজানো তালিকা প্রিন্ট করে বা প্রত্যাবর্তন করে যার সারি এবং কলামটি বহুগুণ উভয়ই 1 থেকে 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

এন = ৪ এর জন্য আপনার সঠিক আউটপুট হতে পারে তবে যেহেতু বাছাইটি বিপরীত হতে পারে এবং ফরম্যাটে কিছুটা অবকাশ আছে, এগুলি বৈধ আউটপুটও হবে:

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

Comments

সুতরাং মূলত, কোডটি এন দ্বারা নির্দিষ্ট করা গুণ টেবিলের সংখ্যার একটি তালিকা ফেরত দেয়, কোনও সংখ্যার পুনরাবৃত্তি করা যায় না?

— তানমাথ

এন কত বড় হতে পারে?

— xsot

@ এক্সসট আপনি ধরে নিতে পারেন এন * এন আপনার ভাষার সর্বাধিক স্বাভাবিক মানের চেয়ে কম হবে (সম্ভবত 2 ^ 31-1)

— ক্যালভিনের শখ

সুতরাং মূলত এটি 1-এন এবং এন ^ 2 অবধি প্রাইমগুলি।

— গ্রেগসডেনিস

@ গ্রেগসডেনিস নং। প্রচুর সংমিশ্রণ উপস্থিত নেই। যেমন এন = 10 এর জন্য 91, 92, 93, 94, 95, 96

— ক্যালভিনের শখ

Answer 1

পাইথ, 8 বাইট

S{*M^SQ2

এটি অনলাইনে চেষ্টা করুন।

ব্যাখ্যা: SQমূল্যায়িত তালিকার ইনপুট নেয় ( Q) এবং একটি তালিকা তৈরি করে [1, 2, ..., Q]। ^SQ2সেই তালিকার কার্টেসিয়ান পণ্যটিকে নিজের সাথে নিয়ে যায় - সমস্ত সম্ভাব্য পণ্য সংমিশ্রণ। *Mএই সমস্ত জোড়া একসাথে গুণিত করে গুণক টেবিলের সমস্ত সম্ভাব্য ফলাফল তৈরি করে এবং S{এটি অনন্য করে তোলে এবং এটি সাজায়।

Comments

@ ফ্রাইআমএইজিগম্যান ইনপুট 5 এর মধ্যে ইতিমধ্যে বাছাই করা দরকার, অন্যথায় আউটপুটে 10 এবং 9 ক্রমযুক্ত নয়।

— রেটো কোরাাদি

গা ছমছমে যে ছিটানো সম্পর্কে ভুলে যেতে থাকুন M। +1

— মালটিসেন

Answer 2

পাইথন 2, 61 51 বাইট

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

কিছু সিনট্যাক্স সংক্ষিপ্ত করার জন্য xnor ধন্যবাদ।

Comments

set(...)শুধু একটি সেট Comp হতে পারে {...}। এছাড়াও, ফাংশনগুলি এখানে ডিফল্টরূপে অনুমোদিত হয়, সুতরাং আপনি কেবল লিখতে পারেন lambda n:...।

— xnor

সেট বোঝা সম্পর্কে আমাকে মনে করিয়ে দেওয়ার জন্য ধন্যবাদ, আমি সম্পূর্ণরূপে ভুলে গিয়েছিলাম এটি বিদ্যমান ছিল।

— xsot

আমি এই কাজ করতে একটি ভাল উপায় দেখতে পাচ্ছি না, সেরা আমি recursion দেখতে 56 হল: f=lambda n:n*[0]and sorted(set(range(n,n*n+n,n)+f(n-1)))।

— xnor

Answer 3

এপিএল, 18 16 বাইট

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

এটি একটি নামবিহীন monadic ফাংশন। আউটপুট আরোহী ক্রমে হয়।

ব্যাখ্যা:

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

একটি সমস্যা স্থির করে এবং টমাস কোয়ার জন্য 2 বাইট সংরক্ষণ করে!

Answer 4

CJam, 14 12 বাইট

@ অ্যাডিটসু প্রস্তাবিত উন্নতিগুলির সাথে সর্বশেষ সংস্করণ:

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

এটি একটি বেনামে ফাংশন। এটি অনলাইনে চেষ্টা করুন পরীক্ষার জন্য প্রয়োজনীয় ইনপুট / আউটপুট কোড সহ ব্যবহার করে দেখুন।

@ মার্টিন আরেকটি খুব মার্জিত সমাধানের প্রস্তাব দিয়েছেন ({,:)_ff*:|$} একই দৈর্ঘ্য সহ ) । আমি এটিকে আদিতু দ্বারা ব্যবহার করেছি কারণ এটি আমার মূল সমাধানের সাথে অনেক বেশি অনুরূপ।

আমার আসল সমাধানের মূল পার্থক্য হ'ল 0এটি মূল ক্রমের মান রাখে , যা শুরুতে 2 বাইট সংরক্ষণ করে। আপনি ভাবেন যে এটি সাহায্য করবে না, কারণ আপনাকে 0ফলাফল থেকে মানটি সরিয়ে ফেলতে হবে । তবে @ অদিতসুর ধারণার মূলটি হ'ল 0^শেষে, যা এর সাথে একটি সেট পার্থক্য 0। এটি অপসারণ করে 0এবং একই সাথে এটি যেহেতু এটি একটি সেট অপারেশন, সমাধান সেট থেকে সদৃশ উপাদানগুলি সরিয়ে দেয় in যেহেতু আমার আগেই সদৃশগুলি অপসারণ করতে 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.

Comments

একই দৈর্ঘ্যের জন্য {2m*::)::*_&$},{)2m*::*_&$0-}

— পিটার টেলর

কিভাবে দুই জন্য এই সম্পর্কে বাইট কম :){,:)_ff*:|$}

— মার্টিন Ender

আরেকটি উপায়:{)2m*::*0^$}

— এডিটসু

Answer 5

অক্টাভা, 22 বাইট

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

Answer 6

জুলিয়া, 24 বাইট

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

এটি একটি বেনামে ফাংশন যা একটি পূর্ণসংখ্যা গ্রহণ করে এবং পূর্ণসংখ্যার অ্যারে প্রদান করে।

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

Answer 7

ম্যাটল্যাব, 24 বাইট

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

Comments

Good one! Soon it will be possible to do it in 7 or 8 bytes... :-)

— Luis Mendo

Oooh, nice! :-)

— Stewie Griffin

@Luis have you tried this one in MATL?

— Stewie Griffin

I don't have much time now to read the whole challenge, but seeing your Matlab code it looks like it could be done with MATL

— Luis Mendo

Answer 8

zsh, 86 56 bytes

thanks to @Dennis for saving 30(!) bytes

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

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

This doesn't work in Bash because Bash doesn't expand {1..$1}—it just interprets it literally (so, a=5; echo {1..$a} outputs {1..5} instead of 1 2 3 4 5).

Comments

I was waiting for a *sh answer. :D

— Addison Crump

Relevant bash tip. Seems to apply to the Z shell as well.

— Dennis

You can squeeze a bit more out of brace expansions

— Digital Trauma

Answer 9

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
}

Using nested loop to multiply each number with every other number upto n and then sorting the array.

50 bytes

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

Usage:

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

Answer 10

R, 39 bytes

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

This reads an integer from STDIN and writes a space delimited list to STDOUT.

We create the multiplication table as a matrix using outer, implicitly flatten into a vector and sort using sort, select unique elements using unique, and print space delimited using cat.

Comments

35 bytes

— Giuseppe

Answer 11

Mathematica, 25 bytes

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

Answer 12

K, 17 bytes

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

Not much to say here. Sort (t@<t:) the unique items (?) of the flattened (,/) multiplied cartesian self-product (t*\:t:) of 1 up to and including N (1+!).

In action:

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

Answer 13

Haskell, 55 54 bytes

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

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

nub removes duplicate elements from a list.

Edit: @Zgarb found a superfluous $.

Answer 14

J, 21 20 bytes

Thanks to @Zgarb for -1 byte!

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

My first J answer! Golfing tips are appreciated, if there is something to golf.

This is a monadic function; we take the outer product by multiplication of the list 1..input with itself, flatten, take unique elements, and sort.

Answer 15

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

Test it with:

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

Answer 16

Shell + common utilities, 41

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

---

Or alternatively:

Bash + coreutils, 48

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

Constructs a brace expansion inside an arithmetic expansion:

\$[{1..n}*{1..n}] expands to the arithmetic expansions $[1*1] $[1*2] ... $[1*n] ... $[n*n] which are evaluated and passed to printf, which prints one per line, which is piped to sort.

Careful use of quotes, escapes and eval ensure the expansions happen in the required order.

---

Or alternatively:

Pure Bash, 60

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

Answer 17

Pyth, 10

S{m*Fd^SQ2

Try it Online or run a Test Suite

Answer 18

Minkolang 0.14, 25 22 18 bytes

I remembered that I very conveniently implemented Cartesian products before this question was posted!

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

Try it here. (Outputs in reverse order.)

Explanation

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.

Answer 19

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

Explanation

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

Test

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>

Answer 20

Perl 6, 27 bytes

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

Example usage:

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

Answer 21

Haskell, 51 bytes

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

Pretty boring. Just filters the list [1..n*n] to the elements of the form a*b with a and b in [1..n]. Using filter gives the same length

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

I tried for a while to generate the list of products with something more clever like concatMap or mapM, but only got longer results. A more sophisticated check of membership came in at 52 bytes, 1 byte longer, but can perhaps be shortened.

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

Comments

You can save 3 bytes by using (*)<$>..<*>.. like this

— ბიმო

Answer 22

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

Answer 23

Pyth, 11 bytes

S{sm*RdSdSQ

This is similar to the Julia answer. Thanks to @Maltysen

Answer 24

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

Ungolfed:

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

---

Previous:

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

Not 100% sure what to do with output, but $a contains an array with the corresponding numbers. $n is the number geven via $_GET['n'], with register_globals=1

Answer 25

TeaScript, 37 35 chars; 40 bytes

Saved 2 bytes thanks to @Downgoat

TeaScript is JavaScript for golfing.

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

Try it online!

Ungolfed and explanation

(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

Comments

You can just use r instead of A.r for generating ranges

— Downgoat

Sure this is 35 bytes? I get 35 chars or 40 bytes.

— manatwork

@manatwork This would be 35 bytes in the ISO/IEC_8859-1 encoding format. But I'm not sure that TeaScript supports that encoding, so I'll change it to 40 bytes for now.

— ETHproductions

Answer 26

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

This prints the numbers in descending order. Suggestions are welcomed as this looks far from optimal.

Answer 27

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}

Looking to shorten it (maybe will try nesting loops).

Answer 28

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

to be run by passing the argument on the command line. It is quite a few declarations short of running with strictures and warnings.

Answer 29

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

More pythonic!

Comments

This is actually 123 bytes, not 124. But you can save a few bytes by using only a single space per indentation level rather than 4.

— Alex A.

You can also put l.append(i*j) on the same line as the if conditional. I think it ends up being 102 bytes altogether.

— El'endia Starman

And use += instead of append.

— Kartik

@El'endiaStarman edited, thanks!

— TanMath

One relatively minor issue: list(set(l)) is not guaranteed to be sorted.

— El'endia Starman

Answer 30

Perl 5, 67 bytes

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