प्रधान विभाजक तालिका

Question

पहचान

मनोरंजक गणित में मैंने जो कुछ खेला है, वह संख्याओं के समूह के प्रमुख विभाजकों की तुलना / विपरीत करने के लिए एक विभाजक तालिका का निर्माण किया गया है। स्तंभ संख्याओं के रूप में इनपुट संख्याओं का समूह शीर्ष पर है, प्रमुख विभाजक पंक्ति लेबल्स के रूप में बाईं ओर हैं, और एक चिह्न इंगित करता है कि दोनों कहां पंक्तिबद्ध हैं।

उदाहरण के लिए, इनपुट के 6, 9, 14, 22लिए निम्न के समान तालिका का निर्माण किया जाएगा:

    6  9 14 22
 2  *     *  *
 3  *  *
 7        *
11           *

इसका कारण यह है है 6के प्रमुख divisors है 2और 3, 9के प्रमुख divisors है 3, और इतने पर।

निर्माण

• तालिका का निर्माण इस प्रकार किया जाता है कि इनपुट नंबर कॉलम कॉलम बनाते हैं जो रिक्त स्थान और आरोही क्रम में अलग हो जाते हैं (आप मान सकते हैं कि वे पूर्व-क्रमबद्ध हैं), और प्रधान विभाजक बाईं ओर आरोही क्रम में सूचीबद्ध हैं प्रति पंक्ति एक पंक्ति बनाते हुए लेबल।
• ध्यान दें कि यदि नंबर अलग-अलग लंबाई के हों, तो प्राइम डिविजर्स और इनपुट नंबरों पर अग्रणी स्थान की आवश्यकता हो सकती है, ताकि सभी कॉलम एक ही चौड़ाई के हों और उचित रूप से पंक्तिबद्ध हों।
• प्रत्येक भाजक को *आपके चयन के एकल (या अन्य उपयुक्त ASCII चरित्र) द्वारा दर्शाया जाता है , इसलिए जब तक कि सभी अर्थों के लिए उसी वर्ण का उपयोग नहीं किया जाता है)।
• एकाधिक विभाजकों को अनदेखा किया जाता है (उदाहरण के लिए, 3 x 3 = 9लेकिन *उस चौराहे के लिए केवल एक ही है )।
• *कॉलम में कहीं भी क्षैतिज रखा जा सकता है, जब तक यह स्पष्ट है के रूप में (मैं के साथ सभी मेरे उदाहरण है *दाएँ संरेखित)।

इनपुट

• किसी भी सुविधाजनक प्रारूप में सकारात्मक पूर्णांक की एक सूची , प्रत्येक>1 ।
• आप मान सकते हैं कि इनपुट पूर्व-सॉर्ट किया गया है।
• इनपुट में केवल अनन्य मान होने की गारंटी है।

उत्पादन

परिणामी ASCII कला का प्रतिनिधित्व प्रमुख भाजक तालिका।

नियम

• लीडिंग या अनुगामी newlines या व्हाट्सएप सभी वैकल्पिक हैं, जब तक कि वर्ण खुद को सही ढंग से पंक्तिबद्ध करते हैं।
• यदि यह विभक्त रेखा को स्तंभ / पंक्ति शीर्षकों को सारणीबद्ध डेटा से अलग करने के लिए छोटा है, तो इसकी भी अनुमति है।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• यदि संभव हो, तो कृपया ऑनलाइन परीक्षण वातावरण का लिंक शामिल करें ताकि लोग आपके कोड को आज़मा सकें!
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

उदाहरण

6,9,14,22

    6  9 14 22
 2  *     *  *
 3  *  *
 7        *
11           *


2,3,5,7

  2 3 5 7
2 *
3   *
5     *
7       *

2,4,8,16,32

   2  4  8 16 32
2  *  *  *  *  *

75,99,151,153

     75  99 151 153
  3   *   *       *
  5   *
 11       *
 17               *
151           *

Comments

क्या शीर्ष पंक्ति और बाएँ स्तंभ के बाद हमारे पास विभक्त रेखाएँ हो सकती हैं?

— नगीनिस

