आज बहुत आसान चुनौती:

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक एन और प्रिंट में लेता है या उस अद्वितीय संख्या की एक क्रमबद्ध सूची देता है जो गुणन तालिका में दिखाई देता है जिसकी पंक्ति और स्तंभ दोनों में 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

N = 4. के लिए आपका सटीक आउटपुट हो सकता है, लेकिन चूंकि छँटाई को उलटा किया जा सकता है और फॉर्मेटिंग में कुछ रास्ते हैं, ये भी मान्य आउटपुट होंगे:

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

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]

code-golf number arithmetic

— केल्विन के शौक
स्रोत

तो मूल रूप से, कोड एन द्वारा निर्दिष्ट गुणा तालिका में संख्याओं की एक सूची देता है, किसी भी संख्या को छोड़कर दोहराया नहीं जा सकता है?

— तन्माथ

N कितना बड़ा हो सकता है?

— xsot

1

@xsot आप मान सकते हैं कि N * N आपकी भाषा के अधिकतम सामान्य मान से कम होगा (शायद 2 ^ 31-1)

— केल्विन के शौक

तो अनिवार्य रूप से यह 1-n है और गैर primes अप करने के लिए n ^ 2 है।

— gregsdennis

1

@gregsdennis No. बहुत सारे कंपोजिट मौजूद नहीं हैं। जैसे 91, 92, 93, 94, 95, 96 एन = 10. के लिए

— केल्विन के शौक

12

पायथ, 8 बाइट्स

S{*M^SQ2

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण: SQमूल्यांकन सूची इनपुट ( Q) लेता है और एक सूची बनाता है [1, 2, ..., Q]। ^SQ2उस सूची के कार्टेशियन उत्पाद को अपने साथ ले जाता है - सभी संभव उत्पाद संयोजन। *Mइन सभी जोड़ियों को गुणन तालिका में सभी संभावित परिणामों को बनाने के लिए एक साथ गुणा S{करता है और इसे अद्वितीय बनाता है और इसे सॉर्ट करता है।

— orlp
स्रोत

@FryAmTheEggman Input 5 को पहले से ही छंटनी की आवश्यकता है, अन्यथा आउटपुट में 10 और 9 ऑर्डर से बाहर हैं।

— रेटो कोराडी

उस छींटाकशी के बारे में भूल जाते हैं M। +1

— माल्टीसेन

13

पायथन 2, 61 51 बाइट्स

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

कुछ वाक्य रचना को छोटा करने के लिए xnor का धन्यवाद।

— xsot
स्रोत

1

set(...)सिर्फ एक सेट कंप्यूटर अनुप्रयोग हो सकता है {...}। इसके अलावा, फ़ंक्शन डिफ़ॉल्ट रूप से यहां अनुमत हैं, इसलिए आप बस लिख सकते हैं lambda n:...।

— xnor

सेट समझ के बारे में मुझे याद दिलाने के लिए धन्यवाद, मैं पूरी तरह से भूल गया कि यह अस्तित्व में है।

— xsot

मैं ऐसा करने के लिए एक बेहतर तरीका नहीं देख सकता, सबसे अच्छा मुझे पुनरावृत्ति के साथ देखना 56: है f=lambda n:n*[0]and sorted(set(range(n,n*n+n,n)+f(n-1)))।

— xnor

11

एपीएल, 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

एक मुद्दा फिक्स्ड और थॉमस Kwa के लिए धन्यवाद 2 बाइट्स बचा लिया!

— एलेक्स ए।
स्रोत

7

CJam, 14 12 बाइट्स

@Aditsu द्वारा प्रस्तावित सुधारों के साथ नवीनतम संस्करण:

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

यह एक अनाम फ़ंक्शन है। परीक्षण के लिए आवश्यक इनपुट / आउटपुट कोड के साथ इसे ऑनलाइन आज़माएं ।

@ मर्टिन ने एक {,:)_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.

— रेटो कोराडी
स्रोत

उसी लंबाई के लिए {2m*::)::*_&$},{)2m*::*_&$0-}

— पीटर टेलर

2

इसके बारे में दो बाइट्स कम के लिए कैसे :){,:)_ff*:|$}

— मार्टिन एंडर

1

एक और तरीका है:{)2m*::*0^$}

— aditsu

5

ऑक्टेव, 22 बाइट्स

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

— alephalpha
स्रोत

4

जूलिया, 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

— एलेक्स ए।
स्रोत

4

MATLAB, 24 बाइट्स

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

— स्टीवी ग्रिफिन
स्रोत

अच्छा था! जल्द ही इसे 7 या 8 बाइट्स में करना संभव होगा ... :-)

