सकारात्मक पूर्णांक की एक सरणी को देखते हुए, इन पूर्णांकों के विभिन्न प्रमुख कारकों का एक स्थिर सरणी आउटपुट। दूसरे शब्दों में, इनपुट में प्रत्येक पूर्णांक के लिए, इसके प्रमुख कारक प्राप्त करते हैं, उन्हें क्रमबद्ध करते हैं, और आउटपुट में पहले से न होने वाले किसी भी अपराधों को जोड़ते हैं।

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

[1,2,3,4,5,6,7,8,9,10] -> [2,3,5,7]
[10,9,8,7,6,5,4,3,2,1] -> [2,5,3,7]
[100,99,98,1,2,3,4,5] -> [2,5,3,11,7]
[541,60,19,17,22] -> [541,2,3,5,19,17,11]
[1,1,2,3,5,8,13,21,34,45] -> [2,3,5,13,7,17]
[6,7,6,7,6,7,6,5] -> [2,3,7,5]
[1] -> []
[8] -> [2]
[] -> []

आउटपुट एक सरणी या पूर्णांक या स्ट्रिंग्स की सूची के रूप में हो सकता है, सीमांकित आउटपुट, या संख्याओं की एक आदेशित सूची को आउटपुट करने का कोई अन्य मानक साधन।

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

code-golf array-manipulation primes

— स्टीफन
स्रोत

सैंडबॉक्स

— स्टीफन

5

यह उन चुनौतियों में से एक है जो मुझे लगता है कि "बहुत सरल" है। लगभग हर उत्तर वाला इनमें से एक जैसा दिखता है: (ए) इनपुट पर एक लूप, और सशर्त परिशिष्ट के साथ ये ओल्ड प्राइम फैक्टराइजेशन कोड; (b) चार बिल्ट-इन की एक श्रृंखला। रचनात्मकता के लिए बस ज्यादा जगह नहीं है। हो सकता है कि उत्तर मुझे गलत साबित करेंगे, लेकिन मुझे इसमें संदेह है। यहाँ अभाज्य गुणनखंड की तुलना में गोल्फ बहुत कम है, और यह मृत्यु के लिए किया गया है।

— लिन

1

@ लीन यह गोल्फिंग लैंग्स के लिए तुच्छ है, लेकिन लगभग सभी चीजों के लिए गैर-तुच्छ है। यकीन नहीं होता है कि यहाँ तुच्छता के लिए आधार है: /

— स्टीफन

क्या आप मुझे बता सकते हैं कि 1 के "अलग प्रमुख कारक" कौन से हैं?

— 1942 पर J42161217

1

@DigitalTrauma हाँ। अन्यथा यह सिर्फ "इनपुट के सभी प्रमुख कारकों का सेट आउटपुट" होगा

— स्टीफन

9

05AB1E , 3 बाइट्स

स्ट्रिंग्स की सूची के रूप में आउटपुट।

f˜Ù

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

2sable , 3 बाइट्स

हां, यह 2sable में भी काम करता है। इसके अलावा स्ट्रिंग्स की एक सूची देता है।

f˜Ù

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

— मिस्टर एक्सकोडर
स्रोत

6

हह… f U। इसे प्यार करना।

— मैजिक ऑक्टोपस यूरन

@MagicOctopusUrn धन्यवाद :-)

— श्री एक्सकोडर

5

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

1 बाइट @Zgarb के लिए धन्यवाद बचा लिया ।

uṁp

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

व्याख्या

up पूरा कार्यक्रम।

  पी प्रत्येक के प्रमुख कारक।
 ṁ सूची पर नक्शा कार्य और परिणाम को व्यक्त करें।
यू यूनीक।

— मिस्टर एक्सकोडर
स्रोत

3

Σ†हो सकता है ṁ।

— जर्बर्ग

@Zgarb बहुत बहुत धन्यवाद। जैसा कि आप बता सकते हैं, यह मेरा पहला हस्क उत्तर है :)

— श्री एक्सकोडर

नए लोगों को भूसी का उपयोग करते हुए देखना अच्छा है। :)

— ज़र्गाब

1

@Zgarb यह बहुत अच्छा लगता है (विशेषकर जब यह जेली को बाहर निकलता है: P)

— श्री Xcoder

5

बैश + जीएनयू उपयोगिताओं, 37

@ बुरु (वाह!) की बदौलत 21 बाइट बच गईं

factor|tr \  \\n|awk '!/:/&&!a[$0]++'

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

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

1