@ngenisis ज़रूर, मैं इसकी अनुमति दूंगा। तालिका का सटीक सूत्रीकरण बहुत खुला है, क्योंकि यह इस चुनौती का सटीक जोर नहीं है।

— AdmBorkBork

Answer 1

गणितज्ञ, १०१ 90 बाइट्स

11 बाइट बचाने के लिए ngenisis के लिए धन्यवाद!

TableForm[Outer[If[#∣#2,Y,""]&,f=#&@@@FactorInteger[1##],g={##}],TableHeadings->‌{f,g}]&

∣जिस तरह के माध्यम से लगभग एक तिहाई चरित्र U + 2223 (3 बाइट्स) है। तर्कों की एक चर संख्या का कार्य, जिनमें से प्रत्येक एक गैर-पूर्णांक है, जो एक TableFormवस्तु (स्वरूपित आउटपुट) को इस तरह लौटाता है :

f=#&@@@FactorInteger[1##]fकिसी भी इनपुट (समान रूप से, उनके उत्पाद को विभाजित करते 1##हुए) को विभाजित करने वाले सभी अपराधों के सेट को परिभाषित करता है , जबकि gसूची में इनपुट शामिल हैं। Outer[If[#∣#2,Y,""]&,f,g]की एक तालिका बनाता हैYविभाजन के अनुरूप एस और खाली तारों (हम Yएक स्ट्रिंग के बजाय अपरिभाषित टोकन का उपयोग करते हैं "Y"या "*"दो बाइट्स को बचाने के लिए)। फिर हम TableForm[...,TableHeadings->‌{f,g}]परिणामी सरणी को उपयुक्त पंक्ति और स्तंभ शीर्षों के साथ प्रारूपित करने के लिए उपयोग करते हैं ।

पिछला सबमिशन:

Grid[p=Prepend;Thread[q[Outer[If[#∣#2,Y,""]&,f=#&@@@FactorInteger[1##],g={##}]~p~g,f~p~""]]/.q->p]&

Comments

आप पहले छोड़ सकते हैं ""।

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

TableForm[Outer[If[#∣#2,Y,""]&,f=#&@@@FactorInteger[1##],g={##}],TableHeadings->{f,g}]&यदि डिवाइडर की अनुमति है

— ngenisis

और दूसरा अगर आप इसे बदलते हैं p[f,]।

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

हेडर को अलग करने के लिए ग्रिड लाइनों की अनुमति है।

— AdmBorkBork

TableFormअच्छा है, उम्मीद है कि मेरे टूलबॉक्स में रहेगा!

— ग्रेग मार्टिन

Answer 2

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

PÆfQ0;ðḍ€+W}⁸;"o⁶G

नियमों के अनुसार अनुमति के 1बजाय उपयोग करता *है।

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

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

PÆfQ0;ðḍ€+W}⁸;"o⁶G  Main link. Argument: A (array of integers greater than 1)

P                   Take the product of the integers in A.
 Æf                 Compute all prime factors (with multiplicity) of the product.
   Q                Unique; deduplicate the prime factors.
    0;              Prepend a 0. Let's call the result P.
      ð             Begin a new, dyadic chain. Left argument: P. Right argument: A
       ḍ€           Divisible each; for each p in P, test all integers in A for
                    divisibility by P. Yields one row of the shape of A for each p.
                    Note that the first element of P is 0, so the first row of the
                    resulting matrix contains only zeroes.
          W}        Wrap right; yield [A].
         +          Add the results to both sides. Because of how Jelly's auto-
                    vectorization works, this adds the first row of [A] (just A) to
                    the first row of the divisibility matrix (all zeroes) and
                    leaves the other rows untouched.
            ⁸;"     Prepend the elements of P to the corresponding rows of the
                    previous result.
               o⁶   OR space; replace all zeroes with spaces.
                 G  Grid; format the matrix as requested in the challenge spec.

Answer 3

जेली , 25 23 बाइट्स

PÆfQ©ḍþµị⁾* ³;"Z⁶;®¤;"G

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

कैसे?

यह अच्छी तरह ÆEसे खाली पंक्तियों का उपयोग करने और फ़िल्टर करने के लिए छोटा हो सकता है ।

PÆfQ©ḍþµị⁾* ³;"Z⁶;®¤;"G - Main link: list of numbers, L
       µ                - monadic chain separation
P                       - product of L - multiply them all together
 Æf                     - prime factors (with repetitions, in ascending order)
   Q                    - unique items, maintaining order
                              - note that the product was performed to keep order
    ©                   - place in the register for later use, and yield
      þ                   - form the outer product of that and L using the dyad:
     ḍ                  -     isDivisor - 1 if divides, 0 if not
        ị⁾* <space      - index into "* " (1s to "*", 0s to " ")
            ³           - program's first input, L
             ;"         - zip with concatenation (column headers to the left)
               Z        - transpose (get it around the right way)
                   ¤    - nilad followed by link(s) as a nilad
                ⁶;®     - space (⁶) concatenated with (;) the register value (®)
                    ;"  - zip with concatenation (row labels to the left)
                      G - format the result as a grid (join items with spaces and
                                               rows with line feeds so they align)
                        - implicit print

Answer 4

जावास्क्रिप्ट (ईएस 6), 264 260 ... 179 173 बाइट्स

a=>[for(c of s=' '.repeat(w=a.slice(-1),i=0))if(!+(r=[i++?i:s,...i<2?a:a.map(x=>x%i&&c)].map(y=>(s+y).slice(-(w+1).length),a=a.map(d=x=>i<2|x%i?x:d(x/i))).join``))r].join`
`

मुझे लगता है कि यह दृष्टिकोण अब स्थायी रूप से पुनरावर्ती से अधिक हो गया है (वर्तमान में 178 बाइट्स):

f=(a,i=0,w=a.slice(-1))=>i++-w?(+(r=[i<2?'':i,...i<2?a:a.map(x=>x%i&&' ')].map(y=>(' '.repeat(w)+y).slice(-(w+1).length)).join``)?'':r+`
`)+f(a.map(d=x=>i<2|x%i?x:d(x/i)),i,w):''

के 0स्थान पर उपयोग करता है *, जिसे चुनौती द्वारा अनुमति दी जाती है।

टेस्ट स्निपेट

let g =

a=>[for(c of s=' '.repeat(w=a.slice(-1),i=0))if(!+(r=[i++?i:s,...i<2?a:a.map(x=>x%i&&c)].map(y=>(s+y).slice(-(w+1).length),a=a.map(d=x=>i<2|x%i?x:d(x/i))).join``))r].join`
`

console.log(g([6,9,14,22]))
console.log(g([2,3,5,7]))
console.log(g([2,4,8,16,32]))
console.log(g([75,99,151,153]))

Comments

अगर मैं गलत नहीं हूं, तो आप |ऑपरेटर का उपयोग कर सकते हैं यदि आप बयान कर रहे हैं, क्योंकि आप 2 बूलियन की तुलना कर रहे हैं ...

— लूका

@ ल्यूक अरे, तुम सही हो। यकीन नहीं होता कि मैं कैसे चूक गया

— ETHproductions

क्या यह फ़ंक्शन के i<2अंदर चेक को स्थानांतरित करने के लिए छोटा नहीं है .map?

— ल्यूक

@Luke यदि आप परिवर्तन ...i<2?a:a.map(x=>x%i&&c)का मतलब है ...a.map(x=>i<2?x:x%i&&c), यह छोटा नहीं है। यदि आप इसका मतलब दूसरे में ले जाते हैं .map, तो शायद ...

— ETHproductions

Answer 5

पायथन 2 - 197 बाइट्स

आसान इनपुट हैंडलिंग और स्ट्रिंग रूपांतरण के लिए `` की अनुमति के लिए पायथन 2 पर स्विच किया गया। gmpy2अगला प्राइम जनरेट करने के लिए उपयोग करता है । आउटपुट स्वरूप अभी भी पिछले पायथन 3 सबमिशन (नीचे देखें) पर आधारित है, अर्थात् gप्रतीकों के साथ एक सूची को भरना और उसे प्रारूपित करना।

import gmpy2
i=input()
n=len(i)+1
p=1;g=[' ']+i
while p<i[-1]:
 p=gmpy2.next_prime(p)
 t=['*'[m%p:]for m in i]
 if'*' in t:g+=[p]+t
print((('{:>%d}'%(len(`i[-1]`)+1)*n+'\n')*(len(g)/n)).format(*g))

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

व्याख्या

उन लोगों के लिए जो इसे स्वयं डिकोड नहीं करना चाहते हैं।

import gmpy2                    # arithmetic library
i=input()
n=len(i)+1                      # saves bytes by not needing ()
                                # afterwards
p=1                             # starting number
g=[' ']+i                       # initialsing header row
while p<i[-1]:                  # looping until last character
  p=gmpy2.next_prime(p)         # get the next prime
  t=['*'[m%p:] for m in i]      # verify whether p is a 
                                # divisor of each number
  if'*'in t:g+=[p]+t            # if any divisor found, append
                                # p + divisors to g.
print(
    (('{:>%d}'%(len(`i[-1]`)+1) # compute right formatting element
                                # for length of last character + 1
        *n+'\n'                 # repeat for each input + once
                                # for the prime and add newline
     )*(len(g)/n)               # repeat row format until g
                                # can be inserted
    ).format(*g)                # format using g
)

पिछला

पायथन 3 - 251 बाइट्स

बहुत यकीन है कि कोई बेहतर कर सकता है। प्रिम्स बनाने के लिए इस उत्तर के आधार पर < k।

i=list(map(int,input().split(',')))
l=len(str(i[-1]))+1
n=len(i)+1
g=[0]+i+sum([l for l in [[k]+[j%k==0for j in i]for k in range(2,i[-1])if all(k%f for f in range(2,k))]if 1in l],[])
print((('{:>%d}'%l*n+'\n')*(len(g)//n)).format(*g).replace('0',' '))

Ungolfed संस्करण और स्पष्टीकरण का पालन करेंगे।

Comments

PPCG में आपका स्वागत है!

— AdmBorkBork

इसके बजाय i=list(map(int,input().split(','))), आप बस कर सकते हैं i=input(), और फॉर्म में इनपुट ले सकते हैं [1, 2, 3, 4]।

— nedla2004

धन्यवाद, मुझे नहीं पता था कि। लेकिन मैं इसे बाद में वैसे भी फिर से काम करने जा रहा हूं :)।

— पिज्ज़यूयूडगस्ट

आप के साथ 2 बाइट्स बचा सकते हैं p=gmpy2.next_prime(p);t=['*'[m%p:]for m in i], और अंदर जगह को हटा सकते हैं if"*" in।

— त्रीलज़वीर

Answer 6

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

बल्कि क्रिया - शायद कोई इसके साथ कुछ कर सकता है:

(j=Join;a=#[[All,1]]&/@FactorInteger@#;b=Sort@DeleteDuplicates@Flatten@a;Grid[j[{j[{""},#]},Transpose@j[{b},Table[If[MemberQ[a[[t]],#],"*",""]&/@b,{t,Length@a}]]]])&

Answer 7

बैश + जीएनयू उपयोगिताओं, 134 133 132 125 123 बाइट्स

q=printf\ ;u=$q%9s
$u
$q%9d $@
echo
for p in $($u\\n `factor $@`|bc|sort -un)
{
$q%9d $p
for x;{ ((x%p))&&$u||$u X;}
echo
}

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

Answer 8

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

^{-2 बाइट्स फ्लिपकैक को धन्यवाद}

n=input()
p=[]
t="%%%ss "%len(`n[-1]`)*-~len(n)
print t%(('',)+n)
i=2
while n[-1]/i:
 if all(i%j for j in p):
	p+=[i];s=['*'[m%i:]for m in n]
	if'*'in s:print t%tuple([i]+s)
 i+=1

इनपुट टपल होना चाहिए।
इसे ऑनलाइन आज़माएं!

Comments

all(i%j for j in p)उपयोग करने के बजाय काम करता है map?

— 22

@ फीलटैक हां, यह बेहतर था, लेकिन मैंने कुछ बात बदल दी और इस अपडेट को भूल गया

— रॉड

Answer 9

बैच, 451 बाइट्स

@echo off
set/am=0,w=2,p=1
for %%n in (%*)do set/a"n=m-%%n,m+=(n>>31)*n
for /l %%i in (0,1,9)do set/am/=10,w+=!!m
set s=
for %%n in ("" %*)do set t=%%~n&call:t
set v=%*
:g
if not %s: =%==%p% echo%s%
if %m%==1 exit/b
set/at=p+=1,m=0
set s=
call:t
set v=&for %%n in (%v%)do set n=%%n&set t=&call:c
goto g
:c
set/ar=n%%p
if %r%==0 set/an/=p&set t=*&goto c
set/a"m|=n
set v=%v% %n%
:t
set t=           %t%
call set s=%%s%%%%t:~-%w%%%

स्पष्टीकरण: wइनपुट मानों की अधिकतम के माध्यम से क्षेत्र की चौड़ाई की गणना करके शुरू होता है m। एक खाली स्ट्रिंग और चौड़ाई में इनपुट नंबर को पैडिंग करके आउटपुट की पहली पंक्ति बनाता हैwसबरूटीन का उपयोग करके बनाता है t। फिर 2 से शुरू होने वाले पूर्णांक के माध्यम से छोरों, पूर्णांक को पैडिंग करके आउटपुट की रेखा उत्पन्न करता है और फिर सबरूटीन को कॉल करता हैc को प्रत्येक मान के लिए एक खाली स्ट्रिंग या तारांकन के रूप में पैड करने के लिए , हालांकि उत्पन्न लाइन को तब छोड़ दिया जाता है जब इसमें कोई तारांकन नहीं होता है। जैसा कि आउटपुट उत्पन्न होता है, प्रत्येक मान को पूर्णांक द्वारा विभाजित किया जाता है जब तक कि यह शेष न रह जाए, इसलिए लूप तब समाप्त हो जाता है जब कोई मूल्य 1 से अधिक नहीं होता है।

ध्यान दें कि एक ही लाइन पर लूप में प्रतिस्थापित होने के बादset v= निष्पादित किया जाता है ।%v%for

Answer 10

पायथन 2 , 157 148 146 145 143 बाइट्स

def p(*t):print'%%%ds '%len(`x[-1]`)*len(t)%t
def f(x):k=m=1;p(' ',*x);exec"r=[n%k and' 'for n in x]\nif 0in m%k*r:p(k,*r)\nm*=k*k;k+=1;"*x[-1]

उपयोग 0 बजाय का है*नियमों के अनुसार अनुमति के है।

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

पृष्ठभूमि

Primes की पहचान करने के लिए, हम विल्सन के प्रमेय के एक कोरोलरी का उपयोग करते हैं :

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

पहली पंक्ति एक सहायक कार्य को परिभाषित करती है।

def p(*t):print'%%%ds '%len(`x[-1]`)*len(t)%t

p तर्कों की एक चर संख्या लेता है जो इसे tuple t में संग्रहीत करता है ।

'%%%ds '%len(`x[-1]`)एक प्रारूप स्ट्रिंग का निर्माण करने के लिए एक प्रारूप स्ट्रिंग का उपयोग करता है; %%एक शाब्दिक प्रतिशत संकेत है, %dपूर्णांक के लिए एक प्लेसहोल्डर है जो len(`x[-1]`)रिटर्न करता है, अर्थात, x में अंतिम तत्व के अंकों की संख्या (इनपुट, अभी तक परिभाषित नहीं), औरs  शाब्दिक है।

यदि, उदाहरण के लिए, x के अंतिम तत्व में तीन अंक हैं, तो यह पैदावार है %3s , जो x के*len(t) प्रत्येक तत्व के लिए एक बार दोहराता है । अंत में, उस प्रारूप स्ट्रिंग को tuple t पर लागू करता है , एक स्ट्रिंग का निर्माण करता है%t है के तत्वों करता है, अंतरिक्ष-पृथक और एक निश्चित लंबाई के लिए सभी सही-उचित।

दूसरी पंक्ति वास्तविक सबमिशन को परिभाषित करती है: एक फ़ंक्शन f जो इनपुट के रूप में एक सूची x लेता है । execकथन को प्रतिस्थापित करने के बाद , जो स्ट्रिंग को निष्पादित करता है, वह x[-1]एक forलूप के साथ होता है , हमें निम्नलिखित कोड मिलते हैं।

def f(x):
    k=m=1;p(' ',*x)
    for _ in range(x[-1]):
        r=[n%k and' 'for n in x]
        if 0in m%k*r:p(k,*r)
        m*=k*k;k+=1

सबसे पहले, f , k और m को 1 से आरंभ करता है । ध्यान दें कि (k - 1)! = 0! = 1 = मी ।

फिर, फ़ंक्शन p का उपयोग करके xp(' ',*x) में एक स्थान और पूर्णांक प्रिंट करता है ।

अब, हम शेष आउटपुट को प्रिंट करने के लिए लूप में प्रवेश करते हैं।

सबसे पहले, k द्वारा विभाजित x में r=[n%k and' 'for n in x]प्रत्येक पूर्णांक n के अवशेषों की सूची का निर्माण करता है । सकारात्मक अवशेष, यानी, ऐसे अवशेष जो कि k के गुणकों के अनुरूप नहीं हैं, सत्य हैं और एक स्थान से बदल जाते हैं ।and' '

अगला, हम निर्माण करते हैं m%k*r। चूंकि m = (k - 1)! , विल्सन के प्रमेय के परिणाम से, यह बस हो जाएगा आर अगर कश्मीर प्रधानमंत्री है, लेकिन एक खाली सूची नहीं तो। यदि परिणाम में कम से कम एक 0 है, अर्थात, यदि k अभाज्य है और x में कम से कम एक पूर्णांक k से विभाज्य है , 0in m%k*rतो True वापस आएगा और p(k,*r)कहा जाएगा, मुद्रण k और विभाज्यता संकेतक: 0यदि विभाज्य, नहीं तो एक स्थान ।

अंत में, हम गुणा मीटर से k² और वेतन वृद्धि कश्मीर , इसलिए गुणवत्ता मीटर = (k - 1)! जारी है।

Answer 11

Matl , 31 बाइट्स

pYfu!Gy\~h0GhwvVZ{'(?<!\d)0'0YX

यह उपयोग करता है 1 बजाय का है*चुनौती के अनुसार अनुमति के ।

इसे ऑनलाइन आज़माएं!या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण ( पुराना )

p           % Implictly input array of numbers. Push product of array
Yf          % Prime factors as a row vector
u           % Keep only unique values
!           % Transpose into column vector
G           % Push input again
y           % Duplicate column vector of unique prime factors onto top
\           % Modulo, element-wise with broadcast
~           % Negate
h           % Concatenate horizontally
0           % Push 0
G           % Push input again
h           % Concatenate horizontally
w           % Swap
v           % Concatenate vertically
V           % Char array representation
Z{          % Convert to cell array of strings. Each row gives a string
'(?<!\d)0'  % Push this string: match '0' not preceded by a digit
0           % Push this string: '0' will be replaced by char 0
YX          % Regexp replace
            % Implicit inoput. Char 0 is displayed as space

Answer 12

रैकेट 176 बाइट्स

(let((p printf))(display"   ")(for((x nl))(p" ~a " x))(displayln"")(for((i '(2 3 7 11)))
(p"~a  " i)(for((j nl))(if(member i(prime-divisors j))(p" * ")(p"   ")))(displayln"")))

Ungolfed:

(define (f nl)
  (let ((p printf))

    (display "   ")
    (for ((x nl))
      (p " ~a " x))
    (displayln "")

    (for ((i '(2 3 7 11)))
      (p "~a  " i)
      (for ((j nl))
        (if (member i (prime-divisors j))
            (p " * ")
            (p "   ")))
      (displayln ""))))

परिक्षण:

(f '(6 9 14 22))

आउटपुट:

    6  9  14  22 
2   *     *  * 
3   *  *       
7         *    
11            *