— लुइस मेंडू

ऊह, अच्छा! :-)

— स्टेवी ग्रिफिन

@Luis आप की कोशिश की है यह एक Matl में?

— स्टिव ग्रिफ़िन

पूरी चुनौती को पढ़ने के लिए मेरे पास अब ज्यादा समय नहीं है, लेकिन आपके मैटलैब कोड को देखकर ऐसा लग रहा है कि यह MATL के साथ किया जा सकता है

— लुइस

4

zsh, 86 56 बाइट्स

30 बाइट बचाने के लिए @ डेनिस का शुक्रिया

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

स्पष्टीकरण / अपुष्ट:

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

यह बैश में काम नहीं करता है क्योंकि बैश का विस्तार नहीं होता है {1..$1}- यह केवल शाब्दिक रूप से व्याख्या करता है (इसलिए, इसके बजाय a=5; echo {1..$a}आउटपुट )।{1..5}1 2 3 4 5

— Doorknob
स्रोत

मैं एक * उत्तर की प्रतीक्षा कर रहा था। : डी

— एडिसन क्रम्प

1

प्रासंगिक बैश टिप। जेड शेल पर भी लागू होता है।

— डेनिस

आप ब्रेस एक्सपैंशन से थोड़ा अधिक बाहर निचोड़

— डिजिटल ट्रॉमा

4

रूबी, 50 48 बाइट्स

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

नेस्टेड लूप का उपयोग करते हुए प्रत्येक संख्या को हर दूसरी संख्या के साथ 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]

— वासु अडारी
स्रोत

3

आर, 39 बाइट्स

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

यह STDIN से एक पूर्णांक को पढ़ता है और STDOUT को एक अंतरिक्ष सीमांकित सूची लिखता है।

हम एक मैट्रिक्स का उपयोग करके गुणा तालिका बनाते हैं outer, एक वेक्टर में स्पष्ट रूप से समतल करते हैं और उपयोग करके सॉर्ट करते हैं sort, उपयोग करने वाले अनूठे तत्वों का चयन करते हैं unique, और उपयोग करके सीमांकित स्थान प्रिंट करते हैं cat।

— एलेक्स ए।
स्रोत

35 बाइट्स

— ग्यूसेप

2

गणितज्ञ, 25 बाइट्स

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

— alephalpha
स्रोत

2

के, 17 बाइट्स

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

यहां कहने के लिए कुछ अधिक नहीं। क्रमबद्ध ( t@<t:) ?चपटे ( ,/) गुणक स्व-उत्पाद ( t*\:t:) का 1 तक और N सहित ( ) का अनूठा आइटम ( 1+!)।

कार्रवाई में:

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

— JohnE
स्रोत

2

हास्केल, 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 को एक शानदार मिला $।

— nimi
स्रोत

2

जे, 21 20 बाइट्स

@ बाइट के लिए शुक्रिया -1 बाइट!

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

मेरा पहला J उत्तर! यदि गोल्फ के लिए कुछ है, तो गोल्फ टिप्स की सराहना की जाती है।

यह एक राक्षसी कार्य है; हम बाहरी उत्पाद को सूची के गुणन द्वारा 1..inputअपने साथ ले जाते हैं, समतल करते हैं, अद्वितीय तत्व लेते हैं, और छाँटते हैं।

— lirtosiast
स्रोत

2

कोटलिन, 70 बाइट्स

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

Ungolfed संस्करण:

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

— succcubbus
स्रोत

2

शेल + आम उपयोगिताओं, 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[@]}

— डिजिटल आघात
स्रोत

1

अजगर, १०

S{m*Fd^SQ2

इसे ऑनलाइन आज़माएं या टेस्ट सूट चलाएं

— FryAmTheEggman
स्रोत

1

मिंकोलंग 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.

— एलेंडिया स्ट्राटन
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 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>

स्निपेट का विस्तार करें

— user81655
स्रोत

1

पर्ल 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)␤

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

हास्केल, 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]

मैंने कुछ समय के लिए उत्पादों की सूची तैयार करने की कोशिश की , जैसे कि अधिक चतुर concatMapया mapM, लेकिन केवल लंबे परिणाम मिले। सदस्यता की अधिक परिष्कृत जांच 52 बाइट्स में हुई, 1 बाइट लंबी, लेकिन शायद इसे छोटा किया जा सकता है।

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

— XNOR
स्रोत

आप इस(*)<$>..<*>.. तरह का उपयोग करके 3 बाइट्स बचा सकते हैं

— '

1

जावा - 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;}

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

— यासिन हज्ज
स्रोत

1

अजगर, 11 बाइट्स

