참고 :이 과제는 sandbox 에 게시되었습니다 .

소개

이 도전은 학부 수학 경쟁의 문제인 2009 Putnam B1 에서 영감을 얻었 습니다. 문제는 다음과 같습니다.

모든 양의 유리수는 반드시 소수 일 필요는없는 소수의 계승의 몫으로 쓸 수 있음을 보여주십시오. 예를 들어

도전

문제는 양의 합리적인 숫자 (또는 합리적인 숫자 자체)의 분자와 분모를 입력으로 나타내는 상대적 소수 소수 쌍을 취하여 소수의 두 목록 (또는 배열 등)을 출력하는 것입니다. 입력 된 유리수는 첫 번째 목록에있는 소수의 계승의 곱과 두 번째 목록에있는 소수의 계승 곱의 비율과 같습니다.

노트

• 첫 번째 목록과 두 번째 목록에 모두 포함 된 소수가 없을 수 있습니다. 그러나 소수는 원하는대로 여러 번 나타날 수 있습니다.
• 입력은 각각 1과 65535 사이 (각각)로 가정 할 수 있습니다. 그러나 출력해야 할 숫자의 계승이이 범위에 있다고 가정 할 수 없습니다.

입력 및 출력 예

다음은 합법적 인 입력 및 출력의 예입니다.

input=>output
10,9 => [2,5],[3,3,3]
2,1 => [2],[]
3,1 => [3],[2]
1,5 => [2,3,2],[5]     (elements of a list may be in any order)
3,2 => [3],[2,2]
6,1 => [3],[]

입력 (2,2), (0,3), (3,0), (3,6) 및 (1,65536)은 잘못된 입력입니다 (즉, 프로그램이 특정 방식으로 동작하지 않아도 됨) ). 다음은 잘못된 출력의 예입니다.

1,2 => [2],[2,2] (2 is in both returned lists)
5,2 => [5],[2,4] (4 is not prime)
2,1 => [2],[1] (1 is not prime either)
3,2 => [3],[2] (3!/2! = 3, not 3/2)

채점

이것은 code-golf 이므로 바이트 단위의 최저 점수가 이깁니다!

05AB1E , 54 53 48 46 40 35 33 32 28 바이트

[D¿÷Z#DÓ€gZD<ØŠQ*DˆR!*]¯øεʒĀ

온라인으로 사용해보십시오! 편집 : @ASCII 전용 덕분에 2 바이트가 절약되었습니다. 저장된 1 2 3 4 @Emigna 덕분에 바이트. (하나만 더 저장하면 원래 바이트 수의 절반으로 줄어 듭니다!) 설명 :

[       Begin an infinite loop
D¿÷     Reduce to lowest terms
Z#      Exit the loop if the (largest) value is 1
DÓ€g    Find the index of the largest prime factor of each value
Z       Take the maximum
D<ØŠ    Convert index back to prime and save for later
Q       Convert to an pair of which value had the largest prime factor
*       Convert to an pair with that prime factor and zero
Dˆ      Save the pair in the global array for later
R!*     Multiply the other input value by the factorial of the prime
]       End of infinite loop
¯ø      Collect all the saved primes
εʒĀ     Forget all the saved 0s

매쓰, 175 177 169 154 108 바이트

Join@@@Table[x[[1]],{s,{1,-1}},{x,r@#},x[[2]]s]&@*(If[#==1,1,{p,e}=Last@(r=FactorInteger)@#;p^e#0[p!^-e#]]&)

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

작동 원리

이것은 두 가지 기능의 구성입니다. 첫 번째, 언 골프

If[# == 1,
  1,
  {p,e} = Last[FactorInteger[#]];
  p^e * #0[p!^-e * #]
]&

실제로 원하는 분해를 계산하기위한 재귀 함수입니다. 특히 합리적인 입력이 주어지면 x계승이 분자와 분모에 있어야하는 소수를 계산하고 그 소수를 모두 곱한 분수를 반환합니다. 예를 들어 input 10/9 = 2!*5!/(3!*3!*3!)에을 반환 10/27 = 2*5/(3*3*3)합니다.

우리는 모든 단계에서 가장 큰 주요 요소를 처리하여이를 수행합니다. x의 인수 분해에서 p ^e 가 발생하면 p! ^e 는 계승 분해에서 발생하고 x를 p로 나눈 값으로 되풀이됩니다! ^e .

(초기에는 p 이전의 소수를 살펴보면 큰 숫자를 피하는 더 영리한 전략이 있었지만 Mathematica는 65521만큼 큰 숫자를 쉽게 처리 할 수 ​​있으므로 요점이 없습니다. 역사에서 찾을 수있는 이전 버전은 훨씬 빠른 속도 : 내 컴퓨터에서는이 버전이 1.6 초 안에 처리하는 입력에 0.05 초가 걸렸습니다.)

두 번째 함수는 첫 번째 함수의 출력을 소수 목록으로 바꿉니다.

Join @@@ 
  Table[x[[1]],
    {s,{1,-1}},
    {x,FactorInteger[#]},
    x[[2]]*s
  ]&

들어 s=1(긍정적 인 힘)과 s=-1(음의 힘), 각 용어에 대한 {prime,exponent}인수 분해에 r@#, 우리는 소수를 반복 prime exponent*s여러 번.

109 62 바이트의 비경쟁 버전

If[#==1,∇1=1,{p,e}=Last@FactorInteger@#;(∇p)^e#0[p!^-e#]]&

위와 동일하지만 출력을 목록으로 제공하는 대신 factor 연산자 (기본 제공 의미가 없기 때문에)를 계승의 독립형으로 사용하여 출력을 표현식으로 제공합니다. 따라서의 입력 10/9은의 출력 (∇2*∇5)/(∇3)^3을 나타냅니다 (2!*5!)/(3!)^3.

함수의 두 번째 부분을 건너 뛰기 때문에 더 짧습니다.

+2 바이트 : f=FirstMathematica가 화를 내지 않도록 올바른 장소에서 과제 를 수행해야합니다.

-8 바이트 : 정수 출력 버그가 수정되어 실제로 코드가 짧아졌습니다.

-15 바이트 : FactorInteger우리가 활용할 수있는 정렬 된 출력을 반환합니다.

-46 바이트 : 실제로 영리 할 필요는 없습니다.

파이썬 2 220 202 195 183 바이트

g=lambda a,b:a and g(b%a,a)or b;n,d=input();m=c=()
while n+d>2:
 t=n*d;f=p=2
 while t>p:
	if t%p:p+=1;f*=p
	else:t/=p
 if n%p:c+=p,;n*=f
 else:m+=p,;d*=f
 t=g(n,d);n/=t;d/=t
print m,c

온라인으로 사용해보십시오! 편집 : @ Mr.Xcoder 덕분에 18 25 바이트가 절약되었습니다. @JonathanFrech 덕분에 12 바이트를 절약했습니다.