Giới thiệu

Một cái gì đó tôi đã chơi xung quanh trong toán học giải trí đã được xây dựng một bảng chia để so sánh trực quan / đối chiếu các ước số chính của một tập hợp số. Tập hợp các số đầu vào nằm trên cùng dưới dạng nhãn cột, các ước số nguyên tố nằm ở bên trái dưới dạng nhãn hàng và dấu cho biết vị trí của hai dòng.

Ví dụ, để nhập 6, 9, 14, 22một bảng tương tự như sau sẽ được xây dựng:

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

Điều này là bởi vì 6có ước số nguyên tố của 2và 3, 9có ước số nguyên tố 3, v.v.

Xây dựng

• Bảng được xây dựng sao cho các số đầu vào tạo thành các nhãn cột được phân tách bằng dấu cách và theo thứ tự tăng dần (bạn có thể giả sử chúng được sắp xếp trước) và các ước số nguyên tố được liệt kê ở bên trái theo thứ tự tăng dần trên mỗi dòng tạo thành hàng nhãn.
• Lưu ý rằng không gian hàng đầu trên các ước số nguyên tố và số đầu vào có thể được yêu cầu nếu các số có độ dài khác nhau, sao cho tất cả các cột có cùng chiều rộng và xếp hàng một cách thích hợp.
• Mỗi ước số được biểu thị bằng một *ký tự (hoặc ký tự ASCII phù hợp khác do bạn chọn, miễn là sử dụng cùng một ký tự cho tất cả các lần xuất hiện).
• Nhiều ước được bỏ qua (ví dụ, 3 x 3 = 9nhưng chỉ có một *cho giao điểm đó).
• Cái này *có thể được đặt ở bất cứ đâu theo chiều ngang trong cột, miễn là nó không rõ ràng (tôi có tất cả các ví dụ của mình với *căn lề phải).

Đầu vào

• Một danh sách các số nguyên dương trong bất kỳ định dạng thuận tiện , mỗi định dạng>1 .
• Bạn có thể giả định rằng đầu vào được sắp xếp trước.
• Đầu vào được đảm bảo chỉ có các giá trị duy nhất.

Đầu ra

Kết quả đại diện nghệ thuật ASCII của bảng ước số nguyên tố.

Quy tắc

• Các dòng mới hoặc dấu cách hàng đầu hoặc dấu trắng đều là tùy chọn, miễn là bản thân các ký tự xếp hàng chính xác.
• Nếu nó ngắn hơn để có một vạch chia ngăn cách các tiêu đề cột / hàng với dữ liệu dạng bảng, thì điều đó cũng được cho phép.
• Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Nếu có thể, vui lòng bao gồm một liên kết đến một môi trường thử nghiệm trực tuyến để mọi người có thể thử mã của bạn!
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

Ví dụ

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           *

Toán học, 101 90 byte

Cảm ơn ngenisis vì đã tiết kiệm 11 byte!

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

Ký ∣tự khoảng một phần ba chặng đường là U + 2223 (3 byte). Hàm không tên của một số lượng đối số khác nhau, mỗi đối số là một số nguyên khác không, trả về một TableFormđối tượng (đầu ra được định dạng) như vậy:

f=#&@@@FactorInteger[1##]định nghĩa flà tập hợp của tất cả các số nguyên tố chia bất kỳ đầu vào nào (tương đương, chia sản phẩm của chúng 1##), trong khi đó glà danh sách bao gồm các đầu vào. Outer[If[#∣#2,Y,""]&,f,g]tạo một bảng gồm Ycác chuỗi s và chuỗi rỗng tương ứng với khả năng chia hết (chúng tôi sử dụng mã thông báo không xác định Ythay vì chuỗi "Y"hoặc "*"để lưu hai byte). Sau đó, chúng tôi sử dụng TableForm[...,TableHeadings->‌{f,g}]để định dạng mảng kết quả với các tiêu đề hàng và cột thích hợp.

Trình trước:

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

Thạch , 18 byte

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

Sử dụng 1thay vì *, như được cho phép bởi các quy tắc.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

Thạch , 25 23 byte

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

Hãy thử trực tuyến!

Làm sao?

Nó cũng có thể ngắn hơn để sử dụng ÆEvà lọc ra các hàng trống.

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

Tôi nghĩ rằng cách tiếp cận này hiện đã vượt quá mức đệ quy (hiện là 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):''

Sử dụng 0thay thế *, được cho phép bởi các thách thức.

Kiểm tra đoạn

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

Chuyển sang Python 2 để xử lý đầu vào dễ dàng hơn và cho phép `` để chuyển đổi chuỗi. Sử dụng gmpy2để tạo số nguyên tố tiếp theo. Định dạng đầu ra vẫn dựa trên lần gửi Python 3 trước đó (xem bên dưới), cụ thể là điền vào danh sách gcác ký hiệu và định dạng nó.

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

