आउटपुट डिस्टिक्ट फैक्टर क्यूबॉइड्स

14

आउटपुट डिस्टिक्ट फैक्टर क्यूबॉइड्स

आज का कार्य बहुत सरल है: एक सकारात्मक पूर्णांक दिया गया है, प्रत्येक क्यूबॉइड के एक प्रतिनिधि को इसके कारकों द्वारा आउटपुट किया जाता है।

स्पष्टीकरण

एक घनाभ का आयतन इसकी तीन भुजाओं की लंबाई का गुणनफल है। उदाहरण के लिए, मात्रा 4 जिसका पक्ष समान नहीं हैं पूर्णांकों पक्षों हो सकता है की एक घनाभ [1, 1, 4], [1, 2, 2], [1, 4, 1], [2, 1, 2], [2, 2, 1], या [4, 1, 1]। हालांकि, इनमें से कुछ समान घनाभ का प्रतिनिधित्व करते हैं: जैसे [1, 1, 4]और [4, 1, 1]समान घनाभ को घुमाया जाता है। वॉल्यूम 4 और पूर्णांक पक्षों के साथ केवल दो अलग-अलग क्यूबॉइड हैं: [1, 1, 4]और [1, 2, 2]। आउटपुट पहले क्यूबॉयड का कोई प्रतिनिधित्व हो सकता है, और दूसरा क्यूबॉयड का कोई भी प्रतिनिधित्व।

इनपुट

आपके प्रोग्राम को एक ही सकारात्मक पूर्णांक ।1≤n≤231−1

उत्पादन

आपको सूची या किसी अन्य स्वीकार्य तरीके से सभी संभावित क्यूबॉइड का उत्पादन करने की आवश्यकता होगी। उदाहरण के लिए

Input  Output
  1    [[1, 1, 1]]
  2    [[1, 1, 2]]
  3    [[1, 1, 3]]
  4    [[1, 1, 4], [1, 2, 2]]
  8    [[1, 1, 8], [1, 2, 4], [2, 2, 2]]
 12    [[1, 1, 12], [1, 2, 6], [1, 3, 4], [2, 2, 3]]
 13    [[1, 1, 13]]
 15    [[1, 1, 15], [1, 3, 5]]
 18    [[1, 1, 18], [1, 2, 9], [1, 3, 6], [2, 3, 3]]
 23    [[1, 1, 23]]
 27    [[1, 1, 27], [1, 3, 9], [3, 3, 3]]
 32    [[1, 1, 32], [1, 2, 16], [1, 4, 8], [2, 2, 8], [2, 4, 4]]
 36    [[1, 1, 36], [1, 2, 18], [1, 3, 12],[1, 4, 9], [1, 6, 6], [2, 2, 9], [2, 3, 6], [3, 3, 4]]

उप-सूचियों को क्रमबद्ध करने की आवश्यकता नहीं है, जब तक वे अद्वितीय हैं।

स्कोरिंग

यह कोड गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा जवाब है। मानक खामियों को मना किया जाता है।

यहाँ एक परीक्षण केस जनरेटर है

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई दे रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक स्कोर अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

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

code-golf  math  number  permutations  factoring 
— Lyxal
स्रोत
— अरनुलद
— अरनुलद

जवाबों:

4

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

œċ3P⁼¥Ƈ

एक सकारात्मक लिंक जो एक सकारात्मक पूर्णांक स्वीकार करता है जो सकारात्मक पूर्णांक की 3-सूचियों की सूची देता है।

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

कैसे?

œċ3P⁼¥Ƈ - Link: positive integer, N
  3     - literal three
œċ      - all combinations (of [1..N]) of length (3) with replacement
           i.e. [[1,1,1],[1,1,2],...,[1,1,N],[1,2,2],[1,2,3],...,[1,2,N],...,[N,N,N]]
      Ƈ - filter keep those for which:
     ¥  -   last two links as a dyad:
   P    -     product
    ⁼   -     equals (N)?
— जोनाथन एलन
स्रोत
5

