2 कारकों का कारक

14

प्राकृतिक संख्या को देखते हुए nउन सभी संभावित दो कारकों गुणन की सूची प्राप्त करने के लिए एक प्रोग्राम या फ़ंक्शन लिखें, जिन्हें प्राप्त करने के लिए उपयोग किया जा सकता है n। यह समझने के लिए कि आप किस तरह का दिखावा कर रहे हैं, आप http://factornumber.com/?page=16777216 पर जाकर देख सकते हैं nकि 16777216हमें निम्नलिखित सूची कब मिलेगी:

   2 × 8388608  
   4 × 4194304  
   8 × 2097152  
  16 × 1048576  
  32 ×  524288  
  64 ×  262144  
 128 ×  131072  
 256 ×   65536  
 512 ×   32768  
1024 ×   16384
2048 ×    8192
4096 ×    4096

यहाँ की तरह सुंदर चीजों को मुद्रित करने की आवश्यकता नहीं है। आवश्यकता यह है कि प्रत्येक प्रविष्टि (कारकों की जोड़ी) एक दूसरे से अच्छी तरह से अलग है और प्रत्येक जोड़ी के अंदर, पहला कारक भी दूसरे से अच्छी तरह से अलग है। यदि आप एक सूची / सरणी वापस करने का विकल्प चुनते हैं, तो अंदर का तत्व दो तत्वों के साथ एक सूची / सरणी हो सकता है, या आपकी भाषा की कुछ संरचना जो सी ++ जैसी चीजों की एक जोड़ी का समर्थन करती है std::pair।

गुणन को 1 प्रविष्टि से न प्रिंट करें, और न ही दूसरे द्वारा शुरू किए गए पहले कारक के साथ प्रविष्टियों को दोहराएं, क्योंकि वे बहुत बेकार हैं।

कोई विजेता नहीं; यह प्रति भाषा आधार कोड गोल्फ होगा।

code-golf  math  arithmetic  integer 
— sergiol
स्रोत
2
क्या आप संभवतः एक छोटा परीक्षण मामला जोड़ सकते हैं, जैसे कि 30?
— caird coinheringaahing
1
@cairdcoinheringaahing आप अधिक परीक्षण मामलों को उत्पन्न करने के लिए factornumber.com का उपयोग कर सकते हैं ।
— जोनाथन फ्रेच
1
मैंने हाल ही में इस "प्रति भाषा" प्रतियोगिता को देखा है। क्या बात है? अधिकांश क्यू 1 भाषा के अनुसार 1 या 2 से अधिक नहीं मिलते हैं, और आप अभी भी सही के रूप में केवल एक ए का चयन कर सकते हैं।
— फेड एस।
5
@fedes। यह आमतौर पर है क्योंकि भाषाओं (यानी जावा बनाम जेली) के बीच तुलना करने का कोई मतलब नहीं है।
— अशुभ
1
@totallyhuman हाँ, मुझे पता है। मेरे अधिकांश उत्तर फैक्टर, या यहां तक ​​कि स्मॉलटाक में हैं। गोल्फ भाषाओं के खिलाफ कोई मौका नहीं। हो सकता है कि वर्बोसिटी और बॉइलरप्लैटरी
— फेडेड एस

जवाबों:

6

जावा (ओपनजेडके 8) , 81 66 65 बाइट्स

  • -15 बाइट्स ओलिवियर ग्रेजायर को धन्यवाद।
  • -1 बाइट: ++j<=i/j-> j++<i/j।
i->{for(int j=1;j++<i/j;)if(i%j<1)System.out.println(j+" "+i/j);}

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

पुराना एक (संदर्भ के लिए)

जावा (ओपनजेडके 8) , 126 बाइट्स

i->{java.util.stream.IntStream.range(2,i).filter(d->d<=i/d&&i%d==0).forEach(e->System.out.println(""+e+"x"+i/e));return null;}

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

पहला कोडगॉल्फ जमा और पहला लैम्ब्डा उपयोग। भविष्य स्व, कृपया मुझे कोड के लिए क्षमा करें।

— बर्नेट
स्रोत
1
अच्छी पहली प्रविष्टि! PPCG में आपका स्वागत है! यहाँ सभी अप्रासंगिक को हटाकर इसे 66 बाइट्स के लिए नीचे रखा गया है : हालांकि मैं आपके एल्गोरिथ्म को गोल्फ नहीं कर सकता।
— ओलिवियर ग्रेजायर 14
5

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

