Intro

Sesuatu yang saya mainkan dalam matematika rekreasional adalah konstruksi tabel pembagi untuk secara visual membandingkan / membedakan pembagi utama dari sekumpulan angka. Himpunan nomor input berada di atas sebagai label kolom, pembagi utama berada di sebelah kiri sebagai label baris, dan tanda menunjukkan di mana keduanya berbaris.

Sebagai contoh, untuk input, 6, 9, 14, 22sebuah tabel yang mirip dengan yang berikut akan dibangun:

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

Ini karena 6memiliki pembagi utama 2dan 3, 9memiliki pembagi utama 3, dan sebagainya.

Konstruksi

• Tabel ini dibangun sedemikian rupa sehingga angka-angka input membentuk label kolom yang dipisahkan oleh spasi dan dalam urutan menaik (Anda dapat mengasumsikan mereka sudah dipilah sebelumnya), dan pembagi utama terdaftar di sebelah kiri dalam urutan menaik satu per baris yang membentuk baris label.
• Perhatikan bahwa spasi utama pada pembagi utama dan nomor input mungkin diperlukan jika jumlahnya panjang yang berbeda, sehingga semua kolom memiliki lebar yang sama dan berbaris dengan tepat.
• Setiap pembagi diwakili oleh satu *(atau karakter ASCII lain yang sesuai pilihan Anda, asalkan karakter yang sama digunakan untuk semua kejadian).
• Banyak pembagi diabaikan (mis., 3 x 3 = 9Tetapi hanya ada satu *untuk persimpangan itu).
• The *dapat ditempatkan di manapun horizontal dalam kolom, asalkan itu tidak ambigu (saya memiliki semua contoh saya dengan *benar-blok).

Memasukkan

• Daftar bilangan bulat positif dalam format apa pun yang nyaman , masing-masing >1.
• Anda dapat mengasumsikan bahwa input sudah dipilah sebelumnya.
• Input dijamin hanya memiliki nilai unik.

Keluaran

Representasi seni ASCII yang dihasilkan dari tabel pembagi utama.

Aturan

• Leading atau trailing newlines atau whitespace semuanya opsional, asalkan karakter itu sendiri berbaris dengan benar.
• Jika lebih pendek memiliki garis pembagi yang memisahkan judul kolom / baris dari data tabular, itu diperbolehkan juga.
• Program lengkap atau fungsi dapat diterima. Jika suatu fungsi, Anda dapat mengembalikan output daripada mencetaknya.
• Jika memungkinkan, harap sertakan tautan ke lingkungan pengujian online sehingga orang dapat mencoba kode Anda!
• Celah standar dilarang.
• Ini adalah kode-golf sehingga semua aturan golf biasa berlaku, dan kode terpendek (dalam byte) menang.

Contohnya

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 byte

Terima kasih kepada ngenisis karena telah menghemat 11 byte!

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

The ∣karakter sekitar sepertiga dari jalan melalui adalah U + 2223 (3 byte). Fungsi tanpa nama dari sejumlah variabel argumen, yang masing-masing adalah bilangan nol, yang mengembalikan TableFormobjek (output yang diformat) seperti:

f=#&@@@FactorInteger[1##]mendefinisikan fsebagai himpunan semua bilangan prima yang membagi salah satu input (ekuivalen, membagi produk mereka 1##), sedangkan gdaftar terdiri dari input. Outer[If[#∣#2,Y,""]&,f,g]membuat tabel Ys dan string kosong yang berkaitan dengan keterbagian (kami menggunakan token yang tidak ditentukan Yalih-alih string "Y"atau "*"untuk menyimpan dua byte). Kemudian kita gunakan TableForm[...,TableHeadings->‌{f,g}]untuk memformat array yang dihasilkan dengan judul baris dan kolom yang sesuai.

Pengajuan sebelumnya:

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

Jelly , 18 byte

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

Menggunakan 1alih-alih *, sebagaimana diizinkan oleh aturan.

Cobalah online!

Bagaimana itu bekerja

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.

Jelly , 25 23 byte

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

Cobalah online!

Bagaimana?

Mungkin lebih pendek untuk menggunakan ÆEdan menyaring baris kosong.

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 byte

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

Saya pikir pendekatan ini sekarang secara permanen telah melampaui pendekatan rekursif (saat ini 178 byte):

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

Penggunaan 0di tempat *, yang diizinkan oleh tantangan.

Cuplikan tes

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 byte

Beralih ke Python 2 untuk penanganan input yang lebih mudah dan memungkinkan `` untuk konversi string. Penggunaan gmpy2untuk menghasilkan perdana berikutnya. Format output masih berdasarkan pada pengajuan Python 3 sebelumnya (lihat di bawah), yaitu mengisi daftar gdengan simbol dan memformatnya.

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

