giriş

Rekreasyon matematiğinde oynadığım bir şey, bir dizi sayının asal bölenlerini görsel olarak karşılaştırmak / karşılaştırmak için bir bölen masasının yapımıydı. Giriş numarası kümesi sütun etiketleri olarak üstte, asal bölenler satır etiketleri olarak soldadır ve bir işaret iki sıranın nerede olduğunu gösterir.

Örneğin, giriş 6, 9, 14, 22için aşağıdakine benzer bir tablo oluşturulur:

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

Bunun nedeni 6bir asal bölenler vardır 2ve 3, 9bir asal bölenler vardır 3böylece, vb.

İnşaat

• Tablo, girdi numaralarının boşluklarla ve artan sırada ayrılan sütun etiketlerini oluşturacak şekilde oluşturulur (önceden sıralandıklarını varsayabilirsiniz) ve asal bölenler solda sıradaki satırı oluşturan her satırda artan sırada listelenir. etiketler.
• Astar bölücülerindeki ana boşlukların ve giriş numaralarının, sayılar farklı uzunluklarda olması gerektiğine dikkat edin, böylece tüm sütunlar aynı genişlikte ve doğru şekilde sıralanırlar.
• Her bölen, tek bir *karakterle (veya aynı karakter tüm oluşumlar için kullanıldığı sürece, seçtiğiniz bir ASCII karakteri ile temsil edilir ).
• Çoklu bölenler yoksayılır (örneğin, 3 x 3 = 9ancak *bu kesişme için yalnızca bir tane var ).
• *Kadar uzun net olduğu gibi (ben bütün örnekler var, sütundaki herhangi bir yere yatay olarak yerleştirilebilir *sağa hizalı).

Giriş

• Her biri uygun biçimde pozitif tamsayıların listesi >1.
• Girişin önceden sıralandığını varsayabilirsiniz.
• Girişin yalnızca benzersiz değerlere sahip olması garanti edilir.

Çıktı

Sonuçta elde edilen ASCII sanat bölücü masasının temsili.

kurallar

• Lider ya da izleyen yeni satırlar ya da boşluklar, karakterlerin kendileri doğru bir şekilde hizalandığı sürece isteğe bağlıdır.
• Sütun / satır başlıklarını tablo verilerinden ayıran bir ayırma çizgisine sahip olmak daha kısaysa, buna da izin verilir.
• Tam bir program veya bir işlev kabul edilebilir. Bir işlev varsa, çıktıyı yazdırmak yerine geri gönderebilirsiniz.
• Mümkünse, lütfen insanların kodunuzu deneyebilmesi için çevrimiçi bir test ortamına bir bağlantı ekleyin!
• Standart boşluklar yasaktır.
• Bu kod-golf olduğundan, tüm normal golf kuralları geçerlidir ve en kısa kod (bayt cinsinden) kazanır.

Örnekler

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           *

Mathematica, 101 90 bayt

11 byte tasarruf için ngenisis teşekkürler!

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

Geçiş ∣yolunun yaklaşık üçte biri U + 2223'tür (3 bayt). Her biri sıfır olmayan bir tamsayı olan değişken sayıdaki argümanların adsız işlevi, şöyle bir TableFormnesne döndürür (çıktı biçimlendirilmiş):

f=#&@@@FactorInteger[1##]fGirdilerden herhangi birini bölen (eşdeğer, ürünlerini bölerek 1##) tüm prim'lerin kümesini tanımlar , girdilerden goluşan liste ise . bölünebilirliğe tekabül eden bir s ve boş dizge Outer[If[#∣#2,Y,""]&,f,g]tablosu yapar (bir dize yerine Ytanımsız göstergeyi Ykullanırız "Y"veya "*"iki bayt tasarruf ederiz ). Daha sonra TableForm[...,TableHeadings->‌{f,g}]elde edilen diziyi uygun satır ve sütun başlıkları ile biçimlendirmek için kullanırız .

Önceki gönderi:

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

Jöle , 18 bayt

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

Kuralların izin verdiği şekilde 1yerine kullanır *.

Çevrimiçi deneyin!

Nasıl çalışır

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.

Jöle , 25 23 bayt

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

Çevrimiçi deneyin!

Nasıl?

ÆEBoş satırları kullanmak ve filtrelemek daha kısa olabilir .

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

JavaScript (ES6), 264 260 ... 179 173 bayt

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

Bence bu yaklaşım kalıcı olarak özyinelemeyi (şu anda 178 byte) aştı:

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

Mücadelenin izin verdiği 0yerde kullanır *.

Test pasajı

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

Python 2 - 197 bayt

Daha kolay girdi kullanımı ve dize dönüşümü için `` izin vermek için Python 2'ye geçildi. gmpy2Bir sonraki üssü oluşturmak için kullanır . Çıktı formatı hala önceki Python 3 gönderimine dayanmaktadır (aşağıya bakınız), yani bir listeyi gsembollerle doldurmak ve biçimlendirmek.

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