मुझे लगता है कि इसका nl|sort|...उपयोग किया जा सकता है awk: awk '!a[$0]++'(यदि पहले नहीं देखा गया है, तो आदेश कभी नहीं खो जाता है), 15 बाइट्स की बचत। फिर sedकमांड को थोड़ी लंबी अवधि का उपयोग करके समाप्त किया जा सकता है awk: factor|awk '!/:/&&!a[$0]++' RS='[ \n]+'(रिक्त स्थान पर रिकॉर्ड को विभाजित करें और नईलाइन्स, रिकॉर्ड को छोड़ दें :), एक और 4 बाइट्स को बचाते हुए।

— मुरु ३

1

मुझे बस एहसास हुआ कि मैं पिछली टिप्पणी पर एक और दो बाइट्स का उपयोग करके बचा सकता हूं tr: factor|tr \ \\n|awk '!/:/&&!a[$0]++'(यह पहला बैकस्लैश के बाद दो स्थान है)

— muru

@ मरमू कमाल - थैंक्स! (मैं परेशान नहीं होता अगर आप इसे अपने जवाब के रूप में पोस्ट करते, तो यह मेरे मूल से काफी दूर हो जाता है)

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

4

MATL , 6 बाइट्स

"@Yfvu

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

स्पष्टीकरण:

"      % Loop over input
 @     % Push the array element
  Yf   % Prime factors
    v  % Concatenate entire stack vertically (does nothing the first iteration)
     u % Stably get distinct (unique, in MATLAB terminology) elements. Does so every loop but this is code golf, not fastest code.

दिलचस्प MATL tidbits: आम तौर पर, सभी फ़ंक्शन वैक्टर (सरणियों) पर आसानी से लागू होते हैं। लेकिन इस मामले में, प्रत्येक इनपुट के लिए कारकों की संख्या परिवर्तनशील है, और मैटलैब और विस्तार से MATL आमतौर पर केवल वर्ग मैट्रिसेस में सौदा करते हैं, इसलिए मुझे लूप के लिए उपयोग करना पड़ा "।

इसके अलावा, MATL के दो मुख्य संघटन ऑपरेटर हैं: hऔर v, क्षैतिज और ऊर्ध्वाधर संयोजन। उनका व्यवहार काफी भिन्न होता है: vपूरे स्टैक को समेटता है, भले ही हमारे पहले पुनरावृत्ति में इसका एक ही तत्व हो। hठीक दो तत्व लेता है और केवल एक ही मौजूद होने पर विफल हो जाएगा, जिससे यह इस एप्लिकेशन के लिए अनुपयुक्त हो जाएगा।

— Sanchises
स्रोत

4

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

ḋᵐ↔ᵐcd

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

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

ḋᵐoᵐcd

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

व्याख्या

ḋᵐ मुख्य अपघटन के साथ मानचित्र (जो कारकों को रिवर्स ऑर्डर में लौटाता है)।
  । प्रत्येक को उल्टा करें (या o order - प्रत्येक को क्रम दें)।
    c कॉनटैनेट (समतल)।
     d डेडुप्लिकेट।

— मिस्टर एक्सकोडर
स्रोत

4

पायथ , 5 4 बाइट्स