जावास्क्रिप्ट (V8) ,  61  60 बाइट्स

STDOUT को क्यूब्स प्रिंट करता है।

n=>{for(z=n;y=z;z--)for(;(x=n/y/z)<=y;y--)x%1||print(x,y,z)}

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

टिप्पणी की गई

n => {                // n = input
  for(                // outer loop:
    z = n;            //   start with z = n
    y = z;            //   set y to z; stop if we've reached 0
    z--               //   decrement z after each iteration
  )                   //
    for(              //   inner loop:
      ;               //     no initialization code
      (x = n / y / z) //     set x to n / y / z
      <= y;           //     stop if x > y
      y--             //     decrement y after each iteration
    )                 //
      x % 1 ||        //     unless x is not an integer,
      print(x, y, z)  //     print the cuboid (x, y, z)
}                     //
— Arnauld
स्रोत
5

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

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

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

ट्यूपल्स अवरोही क्रम में हैं। "3" एक छोटी-सी पर्याप्त संख्या प्रतीत होती है, जिसमें 3 छोरों को लिखना कुछ सामान्य से कम था जो मैं साथ आ सकता था।

— XNOR
स्रोत
मुझे दी गई सूची की सामग्री ट्यूपल्स को कॉल करने का मेटा-ऑब्सफिकेशन पसंद है।
— जोनाथन फ्रैच
4

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

ÆDṗ3Ṣ€QP=¥Ƈ

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

एक विवादास्पद लिंक एक पूर्णांक को अपने तर्क के रूप में लेता है और पूर्णांकों की सूची की एक सूची लौटाता है।

व्याख्या

ÆD          | Divisors
  ṗ3        | Cartesian power of 3
    Ṣ€      | Sort each list
      Q     | Unique
         ¥Ƈ | Keep only where the following is true (as a dyad, using the original argument as right argument)
       P    | - Product
        =   | - Is equal (to original argument)
— निक केनेडी
स्रोत
2

हास्केल , 67 60 59 बाइट्स

n{1,2,…,n}

f n=[x|x@[a,b,c]<-mapM id$[1..n]<$":-)",a*b*c==n,a<=b,b<=c]

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

— flawr
स्रोत
1
मुझे लगता है कि तीन-टुपल्स केवल एक स्माइली के साथ ठीक से उत्पादित किए जा सकते हैं।
— जोनाथन फ्रैच
: -)
— flawr
2

रेटिना , 59 बाइट्स

.+
*
2+%L$`(?<=(_+))(?=(\1)*$)
$` _$#2*
A`_(_+) \1\b
_+
$.&

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण सूट शामिल है। स्पष्टीकरण:

.+
*

यूनीरी में बदलें।

2+%L$`(?<=(_+))(?=(\1)*$)
$` _$#2*

दो बार दोहराते हुए, प्रत्येक संभावित कारकों में से प्रत्येक पंक्ति में अंतिम संख्या को विभाजित करें। दिखावटी लालची और परमाणु है, इसलिए एक बार अंतिम संख्या के उपसर्ग से मेल खाने के बाद यह पीछे नहीं हटेगा। यह तीन कारकों के सभी संभावित क्रमचय उत्पन्न करता है।

A`_(_+) \1\b

उन पंक्तियों को हटा दें जहाँ कारक बढ़ते क्रम में नहीं हैं।

_+
$.&

दशमलव में परिवर्तित करें।

— नील
स्रोत
2

सी (क्लैंग) , 89 बाइट्स

a,b,x;f(n){for(a=n;a;a--)for(b=a;b&&(x=n/a/b)<=b;b--)x*b*a-n||printf("%d,%d,%d ",x,b,a);}

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

पोर्ट ऑफ @ अर्नुलड na

सहेजा गया 1 @Jonathan Frech को बेहतर आउटपुट स्वरूप के लिए धन्यवाद

— AZTECCO
स्रोत
1
"%d %d %d\n"~> "%d,%d,%d "एक बाइट बचाना होगा।
— जोनाथन फ्रैच
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.