Hãy thử trực tuyến!

Giải trình

Đối với những người không muốn tự giải mã nó.

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
)

Trước

Python 3 - 251 byte

Khá chắc chắn ai đó có thể làm tốt hơn. Dựa trên câu trả lời này để tạo các số nguyên tố < 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',' '))

Phiên bản Ungolfed và giải thích sẽ làm theo.

Toán học, 165 byte

Khá dài dòng - có lẽ ai đó có thể làm gì đó với nó:

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

Tiện ích 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
}

Hãy thử trực tuyến!

Python 2 , 181 179 byte

^{-2 byte nhờ 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

Đầu vào phải là một tuple.
Hãy thử trực tuyến!

Hàng loạt, 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%%%

Giải thích: Bắt đầu bằng cách tính độ rộng trường wthông qua mức tối đa của các giá trị đầu vào m. Tạo dòng đầu ra đầu tiên bằng cách đệm một chuỗi trống và các số đầu vào theo chiều rộng wbằng chương trình con t. Sau đó lặp qua các số nguyên bắt đầu từ 2, tạo ra dòng đầu ra bằng cách đệm số nguyên và sau đó gọi chương trình con cđể đệm một chuỗi rỗng hoặc dấu hoa thị phù hợp với từng giá trị, tuy nhiên, dòng được tạo sẽ bị bỏ qua nếu nó không có dấu hoa thị. Khi đầu ra được tạo, mỗi giá trị được chia cho số nguyên cho đến khi nó để lại phần còn lại, do đó vòng lặp chấm dứt khi không có giá trị nào lớn hơn 1.

Lưu ý rằng set v=được thi hành sau khi các %v%được thay ra ở forvòng lặp trên cùng một dòng.

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]

Sử dụng 0thay vì *, như được cho phép bởi các quy tắc.

Hãy thử trực tuyến!

Lý lịch

Để xác định các số nguyên tố, chúng tôi sử dụng một hệ quả của định lý Wilson :

Làm thế nào nó hoạt động

Dòng đầu tiên xác định hàm helper.

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

p lấy một số lượng các đối số mà nó lưu trữ trong tuple t .

Việc '%%%ds '%len(`x[-1]`)sử dụng một chuỗi định dạng để xây dựng một chuỗi định dạng; %%là một ký hiệu phần trăm bằng chữ, %dlà một giữ chỗ cho số nguyên len(`x[-1]`)trả về, tức là số chữ số của phần tử cuối cùng trong x (đầu vào, chưa được xác định) và bằng s chữ.

Nếu, ví dụ, yếu tố cuối cùng của x có ba chữ số, sản lượng này %3s , mà *len(t)lặp đi lặp lại một lần cho mọi phần tử của x . Cuối cùng, %táp dụng chuỗi định dạng đó cho tuple t , xây dựng một chuỗi các phần tử của t , được phân tách bằng dấu cách và tất cả đều được chứng minh đúng theo một độ dài nhất định.

Dòng thứ hai xác định đệ trình thực tế: một hàm f lấy danh sách x làm đầu vào. Sau khi thay thế execcâu lệnh thực thi chuỗi nó đi trước x[-1]lần, với một forvòng lặp, chúng ta nhận được đoạn mã sau.

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

Đầu tiên, f khởi tạo k và m thành 1 . Lưu ý rằng (k - 1)! = 0! = 1 = m .

Sau đó, p(' ',*x)in một khoảng trắng và các số nguyên trong x , sử dụng hàm p .

Bây giờ, chúng ta nhập vòng lặp để in đầu ra còn lại.

Đầu tiên, r=[n%k and' 'for n in x]xây dựng danh sách các phần dư của mỗi số nguyên n trong x chia cho k . Phần dư tích cực, nghĩa là phần dư không tương ứng với bội số của k , là sự thật và được thay thế bằng khoảng trắng bằng and' '.

Tiếp theo, chúng tôi xây dựng m%k*r. Vì m = (k - 1)! , theo hệ quả của định lý Wilson, điều này sẽ chỉ đơn giản là r nếu k là số nguyên tố, nhưng một danh sách trống nếu không. Nếu có ít nhất một 0 trong kết quả, nghĩa là, nếu k là số nguyên tố và ít nhất một số nguyên trong x chia hết cho k , 0in m%k*rsẽ trả về True và p(k,*r)được gọi, in k và các chỉ số chia hết: 0nếu chia hết, một khoảng trắng nếu không .

Cuối cùng, chúng tôi nhân m với k² và tăng k , do đó chất lượng m = (k - 1)! tiếp tục giữ

MATL , 31 byte

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

Điều này sử dụng 1thay vì *, như được cho phép bởi các thách thức.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải thích ( lỗi thời )

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

Vợt 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"")))

Ung dung:

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

Kiểm tra:

(f '(6 9 14 22))

Đầu ra:

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