介绍

我在休闲数学中一直在玩的事情是构造除数表，以便直观地比较/对比一组数字的本数。输入数字的集合在顶部作为列标签，在主除数的左边作为行标签，并且标记指示两者的排列位置。

例如，对于输入6, 9, 14, 22，将构建类似于以下内容的表：

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

这是因为6具有和的素数，具有2和的素数，依此类推。393

施工

• 该表的构造使得输入数字形成以空格隔开并按升序排列的列标签（您可以假定它们是预先排序的），并且素数除数以升序列在左侧，每行一行标签。
• 请注意，如果数字的长度不同，则质数和输入数字的前导空格可能是必需的，因此所有列的宽度均应相同，并适当对齐。
• 每个除数都由一个*（或您选择的其他合适的ASCII字符表示，只要所有出现都使用相同的字符）即可。
• 多个除数将被忽略（例如，3 x 3 = 9但是*那个交集只有一个）。
• 本*可以在栏中任一水平放置，只要它是明确的（我有我所有的用例*右对齐）。

输入值

• 正整数的名单在任何方便的格式，每个>1。
• 您可以假定输入已预先排序。
• 确保输入仅具有唯一值。

输出量

主除数表的结果ASCII艺术表现形式。

规则

• 前导或尾随的换行符或空格都是可选的，只要字符本身正确对齐即可。
• 如果用分隔线将表格标题/行标题与表格数据分隔开来要短一些，那也是允许的。
• 完整的程序或功能都是可以接受的。如果是函数，则可以返回输出而不是打印输出。
• 如果可能，请提供一个在线测试环境的链接，以便人们可以尝试您的代码！
• 禁止出现标准漏洞。
• 这是代码高尔夫球，因此所有常用的高尔夫规则都适用，并且最短的代码（以字节为单位）获胜。

例子

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字节

感谢ngenisis节省了11个字节！

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 s和空字符串与可除数相对（我们使用未定义的标记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]&

果冻，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.

果冻，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

的JavaScript（ES6），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]))

Python 2-197字节

切换到Python 2以便更轻松地进行输入处理并允许``进行字符串转换。用途gmpy2产生下一任。输出格式仍基于先前的Python 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
)

以前

Python 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',' '))

非高尔夫版本和说明将在后面介绍。

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

击 + GNU工具，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
}

在线尝试！

Python 2中，181 179字节

^{-2个字节归功于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

输入必须是一个元组。
在线尝试！

批量，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在同一行循环。

Python 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代替*。

在线尝试！

背景

为了确定素数，我们使用威尔逊定理的推论：

怎么运行的

第一行定义了一个辅助函数。

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

p接受可变数量的参数，并将其存储在元组t中。

在'%%%ds '%len(`x[-1]`)使用一个格式字符串以构建格式字符串; %%是文字百分号，%d是len(`x[-1]`)返回整数的占位符，即x中最后一个元素（输入，尚未定义）的位数，并且s 是文字。

例如，如果x的最后一个元素具有三个数字，则产生%3s ，*len(t)对于x的每个元素重复一次。最后，%t将该格式字符串应用于元组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(' ',*x)打印一个空格和x中的整数使用函数p。

现在，我们进入循环以打印剩余的输出。

首先，r=[n%k and' 'for n in x]构造，每个整数的余数的列表Ñ在X除以ķ。正余数（即不对应于k的倍数的余数）是真实的，并由代替and' '。

接下来，我们构造m%k*r。由于m =（k-1）！，根据威尔逊定理的推论，如果k为素数，则简单地为r，否则为空列表。如果结果中至少有一个0，即，如果k为素数，并且x中的至少一个整数可以被k整除，则将返回True并被调用，打印0in m%k*rp(k,*r) k和除数指示符：0如果可整除，则为空格。

最后，我们乘中号由K²和增量ķ，所以质量M =（K - 1）！继续持有。

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

球拍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"")))

取消高尔夫：

(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            *