Çevrimiçi deneyin!

açıklama

Kendileri çözmek istemeyenler için.

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
)

Önceki

Python 3 - 251 bayt

Birisinin daha iyisini yapabileceğinden eminim. Asalları üretmek için bu cevaba dayanarak 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 versiyonu ve açıklaması takip edecek.

Mathematica, 165 bayt

Oldukça ayrıntılı - belki birileri onunla bir şeyler yapabilir:

(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}]]]])&

Bash + GNU yardımcı programları, 134 133 132 125 123 bayt

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
}

Çevrimiçi deneyin!

Python 2 , 181 179 bayt

^{FlipTack sayesinde -2 bayt}

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

Giriş bir demet olmalıdır.
Çevrimiçi deneyin!

Toplu iş, 451 bayt

@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%%%

Açıklama: Alan genişliğini wgiriş değerlerinin maksimum değeri ile hesaplayarak başlar m. Boş bir dize ve girdi numaralarını walt yordamı kullanarak genişliğe yayarak doldurma ile ilk çıktı satırını oluşturur t. Sonra, 2'den başlayarak tam sayılar arasında dolaşır, tam sayıyı yastırarak çıkış hattını oluşturur ve sonra alt rutini cher değer için uygun olarak boş bir dize ya da yıldız işareti doldurmaya çağırır , ancak oluşturulan satır daha sonra yıldız işareti içermiyorsa atlanır. Çıktı üretilirken, her değer bir geri kalanı bırakana kadar tam sayıya bölünür, böylece döngü 1'den büyük bir değer olmadığında sona erer.

Aynı satırdaki döngüye ikame set v=edildikten sonra yapılan işlemlerin not alın .%v%for

Python 2 , 157 148 146 145 143 bayt

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]

Kuralların izin verdiği şekilde 0yerine kullanır *.

Çevrimiçi deneyin!

Arka fon

Asalları tanımlamak için, Wilson teorisinin bir sonucunu kullanırız :

Nasıl çalışır

İlk satır bir yardımcı işlevi tanımlar.

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

p , t dosyasında sakladığı değişken sayıdaki argümanları alır .

'%%%ds '%len(`x[-1]`)Bir dizgi formatı oluşturmak için bir dizgi formatı kullanır; %%değişmez yüzde işaretidir, %dtamsayıyı x cinsinden len(`x[-1]`)döndüren tamsayı için bir yer tutucudur , yani son öğenin basamak sayısını x (henüz tanımlanmamış girdi) ve s değişmezdir.

Örneğin, x'in son elemanı üç hane sahipse, bu , x'in her elemanı için bir kez tekrar %3s eden *len(t)verimdir . Son olarak, bu format dizesini t dizgesine uygular , t öğelerinin bir dizesini oluşturarak , boşlukla ayrılmış ve tümü belirli bir uzunlukta sağa yaslanır.%t

Bir fonksiyonu: ikinci hat gerçek gönderme tanımlayan f listesi alır x girdi olarak kullanılmaktadır. execÖncesinde dize yürüten ifadeyi değiştirdikten sonra x[-1], bir fordöngü ile aşağıdaki kodu alırız.

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

İlk olarak, f başlatılırken k ve m ile 1 . Şunu not edin (k - 1)! = 0! = 1 = m .

Ardından, p işlevini kullanarak p(' ',*x)bir boşluk ve tamsayıları x olarak yazdırır .

Şimdi, kalan çıktıyı yazdırmak için döngüye giriyoruz.

İlk olarak, r=[n%k and' 'for n in x]her bir tam sayıdır kalanlarından listesini oluşturur n de x bölünmesiyle k . Pozitif kalanlar, yani, k'nın katlarına karşılık gelmeyen kalanlar , sıra dışıdır ve bir boşlukla değiştirilirler and' '.

Daha sonra inşa ederiz m%k*r. M = (k - 1) 'den beri ! Wilson teoreminin bir sonucu olarak, eğer k en iyiyse basitçe r , eğer değilse boş bir liste olacaktır. Sonuçta en az bir 0 varsa, yani, eğer k asal ise ve x in en az bir tamsayısı k ile bölünebiliyorsa , True döndürür ve çağrılır, k ve bölünebilirlik göstergelerini yazdırır : eğer bölünebilir ise, boşluk .0in m%k*rp(k,*r)0

Son olarak, biz çarpın m tarafından k² ve artım k kalitesi bu yüzden, (- 1 k) = m! tutmaya devam ediyor.

MATL , 31 bayt

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

Bu , meydan okumaların izin verdiği şekilde kullanmak 1yerine kullanır *.

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

Açıklama ( eski )

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

Raket 176 bayt

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

Test yapmak:

(f '(6 9 14 22))

Çıktı:

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