{smP

यहाँ यह कोशिश करो! या सभी परीक्षण मामलों को सत्यापित करें।

वैकल्पिक: {sPM

व्याख्या

{smP पूर्ण कार्यक्रम निहित इनपुट (क्यू) के साथ।
  मी इनपुट पर नक्शा।
   पी प्रमुख कारक।
 s समतल।
{डेडुप्लिकेट।

— मिस्टर एक्सकोडर
स्रोत

3

पॉवरशेल , 102 बाइट्स

param($x)$a=@();$x|%{$a+=(2..($z=$_)|?{!($z%$_)-and'1'*$_-match'^(?!(..+)\1+$)..'}|sort)};$a|select -u

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

(TessellatingHeckler के जवाब पर बॉरोअर्स फैक्टराइज़ेशन आइडिया "मेरे पीछे शैतान-प्रधान हो जाओ!"

इनपुट को शाब्दिक सरणी के रूप में लेता है $x। एक नया खाली सरणी बनाता है $a। लूप ओवर $x। प्रत्येक पुनरावृत्ति हम 2वर्तमान संख्या तक लूप करते हैं, यह जाँचते हुए कि क्या एक कारक -andप्रधान है, फिर |sortउस का आउटपुट, और इसे करने के लिए संलग्न करें $a। जब हम काम कर रहे होते हैं $x, तब हम उत्पादन करते हैं, $aलेकिन |selectकेवल -uसंख्याएँ ही होती हैं। यह इस तथ्य का फायदा उठाता है कि पहली घटना को ध्यान में रखते हुए, अद्वितीयता बाएं-दाएं जाती है, जो समस्या वर्णन से मेल खाती है। उन नंबरों को पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

— AdmBorkBork
स्रोत

3

सीजेएम, 11 बाइट्स

{:mfe__&1-}

फंक्शन जो कि इन्ट्स के अरैमेंट्स को ले जाता है और इन्ट्यूस की अरेंजमेंट को अरैस्ट करता है।

परीक्षण संस्करण

— geokavel
स्रोत

मैं कई वर्णों के साथ आउटपुट को कैसे अलग करूंगा? कम से कम मेरे (ऑनलाइन) परीक्षण के लिए, यह एक स्ट्रिंग का आउटपुट देता है, न कि इन्टस का।

— स्टीफन

एक फ़ंक्शन के रूप में, यह आउटपुट डेटाटाइप है, जो कि इन्टस की एक सरणी है। CJam स्वचालित रूप से ths स्टैक प्रिंट करता है, और यह w / o परिसीमन को प्रिंट करता है। मुझे नहीं पता कि यह आपके उद्देश्यों के लिए पर्याप्त है या नहीं। यदि आप चाहते हैं कि delimeters S*करीब ब्रैकेट के अंदर जोड़े ।

— geokavel

मेरा मानना है कि स्टैक-आधारित लंग्स वैसे भी TOS द्वारा आउटपुट कर सकते हैं, इसलिए यह ठीक है, मैं सोच रहा था। धन्यवाद।

— स्टीफन

3

गैया , 4 बाइट्स

ḍ¦_u

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

व्याख्या

each प्रत्येक के प्रमुख कारक।
  _ सूची को समतल करें।
   u डुप्लिकेट तत्वों को निकालें।

— मिस्टर एक्सकोडर
स्रोत

3

जेली , 5 4 बाइट्स

1 बाइट ताली की बदौलत।

ÆfFQ

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

— लीक नन
स्रोत

आश्चर्य नहीं था ।

— लीकी नून

मत सोचो तुम पर vectorization के लिए मजबूर करने की जरूरत है Æfताकि आप शायद के साथ एक बाइट ड्रॉप कर सकते हैं,ÆfFQ

— ताली

3

@ क्लैप आई एम ए इडियट ...

— लीक

2

Pyke , 4 बाइट्स

MPs}

यहाँ यह कोशिश करो!

व्याख्या

MP       Prime factors of each.
  s      Flatten.
   }     Deduplicate.

— मिस्टर एक्सकोडर
स्रोत

2

मैथेमेटिका, 64 बाइट्स

Select[DeleteDuplicates[First/@FactorInteger@#~Flatten~1],#>1&]&

इनपुट

[{100, 99, 98, 1, 2, 3, 4, 5}]

— J42161217
स्रोत

Select[#&@@@Gather[#&@@@Join@@FactorInteger@#],#>1&]&

— मैट्रिक्स89

2

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

import Data.List
x!y|y>x=[]|x`mod`y<1=y:(x`div`y)!y|1<2=x!(y+1)
nub.((!2)=<<)

स्पष्टीकरण:

x!yऑपरेटर रिटर्न के सभी प्रमुख कारकों में से एक सूची xहै कि अधिक से अधिक कर रहे हैं या करने के लिए बराबरy
(!2)समारोह अपने तर्क के सभी प्रमुख कारकों में से एक सूची लौटाती
अंतिम पंक्ति पर फ़ंक्शन आवश्यक कार्यक्षमता को लागू करता है

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

— क्रिस्टियन लुपस्कू
स्रोत

2

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

ḋᵐoᵐcd

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

व्याख्या

ḋᵐ         Map prime decomposition
  oᵐ       Map order
    c      Concatenate
     d     Remove duplicates

— Fatalize
स्रोत

के लिए फ़ैसला किया [10,9,8,7,6,5,4,3,2,1]। यह होना चाहिए [2, 5, 3, 7], नहीं[2, 3, 5, 7]

— श्री Xcoder

आप इसे +1 बाइट के लिए ठीक कर सकते हैं:ḋᵐoᵐcd

— श्री एक्सकोडर

@ Mr.Xcoder धन्यवाद, निश्चित। सुंदर गैर-संवेदी आवश्यकता यद्यपि।

— घातक

यह वास्तव में गैर-सनसनीखेज नहीं है, क्योंकि यह एक छोटा, थोड़ा कम तुच्छ है। मैंने अपना उत्तर भी पोस्ट किया, लेकिन मैंने ऑर्डर के बजाय पहले का उपयोग किया। निश्चित नहीं है कि प्रमुख कारक रिवर्स ऑर्डर में क्यों उत्पन्न होते हैं?

— श्री Xcoder

@ अच्छी तरह से समझें - चुनौती "सूची के विभिन्न प्रमुख कारकों को क्रमबद्ध नहीं है," यह "सूची के माध्यम से पुनरावृत्त करता है और अलग-अलग प्रमुख कारकों को जोड़ता है।"

— स्टीफन

2

ओम v2 , 3 बाइट्स

फिर भी एक और 3-बटर (ऑटो-वैश्वीकरण के साथ भाषाओं के लिए धन्यवाद)।

m{U

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

व्याख्या

मी प्रधान कारक। इनपुट पर ऑटो-वेक्टर करता है।
 {चपटा।
  यू यूनिकिफाई।

— मिस्टर एक्सकोडर
स्रोत

2

जाप , 6 बाइट्स

mk c â

झसे आज़माओ

व्याख्या

सरणी का निहित इनपुट U। प्रत्येक तत्व mके कारकों ( k) को प्राप्त करते हुए, उस पर नक्शा ( ) । समतल ( c), अद्वितीय तत्वों ( â) और अंतर्निहित आउटपुट प्राप्त करें।

— झबरा
स्रोत

2

पायथन 3 , 128 125 116 बाइट्स

यह एक शुद्ध पायथन समाधान है। कोई पैकेज नहीं। 9 बाइट बचाने के लिए हैलवार्ड का धन्यवाद।

def f(l):y=[k for i in l for k in range(2,i+1)if i%k<1*all(k%x for x in range(2,k))];print(sorted({*y},key=y.index))

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

पायथन 2 , 133 127 126 बाइट्स

def f(l):y=sum([[k for k in range(2,i+1)if i%k<1*all(k%x for x in range(2,k))]for i in l],[]);print sorted(set(y),key=y.index)

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

पायथन 2 , 142 138 134 बाइट्स

l=input();r=[]
for i in sum([[k for k in range(2,i+1)if i%k<1*all(k%x for x in range(2,k))]for i in l],[]):r+=[i]*(i not in r)
print r

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

बहुत आश्चर्य की बात है कि अभी तक कोई पायथन जवाब नहीं था। गोल्फिंग पर काम कर रहे हैं।

— मिस्टर एक्सकोडर
स्रोत

११६ बाइट्स पायथन ३

— हलवार्डम

@ हैलवर्धमेल धन्यवाद

— श्री एक्सकोडर

2

डोरस्ट , 16 बाइट्स

EDkE]l1FeFPkEQE_

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

Deorst चैटरूम में @cairdcoinheringaahing की मदद से किया गया (ध्यान दें कि समाधान अलग हैं)।

व्याख्या

EDkE] l1FeFPkEQE_ पूर्ण कार्यक्रम।

ईडी प्रत्येक तत्व के विभाजकों की सूची को धक्का देता है।
  k स्टैक को फिर से चालू करने से रोकें।
   ई] ढेर को समतल करें।
     l1Fe स्टैक से 1s निकालें (क्योंकि caird पहुंचे और 1 प्राइम बना दिया!) - भविष्य की भाषा रिलीज़ में हटा दिया जाना चाहिए।
         FP primes रखें।
           k स्टैक को फिर से चालू करने से रोकें।
            EQ डेडुप्लिकेट।
              E_ परिणाम का उत्पादन।

— मिस्टर एक्सकोडर
स्रोत

2

डोरस्ट , 16 बाइट्स

EDkE]EQFPkl1FeE_

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

@ Mr.Xcoder की मदद से किया। यह एक pseudogolfing भाषा के लिए बहुत लंबा रास्ता है।

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

EDkE]EQFPkl1FeE_ - Full program, implicit input: [1,2,3,4,5]

ED               - Get divisors. Vectorizes. STACK = [[1], [1,2], [1,3], [1,2,4], [1,5]]
  k              - Turn off sorting for the next command
   E]            - Flatten the stack. STACK = [1, 1, 2, 1, 3, 1, 2, 4, 1, 5]
     EQ          - Deduplicate stack in place. STACK = [1, 2, 3, 4, 5]
       FP        - Filter by primality 1 is considered prime. STACK = [1, 2, 3, 5]
         k       - Turn off sorting for the next command
          l1     - Push 1. STACK = [1, 2, 3, 5, 1]
            Fe   - Filter elements that are equal to the last element. STACK = [2, 3, 5]
              E_ - Output the whole stack

— केर्ड सिक्काहिरिंग
स्रोत

1

Pyke , 4 बाइट्स

mPs}

यहाँ यह कोशिश करो!

mP   -   map(factorise, input)
  s  -  sum(^)
   } - uniquify(^)