S{sm*RdSdSQ

यह जूलिया जवाब के समान है। @Maltysen को धन्यवाद

— TanMath
स्रोत

1

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

पिछला:

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

नहीं 100% यकीन है कि उत्पादन के साथ क्या करना है, लेकिन $aइसी संख्या के साथ एक सरणी शामिल है। $nके $_GET['n']साथ, के माध्यम से संख्या को बदलने वाला हैregister_globals=1

— Martijn
स्रोत

1

टीस्क्रिप्ट , 37 35 वर्ण; 40 बाइट्स

सहेजे गए 2 बाइट्स @Downgoat की बदौलत

TeaScript गोल्फिंग के लिए जावास्क्रिप्ट है।

(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

— ETHproductions
स्रोत

आप बस का उपयोग rकरने के A.rलिए पर्वतमाला पैदा करने के लिए उपयोग कर सकते हैं

— Downgoat

यकीन है कि यह 35 बाइट्स है ? मुझे 35 चार्ट या 40 बाइट्स मिलते हैं।

— मैनटवर्क

@manatwork यह आईएसओ / IEC_8859-1 एन्कोडिंग प्रारूप में 35 बाइट्स होगा । लेकिन मुझे यकीन नहीं है कि TeaScript उस एन्कोडिंग का समर्थन करता है, इसलिए मैं इसे अभी के लिए 40 बाइट्स में बदल दूँगा।

— ETHproductions

0

सी, 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);}

यह संख्या को अवरोही क्रम में प्रिंट करता है। सुझावों का स्वागत किया जाता है क्योंकि यह इष्टतम से बहुत दूर दिखता है।

— xsot
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 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}

इसे छोटा करने के लिए खोज (शायद घोंसले के शिकार छोरों की कोशिश करेंगे)।

— nicael
स्रोत

0

पर्ल 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";

कमांड लाइन पर तर्क पारित करके चलाया जाना। यह सख्त और चेतावनियों के साथ चलने की घोषणा के काफी कम है।

— वाल्टर ए। एपिले
स्रोत

0

पायथन, 124 102 बाइट्स

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

अधिक अजगर!

— TanMath
स्रोत

2

यह वास्तव में 123 बाइट्स है, न कि 124। लेकिन आप 4 के बजाय केवल इंडेंटेशन स्तर पर केवल एक ही स्थान का उपयोग करके कुछ बाइट्स बचा सकते हैं

— एलेक्स ए।

1

तुम भी l.append(i*j)सशर्त के रूप में एक ही लाइन पर डाल सकते हैं। मुझे लगता है कि यह पूरी तरह से 102 बाइट्स समाप्त होता है।

— एलेंडिया स्ट्राटन

3

और के +=बजाय का उपयोग करें append।

— कार्तिक

@ El'endiaStarman संपादित, धन्यवाद!

— तनमथ

1

एक अपेक्षाकृत मामूली समस्या: list(set(l))हल करने की गारंटी नहीं है।

— एल'एंडिया स्ट्रोमैन

0

पर्ल 5, 67 बाइट्स

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

— msh210
स्रोत

गुणन तालिका में अद्वितीय संख्याओं को क्रमबद्ध करें

उदाहरण

परीक्षण के मामलों

पायथ, 8 बाइट्स

पायथन 2, 61 51 बाइट्स

एपीएल, 18 16 बाइट्स

CJam, 14 12 बाइट्स

ऑक्टेव, 22 बाइट्स

जूलिया, 24 बाइट्स

MATLAB, 24 बाइट्स

zsh, 86 56 बाइट्स

रूबी, 50 48 बाइट्स

आर, 39 बाइट्स

गणितज्ञ, 25 बाइट्स

के, 17 बाइट्स

हास्केल, 55 54 बाइट्स

जे, 21 20 बाइट्स

कोटलिन, 70 बाइट्स

शेल + आम उपयोगिताओं, 41

बाश + कोरुटिल्स, 48

शुद्ध बैश, 60

अजगर, १०

मिंकोलंग 0.14 , 25 22 18 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 92 90 बाइट्स

व्याख्या

परीक्षा

पर्ल 6 , 27 बाइट्स

हास्केल, 51 बाइट्स

जावा - 86 बाइट्स

Ungolfed

अजगर, 11 बाइट्स

PHP, 74,73 70bytes

टीस्क्रिप्ट , 37 35 वर्ण; 40 बाइट्स

अपुष्ट और व्याख्या

सी, 96 बाइट्स

जावास्क्रिप्ट (ईएस 6), 86 बाइट्स

पर्ल 5, 91 बाइट्स

पायथन, 124 102 बाइट्स

पर्ल 5, 67 बाइट्स