Cobalah online!

Penjelasan

Bagi mereka yang tidak ingin men-decode sendiri.

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
)

Sebelumnya

Python 3 - 251 byte

Cukup yakin seseorang bisa berbuat lebih baik. Berdasarkan jawaban ini untuk menghasilkan bilangan prima < 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',' '))

Versi dan penjelasan yang tidak dikelompokkan akan mengikuti.

Mathematica, 165 byte

Agak verbose - mungkin seseorang dapat melakukan sesuatu dengannya:

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

Utilitas Bash + GNU, 134 133 132 125 123 byte

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
}

Cobalah online!

Python 2 , 181 179 byte

^{-2 byte berkat FlipTack}

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

Input harus berupa tuple.
Cobalah online!

Batch, 451 byte

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

Penjelasan: Mulai dengan menghitung lebar bidang wmelalui nilai input maksimum m. Menghasilkan baris pertama dari output dengan mengisi string kosong dan memasukkan angka ke lebar wmenggunakan subrutin t. Kemudian loop melalui bilangan bulat mulai dari 2, menghasilkan garis output dengan mengisi bilangan bulat dan kemudian memanggil subrutin cuntuk mengisi string kosong atau tanda bintang yang sesuai untuk setiap nilai, namun garis yang dihasilkan kemudian dilewati jika tidak mengandung tanda bintang. Sebagai output yang dihasilkan, setiap nilai dibagi oleh integer hingga akan meninggalkan sisa, sehingga loop berakhir ketika tidak ada nilai yang lebih besar dari 1.

Perhatikan bahwa set v=dijalankan setelah itu %v%diganti ke dalam forlingkaran pada baris yang sama.

Python 2 , 157 148 146 145 143 byte

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]

Menggunakan 0alih-alih *, sebagaimana diizinkan oleh aturan.

Cobalah online!

Latar Belakang

Untuk mengidentifikasi bilangan prima, kami menggunakan wajar teorema Wilson :

Bagaimana itu bekerja

Baris pertama mendefinisikan fungsi pembantu.

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

p mengambil sejumlah variabel argumen yang disimpan dalam tuple t .

The '%%%ds '%len(`x[-1]`)menggunakan format string untuk membangun format string; %%adalah tanda persen literal, %dadalah placeholder untuk bilangan bulat yang len(`x[-1]`)mengembalikan, yaitu jumlah digit elemen terakhir dalam x (input, belum didefinisikan), dan s literal.

Jika, misalnya, elemen terakhir x memiliki tiga digit, ini menghasilkan %3s , yang *len(t)berulang satu kali untuk setiap elemen x . Akhirnya, %tterapkan format string itu ke tuple t , membangun string elemen t , dipisahkan oleh ruang dan semuanya dibenarkan dengan panjang tertentu.

Baris kedua mendefinisikan pengiriman aktual: fungsi f yang mengambil daftar x sebagai input. Setelah mengganti execpernyataan, yang mengeksekusi string yang mendahului x[-1]kali, dengan forloop, kita mendapatkan kode berikut.

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

Pertama, f menginisialisasi k dan m ke 1 . Perhatikan bahwa (k - 1)! = 0! = 1 = m .

Kemudian, p(' ',*x)cetak spasi dan bilangan bulat dalam x , menggunakan fungsi hlm .

Sekarang, kita memasuki loop untuk mencetak sisa output.

Pertama, r=[n%k and' 'for n in x]buat daftar sisa dari setiap bilangan bulat n di x dibagi dengan k . Sisa positif, yaitu sisa yang tidak sesuai dengan kelipatan k , adalah benar dan diganti dengan spasi oleh and' '.

Selanjutnya, kita membangun m%k*r. Sejak m = (k - 1)! , oleh akibat wajar teorema Wilson, ini hanya akan r jika k adalah prima, tetapi daftar kosong jika tidak. Jika ada setidaknya satu 0 dalam hasil, yaitu, jika k adalah bilangan prima dan setidaknya satu bilangan bulat dalam x dapat dibagi dengan k , 0in m%k*rakan mengembalikan True dan p(k,*r)dipanggil, mencetak k dan indikator yang dapat dibagi: 0jika dibagi, spasi jika tidak .

Akhirnya, kita mengalikan m dengan k² dan selisih k , jadi kualitasnya m = (k - 1)! terus bertahan.

MATL , 31 byte

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

Ini menggunakan 1alih-alih *, sebagaimana diizinkan oleh tantangan.

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan ( kedaluwarsa )

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

Racket 176 byte

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

Tidak Terkumpul:

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

Pengujian:

(f '(6 9 14 22))

Keluaran:

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