— नीला
स्रोत

आउच, मैं निंजा आपको बुरी तरह से - अच्छा हम अलग दृष्टिकोण है :)

— श्री Xcoder

: पी वन बाइट अंतर। मुझे लगता है कि इसकी अनुमति है या कम से कम पिछली सहमति के अनुसार मैंने पढ़ा

— ब्लू

हां, डुप्लिकेट उत्तर, यहां तक कि बाइट-टू-बाइट की अनुमति है

— श्री एक्सकोडर

1

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

a=input('');b=[];for c=a(a>1)b=[b setdiff(factor(c),b)];end;b

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

— rahnema1
स्रोत

1

MY, 17 बाइट्स

⎕Ḋḟ’⊢f(‘53ǵ'ƒf(ū←

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

कैसे?

⎕ मूल्यांकन किया गया इनपुट
Ḋ भाजक (वेक्टरकृत / वशीकरण)
ḟ समतल करना
’⊢f(‘वेतन वृद्धि, फ़िल्टर, वृद्धि (हटाता है 1)
53ǵ''P'MY के कोडपेज में स्ट्रिंग , जो कि प्राइमलिटी टेस्टिंग है। अफसोस 0x35=53की बात यह है कि यह 16 वां नंबर है और 16स्टैक> _ <पर धकेलने के लिए कोई कमांड नहीं है ।
ƒ एक समारोह के रूप में
f( उसके द्वारा फ़िल्टर करें
ū uniquify
← उत्पादन

— जाकारी
स्रोत

1

सी ++, 118 बाइट्स

[](auto n){decltype(n)r;for(int m:n)for(int i=1,j;i++<m;){j=m%i;for(int x:r)j|=!(i%x);if(!j)r.push_back(i);}return r;}

इनपुट को पास करने की आवश्यकता है std::vector<int> , std::vector<int>आउटपुट के लिए दूसरा रिटर्न देता है ।

— HVD
स्रोत

1

जे, 10 बाइट्स

~.(#~*),q:

मुझे यकीन है कि कुछ चतुर जे-एर इसे छोटा बना सकते हैं।

— ग्रेगरी हिगले
स्रोत

1

दरअसल , 5 बाइट्स

♂y♂i╔

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

स्पष्टीकरण:

♂y♂i╔
♂y     prime factors of each element
  ♂i   flatten
    ╔  deduplicate (stable)

— मै जाऊं
स्रोत

1

अजगर 2, 88 119 103 बाइट्स

ये रहा। सही छँटाई के साथ।

def f(l,s=[]):[s.append(x) for x in sum([list(primefac(i)) for i in l],[]) if x not in s];print s
from primefac import*

जाहिरा तौर पर मैं टीआईओ पर काम करने के लिए नहीं मिल सकता, क्योंकि पैकेज समर्थित नहीं है। यह मेरी मशीन पर चलता है। यहाँ मेरे टेस्ट आउटपुट हैं:

f([1,2,3,4,5,6,7,8,9,10],[])     #[2, 3, 5, 7]
f([10,9,8,7,6,5,4,3,2,1],[])     #[2, 5, 3, 7]
f([100,99,98,1,2,3,4,5],[])      #[2, 5, 3, 11, 7]
f([541,60,19,17,22],[])          #[541, 2, 3, 5, 19, 17, 11]
f([1,1,2,3,5,8,13,21,34,45],[])  #[2, 3, 5, 13, 7, 17]
f([6,7,6,7,6,7,6,5],[])          #[2, 3, 7, 5]
f([1],[])                        #[]
f([8],[])                        #[2]
f([],[])                         #[]

किसी तरह मैं फंक्शन को मेमना-फंक्शन नहीं बना पाया। जब भी मैं सूची को वापस करने की कोशिश करता हूं, तो यह [कोई नहीं, कोई भी, ...] देता है। अगर मैं सिर्फ कुछ अनदेखी कर रहा हूं, तो क्या कोई उस गलती को इंगित कर सकता है? प्रतिक्रिया के लिए धन्यवाद!

संपादित करें:

श्री Xcoders छँटाई एल्गोरिथ्म का उपयोग कर मैं 16 बाइट्स द्वारा कोड में कटौती कर सकता था। उस भाग के लिए धन्यवाद।

from primefac import*
def f(l):a=sum([list(primefac(i))for i in l],[]);print sorted(set(a),key=a.index)

— साइमन
स्रोत

यह सही प्रतीत नहीं होता है। दूसरा टेस्ट केस आउटपुट होना चाहिए [2, 5, 3, 7]। आउटपुट का क्रम मायने रखता है।

— मेगो

sorted(set().union(*map(primefac,l)))

— एलेक्स हॉल

आउटपुट का क्रम महत्वपूर्ण है। स्पष्टीकरण को फिर से पढ़ें, या अन्य उत्तरों को देखें - मुझे वास्तव में नहीं पता कि इसे कैसे समझा जाए।

— स्टीफन

@Stephen। सही आउटपुट के साथ अपडेटेड रूटीन। जब तक मैंने प्रत्येक पंक्ति में अंतर नहीं देखा तब तक मुझे कुछ समय लगा। पढ़ने के दौरान ध्यान केंद्रित करने से बहुत मदद मिलती है।

— साइमन

@ साइमन ने पार्स के बाद रिक्त स्थान से छुटकारा पाकर तीन बाइट्स बचाए - s.append(x) for-> s.append(x)for, primefac(i)) for-> primefac(i))for, []) if->[])if