f=lambda n,k=2:n/k/k*[f]and[(k,n/k)][n%k:]+f(n,k+1)

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

51 बाइट्स (लुइस मेंडो के लिए धन्यवाद बाइट के लिए)

lambda n:[(n/k,k)for k in range(1,n)if(k*k<=n)>n%k]

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

51 बाइट्स

lambda n:[(n/k,k)for k in range(1,n)if n/k/k>n%k*n]

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

— XNOR
स्रोत
मुझे इसका उपयोग पसंद है [f]।
— जोनाथन फ्रीच
1
आप दूसरे संस्करण में 1 बाइट बचा सकते हैंlambda n:[(n/k,k)for k in range(1,n)if(k*k<=n)>n%k]
— लुइस मेंडू
1512518520 के लिए सभी दृष्टिकोणों पर मेमोरीएयर
— सेरगिओल
3

ब्रेकीलॉग , 8 बाइट्स

{~×≜Ċo}ᵘ

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

व्याख्या

{~×≜Ċo}ᵘ
{     }ᵘ  List the unique outputs of this predicate.
 ~×       Pick a list of integers whose product is the input.
   ≜      Force concrete values for its elements.
    Ċ     Force its length to be 2.
     o    Sort it and output the result.

~×भाग इसके उत्पादन में 1s शामिल नहीं है, इसलिए निवेश के लिए एन यह देता है [एन] के बजाय [1, एन] , जो बाद में से चुनी गई है Ċ। मुझे पूरी तरह से यकीन नहीं है कि ≜इसकी आवश्यकता क्यों है ...

— Zgarb
स्रोत
1
≜क्योंकि अन्यथा वहाँ के लिए कोई विकल्प नहीं अंक हैं की जरूरत है ᵘलंबाई -2 सूची जिसका उत्पाद है इनपुट केवल जवाब अगर आप वास्तव में सूची के मूल्यों के लिए पूछ नहीं है:।
— घातक
2

जाप , 9 बाइट्स

â¬Å£[XZo]

इसे ऑनलाइन टेस्ट करें! अंत में कुछ नल के साथ, सरणियों की एक सरणी लौटाता है; -Rध्वज आउटपुट को और अधिक स्पष्ट रूप से दिखाने के लिए जोड़ा गया।

— ETHproductions
स्रोत
1
तो मुझे लगता है कि बाइट काउंट के लिए `-आर` पर विचार किया जाना चाहिए ...
— सर्जियोल डे
3
@sergiol, नहीं, इस मामले में यह सिर्फ बेहतर पठनीयता के लिए आउटपुट स्वरूपण के लिए है।
— झबरा
वास्तव में मेरे पास समाधान था, सिवाय इसके कि मैंने nullएस को अंत में फ़िल्टर किया ।
— झबरा
2

जेली , 8 बाइट्स

½ḊpP⁼¥Ðf

एक मोनाडिक लिंक एक संख्या ले रहा है और संख्याओं की सूची (जोड़े) की वापसी कर रहा है।

इसे ऑनलाइन आज़माएं! (16777216उदाहरण केलिए TIO पर कई बार केबाद से यह 68.7 बिलियन जोड़े की सूची बनाएगा और सही उत्पाद वाले लोगों को फ़िल्टर करेगा!)

कैसे?

