소개

레크리에이션 수학에서 함께해온 것은 숫자의 주요 제수를 시각적으로 비교 / 대비하기 위해 제수 테이블을 만드는 것입니다. 입력 번호 세트는 상단에 열 레이블로, 소수는 왼쪽에 행 레이블로 표시되며 마크는 두 줄의 위치를 ​​나타냅니다.

예를 들어, 입력 6, 9, 14, 22을 위해 다음과 유사한 테이블이 구성됩니다.

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

때문이다 6의 주요 약수를 가지고 2와 3, 9의 주요 제수를 가지고 3등등합니다.

구성

• 테이블은 입력 숫자가 공백으로 구분되고 오름차순으로 열 레이블을 구성하도록 구성되며 (사전 정렬 된 것으로 가정 할 수 있음) 소수는 왼쪽에 행을 구성하는 행당 오름차순으로 나열됩니다. 라벨.
• 모든 열의 너비가 동일하고 적절하게 정렬되도록 숫자의 길이가 다른 경우 소수와 제수의 선행 공백이 필요할 수 있습니다.
• 각 제수는 단일 *(또는 동일한 문자가 모든 경우에 사용되는 한 선택한 다른 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 바이트

11 바이트를 절약 한 ngenisis 덕분에!

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

∣3 분의 1 정도 의 문자는 U + 2223 (3 바이트)입니다. 가변 개수의 인수의 이름이없는 함수는 각각 0이 아닌 정수로, TableForm객체 (형식화 된 출력)를 다음과 같이 반환합니다 .

f=#&@@@FactorInteger[1##]정의를 f(등가 적으로, 그 제품의 분할 입력 중 나누는 모든 소수의 설정 될 1##때) g입력 이루어진리스트이다. 나누기에 대응하는 s 및 빈 문자열 Outer[If[#∣#2,Y,""]&,f,g]표를 만듭니다 Y( Y문자열 대신 정의되지 않은 토큰을 사용 "Y"하거나 "*"2 바이트를 절약하기 위해). 그런 다음 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

자바 스크립트 (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]))

파이썬 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
)

너무 이른

파이썬 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
}

온라인으로 사용해보십시오!

파이썬 2 , 181 179 바이트

^{FlipTack 덕분에 -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

입력은 튜플이어야합니다.
온라인으로 사용해보십시오!

배치, 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동일한 라인 루프.

파이썬 (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]`)형식 문자열을 구성하는 문자열 포맷을 사용한다; %%리터럴 퍼센트 부호이며, x 에있는 마지막 요소의 자릿수 (아직 정의되지 않은 입력) %d를 len(`x[-1]`)반환 하는 정수의 자리 표시 자 이며 리터럴입니다.s 

예를 들어, x 의 마지막 요소에 세 자리 숫자가 있으면이 결과가 %3s 되며 x의*len(t) 모든 요소에 대해 한 번씩 반복됩니다 . 마지막으로 해당 형식 문자열을 튜플 t에 적용하여 공백으로 구분되고 모든 길이를 일정한 길이로 정렬하여 t 요소 의 문자열을 구성합니다 .%t

두 번째 줄은 실제 제출을 정의합니다 : 리스트 x 를 입력으로 받는 함수 f . 일 교체 한 후에 는 앞에있는 문자열 실행 문, 로, 시간을 루프를, 우리는 다음과 같은 코드를 얻을.execx[-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로 초기화 합니다. 그 주 (- 1 k)를! = 0! = 1 = m 입니다.

그런 다음 함수 p를 사용하여 p(' ',*x)공백과 x 의 정수를 인쇄합니다 .

이제 나머지 출력을 인쇄하기 위해 루프에 들어갑니다.

우선, r=[n%k and' 'for n in x]각 정수의 나머지 목록 구축 N 에서 X 로 나눈 케이 . 긍정적 인 나머지, 즉 k의 배수에 해당하지 않는 나머지 는 진실이며로 공백으로 대체됩니다 and' '.

다음으로을 생성 m%k*r합니다. m = (k-1) 이므로 ! 윌슨 정리의 목록에 따르면 k 가 소수 이면 간단히 r 이되고 그렇지 않으면 빈리스트가됩니다. 적어도 하나 있으면 0 결과에서, 경우 즉, k는 소수와 적어도 하나의 정수 x는 로 나누어 K , 반환 사실을 및 인쇄, 호출되는 K 와 가분성 지표 : 만약 나눌 수, 공간을하지 않을 경우 .0in m%k*rp(k,*r)0

마지막으로, 우리는 m 에 k²를 곱하고 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            *