— स्टीफन

1

ब्रिंगोल्फ , 7 बाइट्स

&(p)u=;

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

ओह देखो, यह मूल रूप से है से 4 बिल्ट-इन की एक श्रृंखला है

व्याख्या

&(p)u=;  Implicit input from commandline args
 (.)     Sandbox loop, sandboxes each item in a separate stack and runs the
         code within the loop.
&        Append the entire sandboxed stack when loop ends, rather than only the
         top of stack after each iteration
  p      Prime factors
    u    Unique
     =   Print stack
      ;  Suppress implicit output

— Skidsdev
स्रोत

के लिए विफल रहता है [10,9,8,7,6,5,4,3,2,1]। - आदेश मायने रखता है: आपको [2, 5, 3, 7]इसके बजाय वापस लौटना चाहिए [2, 3, 5, 7]।

— श्री एक्सकोडर

हालांकि आप -1 बाइट के लिए इसे ठीक कर सकते हैं । चूँकि Kयहाँ केवल नुकसान करता है।

— श्री एक्सकोडर

@ Mr.Xcoder ओह ठीक है, एहसास नहीं हुआ कि वे होने के क्रम में होने वाले थे, आरोही क्रम नहीं। फिक्स्ड

— स्किड्सदेव

1

एपीएल (Dyalog विस्तारित) , 4 बाइट्स ^SBCS