½ḊpP⁼¥Ðf - Link: number, n     e.g. 144
½        - square root of n          12
 Ḋ       - dequeue*                 [2,3,4,5,6,7,8,9,10,11,12]
  p      - Cartesian product**      [[2,1],[2,2],...[2,144],[3,1],...,[3,144],...,[12,144]
      Ðf - filter keep if:
     ¥   -   last two links as a dyad (n is on the right):
   P     -     product
    ⁼    -     equals
         -                          [[2,72],[3,48],[4,36],[6,24],[8,18],[9,16],[12,12]]

* Ḋ, dequeue, स्पष्ट रूप से अभिनय से पहले एक संख्यात्मक इनपुट की एक सीमा बनाता है, और रेंज फ़ंक्शन अपने इनपुट को स्पष्ट रूप से फर्श करता है, इसलिए, कहते हैं, n=24का परिणाम ½है 4.898...; सीमा बन जाती है [1,2,3,4]; और समाप्त हुआ परिणाम है[2,3,4]

** उपर्युक्त के समान, pकार्टेशियन उत्पाद, संख्यात्मक इनपुट के लिए सीमा बनाता है - यहाँ सही तर्क है nइसलिए सही तर्क [1,2,3,...,n]वास्तविक कार्टियन उत्पाद से पहले हो जाता है।

— जोनाथन एलन
स्रोत
2

भूसी , 8 बाइट्स

tüOSze↔Ḋ

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

व्याख्या

tüOSze↔Ḋ  Implicit input, say n=30.
       Ḋ  List of divisors: [1,2,3,5,6,10,15,30]
      ↔   Reverse: [30,15,10,6,5,3,2,1]
   Sze    Zip with original: [[1,30],[2,15],[3,10],[5,6],[6,5],[10,3],[15,2],[30,1]]
 üO       Deduplicate by sort: [[1,30],[2,15],[3,10],[5,6]]
t         Drop first pair: [[2,15],[3,10],[5,6]]
— Zgarb
स्रोत
2

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

n=>eval('for(k=1,a=[];k*++k<n;n%k||a.push([k,n/k]));a')

डेमो

कोड स्निपेट दिखाएं

यह ऑनलाइन की कोशिश करो!

— Arnauld
स्रोत
क्या यह मेरे लिए है या इसके लिए असफल है 6?
— नील
@ नील "हम इसे ठीक कर सकते हैं।" (रिपोर्टिंग के लिए धन्यवाद!)
— अरनौलड
मैं परीक्षण करने के लिए एक नंबर कैसे दे सकता हूं?
— सर्गियोल
— अरनौलड
1

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

lambda N:{(n,N/n,n)[n>N/n:][:2]for n in range(2,N)if N%n<1}

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

— जोनाथन फ्रेच
स्रोत
— सर्गियोल
@sergiol Yes, एक MemoryError, चूंकि पायथन range(2,N)इसका मूल्यांकन करने और इसे एक सूची के रूप में संग्रहीत करने की कोशिश करता है , फिर भी आवंटित स्मृति पर्याप्त नहीं है। एक (पायथन 2 के रेंज जनरेटर) के rangeसाथ बदलने की कोशिश कर सकता है xrange, हालांकि यह TIO के अधिकतम रनटाइम के एक मिनट से अधिक है। पर्याप्त मेमोरी और समय के साथ एक मशीन पर, इस कार्यक्रम को समाप्त करना चाहिए और सही उत्तर देना चाहिए।
— जोनाथन फ्रीच
1

PHP, 70 बाइट्स

स्ट्रिंग के रूप में (70 बाइट्स):

$i++;while($i++<sqrt($a=$argv[1])){echo !($a%$i)?" {$i}x".($a/$i):'';}

सरणी डंप (71 बाइट्स) के रूप में:

$i++;while($i++<sqrt($a=$argv[1]))!($a%$i)?$b[$i]=$a/$i:'';print_r($b);

(मुझे यकीन नहीं है कि अगर मैं रिटर्न $ b का उपयोग कर सकता हूं, तो बजाय print_r के क्योंकि यह अब सरणी को आउटपुट नहीं करता है, अन्यथा मैं यहां 2 बाइट बचा सकता हूं।)

सरणी परिणाम जैसे देता है:

Array
(
    [2] => 8388608
    [4] => 4194304
    [8] => 2097152
    [16] => 1048576
— RFSnake
स्रोत
"यदि आप एक सूची / एरे को वापस करने का विकल्प चुनते हैं" तो मेरे लिए इसका मतलब है कि आप प्रिंट कर सकते हैं या जैसा कि आप देख सकते हैं वापस लौट सकते हैं।
— फेड एस।
दूसरे विचार पर, किसी फ़ंक्शन के लिए लौटना वैध होना चाहिए, और किसी प्रोग्राम के लिए प्रिंट करना। आपको लगता है कि एक स्निपेट / कार्यक्रम है, एक फ़ंक्शन नहीं है, इसलिए मैं कहूंगा कि इस मामले में आपको मुद्रण होना चाहिए।
— फेड एस।
1

जेली , 12 बाइट्स

ÆDµżUḣLHĊ$$Ḋ

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

यह काम किस प्रकार करता है

ÆDµżUḣLHĊ$$Ḋ - Main monadic link;
             - Argument: n (integer) e.g. 30
ÆD           - Divisors                   [1, 2, 3, 5, 6, 10, 15, 30]
    U        - Reverse                    [30, 15, 10, 6, 5, 3, 2, 1]
   ż         - Interleave                 [[1, 30], [2, 15], [3, 10], [5, 6], [6, 5], [10, 3], [15, 2], [30, 1]]
         $$  - Last 3 links as a monad
      L      -   Length                   8
       H     -   Halve                    4
        Ċ    -   Ceiling                  4
     ḣ       - Take first elements        [[1, 30], [2, 15], [3, 10], [5, 6]]
           Ḋ - Dequeue                    [[2, 15], [3, 10], [5, 6]]
— केर्ड सिक्काहिराहिंग
स्रोत
1

कारक , ५ Fact

खैर, इस सवाल में कुछ फैक्टर होना चाहिए!

[ divisors dup reverse zip dup length 1 + 2 /i head rest ]

यह एक उद्धरण है। callस्टैक पर संख्या के साथ, स्टैक पर एक assoc(जोड़े का एक सरणी) छोड़ देता है ।

मुझे यकीन नहीं है कि सभी आयात गिनती या नहीं, क्योंकि वे भाषा का हिस्सा हैं। यह एक का उपयोग करता है:

USING: math.prime.factors sequences assocs math ;

(यदि वे गिनती करते हैं, तो मुझे छोटे आयातों के साथ लंबे समाधान की तलाश करनी चाहिए, जो मूर्खतापूर्ण है)

एक शब्द के रूप में:

: 2-factors ( x -- a ) divisors dup reverse zip dup length 1 + 2 /i head rest ;

50 2-factors .
 --> { { 2 25 } { 5 10 } }
— फ़ेडर एस।
स्रोत
1

रूबी , 43 बाइट्स

->n{(2..n**0.5).map{|x|[[x,n/x]][n%x]}-[p]}

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

यह काम किस प्रकार करता है:

Sqrt (n) तक की प्रत्येक संख्या के लिए, जोड़ी बनाएं [[x, n/x]], फिर n%xइस सरणी का वें तत्व लें। यदि n%x==0यह है [x, n/x], अन्यथा यह है nil। जब पूरा हो जाए, nilतो सूची से सभी को हटा दें ।

— जीबी
स्रोत
1

परी / जीपी , 49 34 38 बाइट्स

n->[[d,n/d]|d<-divisors(n),d>1&d<=n/d]

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

सभी युग्मों के लिए बिल्डर संकेतन सेट करें [d, n/d]जहाँ विषय के dसभी विभाजकों dके माध्यम से चलता nहै d > 1और d <= n/d।

एलेफाल्फा द्वारा भारी सुधार।

— जेपी स्टिग नीलसन
स्रोत
1
— एलेफाल्फा
@alephalpha अच्छा है। लेकिन इसे थोड़ा बदलना पड़ा क्योंकि यह आउटपुट के साथ फैक्टराइजेशन भी है 1।
— जेपी स्टिग नीलसन
0

भूसी , 14 12 बाइट्स

tumoOSe`/⁰Ḋ⁰

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

व्याख्या

tum(OSe`/⁰)Ḋ⁰  -- input ⁰, eg. 30
           Ḋ⁰  -- divisors [1..⁰]: [1,2,3,5,6,10,15,30]
  m(      )    -- map the following function (example on 10):
     Se        --   create list with 10 and ..
       `/⁰     --   .. flipped division by ⁰ (30/10): [10,3]
    O          --   sort: [3,10]
               -- [[1,30],[2,15],[3,10],[5,6],[5,6],[3,10],[2,15],[1,30]]
 u             -- remove duplicates: [[1,30],[2,15],[3,10],[5,6]]
t              -- tail: [[2,15],[3,10],[5,6]]
— ბიმო
स्रोत
0

एपीएल + विन, 32 बाइट्स

m,[.1]n÷m←(0=m|n)/m←1↓⍳⌊(n←⎕)*.5

स्पष्टीकरण:

(n←⎕) Prompts for screen input

m←(0=m|n)/m←1↓⍳⌊(n←⎕)*.5 Calculates the factors dropping the first

m,[.1]n÷ Identifies the pairs and concatenates into a list.
— ग्राहम
स्रोत
0

++ , 18 15 बाइट्स जोड़ें

L,F@pB]dBRBcE#S

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

यह काम किस प्रकार करता है

L,   - Create a lambda function
     - Example argument:     30
  F  - Factors;     STACK = [1 2 3 5 6 10 15]
  @  - Reverse;     STACK = [15 10 6 5 3 2 1]
  p  - Pop;         STACK = [15 10 6 5 3 2]
  B] - Wrap;        STACK = [[15 10 6 5 3 2]]
  d  - Duplicate;   STACK = [[15 10 6 5 3 2] [15 10 6 5 3 2]]
  BR - Reverse;     STACK = [[15 10 6 5 3 2] [2 3 5 6 10 15]]
  Bc - Zip;         STACK = [[15 2] [10 3] [6 5] [5 6] [3 10] [2 15]]
  E# - Sort each;   STACK = [[2 15] [3 10] [5 6] [5 6] [3 10] [2 15]]
  S  - Deduplicate; STACK = [[[2 15] [3 10] [5 6]]]
— केर्ड सिक्काहिराहिंग
स्रोत
0

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

~x=[(y,div(x,y))for y=2:x if x%y<1>y^2-x]

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

अनुपयोगी संचालक को फिर से परिभाषित ~करता है और आउटपुट के निर्माण के लिए एक सरणी समझ का उपयोग करता है।

  • div(x,y)पूर्णांक विभाजन के लिए neccessary है। x/y5 बाइट्स बचाता है लेकिन आउटपुट है ~4=(2,2.0)।
  • जूलिया तुलनाओं का पीछा करते हुए, एक बाइट को बचाने की अनुमति देता है।
  • एक्स से बचने के लिए सभी तरह से लूप करना Int(floor(√x))।
— Lukes
स्रोत
0

APL NARS 99 वर्ण

r←f w;i;h
r←⍬⋄i←1⋄→0×⍳0≠⍴⍴w⋄→0×⍳''≡0↑w⋄→0×⍳w≠⌊w⋄→0×⍳w≠+w
A:i+←1⋄→A×⍳∼0=i∣w⋄→0×⍳i>h←w÷i⋄r←r,⊂i h⋄→A

९ + ४६ + ४१ + ३ = ९९ परीक्षण: (जहां कुछ भी नहीं प्रिंट किया है, यह कुछ वापस लौटाता है list सूची शून्य किसी को "कोई समाधान नहीं" के रूप में विचार करना है)

  f 101    

  f 1 2 3

  f '1'

  f '123'

  f 33 1.23

  f 1.23

  ⎕←⊃f 16777216      
   2 8388608
   4 4194304
   8 2097152
  16 1048576
  32  524288
  64  262144
 128  131072
 256   65536
 512   32768
1024   16384
2048    8192
4096    4096
  f 123
3 41
— RosLuP
स्रोत
0

पाइट , 67 65 बाइट्स

←ĐðĐ0↔/⅟ƖŽĐŁ₂20`ŕ3ȘĐ05Ș↔ŕ↔Đ4Ș⇹3Ș⦋ƥ⇹⁺Ɩ3ȘĐ05Ș↔ŕ↔Đ4Ș⇹3Ș⦋ƤĐ3Ș⁺ƖĐ3Ș<łĉ

मुझे पूरा यकीन है कि यह गोल्फ हो सकता है।

मूल रूप से, एल्गोरिथ्म इनपुट के सभी विभाजकों की एक सूची उत्पन्न करता है (चलो इसे n कहते हैं ), एक ही सूची बनाता है, लेकिन फ़्लिप, दोनों को इंटरलेव करता है (उदाहरण के लिए, यदि n = 24, तो, इस बिंदु पर, यह है] 1,24,2,12,3,8,4,6,6,4,4,3,3,12,2,24,1]), और इंडेक्स 2 से तत्वों को प्रिंट करता है जब तक कि आधे सरणी की लंबाई, प्रत्येक को प्रिंट न कर दें एक नई लाइन पर नंबर, और हर जोड़ी के बीच में एक अतिरिक्त नई लाइन।

अधिकांश कार्य वास्तव में स्टैक के प्रबंधन में किया जाता है।


वेतन वृद्धि फ़ंक्शन का उपयोग करके 2 बाइट्स सहेजे गए।

— mudkip201
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.