∪∘∊⍭

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

— voidhawk
स्रोत

एरे फैक्टराइजेशन

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

05AB1E , 3 बाइट्स

2sable , 3 बाइट्स

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

व्याख्या

बैश + जीएनयू उपयोगिताओं, 37

MATL , 6 बाइट्स

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

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

व्याख्या

पायथ , 5 4 बाइट्स

व्याख्या

पॉवरशेल , 102 बाइट्स

सीजेएम, 11 बाइट्स

गैया , 4 बाइट्स

व्याख्या

जेली , 5 4 बाइट्स

Pyke , 4 बाइट्स

व्याख्या

मैथेमेटिका, 64 बाइट्स

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

स्पष्टीकरण:

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

व्याख्या

ओम v2 , 3 बाइट्स

व्याख्या

जाप , 6 बाइट्स

व्याख्या

पायथन 3 , 128 125 116 बाइट्स

पायथन 2 , 133 127 126 बाइट्स

पायथन 2 , 142 138 134 बाइट्स

डोरस्ट , 16 बाइट्स

व्याख्या

डोरस्ट , 16 बाइट्स

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

Pyke , 4 बाइट्स

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

MY, 17 बाइट्स

कैसे?

सी ++, 118 बाइट्स

जे, 10 बाइट्स

दरअसल , 5 बाइट्स

अजगर 2, 88 119 103 बाइट्स

ब्रिंगोल्फ , 7 बाइट्स

व्याख्या

एपीएल (Dyalog विस्तारित) , 4 बाइट्स SBCS

एपीएल (Dyalog विस्तारित) , 4 बाइट्स ^SBCS