당신의 임무는 아래에 설명 된 방법을 사용하여 103 매끄러운 숫자 를 영어 단어로 번역하는 것 입니다.

어떻게?

1. 입력 번호의 소인수 (반복 포함) 목록을 생성하십시오.
2. 목록을 정렬하십시오.
   • 2 가 주요 요소 중 하나가 아닌 경우 목록을 오름차순으로 정렬하십시오.
   • 2 가 주요 요인 중 하나 인 경우 목록에서 제거하고 나머지 요인을 내림차순으로 정렬하십시오.

3. 다음 표를 사용하여 각 요소를 문자로 번역하십시오.

    3 = S   13 = L   29 = X   43 = O   61 = Z   79 = H  101 = K  
    5 = P   17 = Q   31 = N   47 = R   67 = T   83 = V  103 = Y  
    7 = M   19 = U   37 = C   53 = A   71 = E   89 = D  
   11 = F   23 = I   41 = W   59 = G   73 = J   97 = B  
   

_{참고 :이 표는 가능한 단어 수를 최대화하기 위해 경험적으로 만들어졌습니다. 궁금한 점은 다음과 같이 인코딩 할 수있는 2,187 개의 단어 목록입니다 (무례한 언어 포함). 반드시 최적이라고 보장 할 수는 없지만이 과제에 충분합니다.}

예

예 1 : 579085261 (오름차순)

1. 주요 요인은 [37, 47, 53, 61, 103] 입니다.
2. 2 는 주요한 요소가 아니므로 목록을 오름차순으로 정렬합니다.
3. 37 = C, 47 = R 등. 출력은 "CRAZY"입니다.

예 2 : 725582 (내림차순)

1. 주요 요인은 [2, 11, 13, 43, 59] 입니다.
2. 2 는 주요한 요소이므로 목록을 제거하고 목록을 내림차순으로 정렬하면
   [59, 43, 13, 11]이 됩니다.
3. 59 = G, 43 = O 등. 출력은 "GOLF"입니다.

예 3 : 10757494 (반복 요인 포함)

1. 주요 요인은 [2, 11, 71, 71, 97] 입니다.
2. 2 는 주요한 요소이므로 제거하고 목록을 내림차순으로 정렬하면
   [97, 71, 71, 11]이 됩니다.
3. 97 = B, 71 = E, 11 = F. 출력은 "BEEF"입니다.

설명 및 규칙

• 입력 번호는 103-smooth이며 최대 2 번으로 나눌 수 있습니다.
• 정의에 따라, 부드러운 숫자는 양의 정수 입니다.
• 입력과 출력은 합리적인 형식으로 처리 할 수 ​​있습니다. 출력은 소문자 또는 대문자 일 수 있습니다. 후행 공백이 허용됩니다. 선행 공백은 아닙니다.
• 프로그램 / 기능이 큰 입력을 지원할 수없는 경우 답을 지정하십시오.
• 이것은 코드 골프이므로 바이트 단위의 최단 답변이 이깁니다.

테스트 사례

34874          --> ARM
483254         --> BAR
353722         --> EAR
494302         --> EGG
39061          --> FAT
6479           --> FUN
60421          --> ICE
54166          --> JAM
48911474       --> BETA
2510942        --> BOOM
2303854        --> DOOM
844261         --> FIRE
1606801        --> MAZE
1110085        --> PAGE
5212974        --> BALLS
67892046       --> BEANS
885396199      --> CREEK
67401037       --> FUNKY
27762173       --> QUICK
1238440506     --> ARROWS
33045832681    --> CRAGGY
1362714005     --> PIRATE
137302698      --> TROLLS
358310128062   --> BEGGARS
40255151586    --> DETAILS
164633248153   --> FIXATED
621172442227   --> UNRATED
2467812606     --> VACUUMS
86385078330    --> GROWNUPS
26607531423091 --> UNWORTHY

젤리 , 29 27 바이트

ÆEµØA“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?xḊṚḢ}¡

1 바이트를 골프로 해준 @JonathanAllan에게 감사합니다!

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

배경

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’

숫자 리터럴입니다. 따옴표 사이의 문자는 Jelly 코드 페이지 에서 1 기반 인덱스로 대체되며 결과 배열은 기본 250 숫자로 해석됩니다. 정수 c : = 288824892868083015619552399가 생성 됩니다.

작동 원리

ÆEµØA“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?xḊṚḢ}¡  Main link. Argument: n

ÆE                           Yield the exponents of n's prime factorization, with.
                             zeroes. This yields an array A.
  µ                          Begin a new monadic chain with argument A.
   ØA                        Set the return value to “ABC...XYZ”.
     “¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?        Select the c-th permutation of the alphabet, yielding
                             s := “SPMFLQUIXNCWORAGZTEJHVDBKY”.
                      Ḋ      Dequeue; yield A without its first element, stripping
                             the exponent of 2.
                     x       Repeat the k-th letter of s r times, where r is the
                             exponent of the k-th odd prime number.
                          ¡  Combine the two links to the left into a quicklink:
                        Ḣ}     - Apply head to the right argument (A), yielding the
                                 exponent of 2. Since n is at most divisible by the
                                 first power of 2, this yields 1 for even numbers
                                 and 0 for odd ones. Call the link to the left that
                                 many times on the previous return value.
                       Ṛ       - Reverse the string to the left.

젤리 , 36 바이트

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA1;;⁶
×107ÆE¢×UḢ¡t⁶

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

설명

도우미 상수1£ ( “SPMFLQUIXNCWORAGZTEJHVDBKY ”1 앞에 추가됨)

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA1;;⁶
“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’          288824892868083015619552399 (compressed representation)
              œ?ØA      th permutation of the alphabet
                  1;    prepend 1
                    ;⁶  append a space

주요 프로그램

×107ÆE¢×UḢ¡t⁶
×107           Multiply {the input} by 107
    ÆE         Convert to a list of frequencies for each factor
      ¢×       {Vectorized} multiply by the return value of 1£
        UḢ¡    Delete the first value, reverse the list that many times
           t⁶  Delete trailing/leading space

나는 목록의 압축이 다른 젤리 대답보다 쉽게 ​​이길 수 있다고 생각하지만, 그것을 사용하는 알고리즘이 훨씬 효율적일 수 있습니다. 어쩌면 나는 그들을 결합하려고 노력할 것입니다.

@Leakynun의 답변에서 영감을 얻은 Jelly , 31 바이트

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA⁷;
ÆfÆCị¢U⁸¡U

온라인으로 사용해보십시오! (더 빠르게 실행되도록 약간 수정)

후행 줄 바꿈을 인쇄하는지 여부에 일관성이 없습니다 (그러나 PPCG는 일반적으로 후행 줄 바꿈이 있거나없는 답변을 허용 하므로이 방법도 효과가 있습니까?). 가 매우 (O (느린 N ) 여기서 n은 ... 입력하고, 그 숫자는 정확히 작은되지 않습니다)

설명

도우미 상수1£ ( 줄 바꿈이 “¶SPMFLQUIXNCWORAGZTEJHVDBKY”있는 곳을 생성합니다 ¶)

“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA⁷;
“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’          288824892868083015619552399 (compressed representation)
              œ?ØA      th permutation of the alphabet
                  ⁷;    prepend newline

주요 프로그램

ÆfÆCị¢U⁸¡U
Æf          Produce list of prime factors (repeating repeated factors)
  ÆC        Map the nth prime to n
    ị¢      Index into the output of 1£
      U     Reverse
        ¡   a number of times
       ⁸    equal to the input
         U  Reverse again

05AB1E , 39 38 바이트

ÒW<iR¨}26LØR•6Ê2"£´õþÕàçŸôëÂÛ*™•36BS:J

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

파이썬 2, 220 217 바이트

n=input()
i=1
L=[]
exec'i+=1;c=0\nwhile n%i<1:c+=1;n/=i\nif c:L+=[i]*c\n'*n
T='SPMFLQUIXNCWORAGZTEJHVDBKY'
print''.join(T[[p for p in range(3,104)if all(p%k for k in range(2,p))].index(q)]for q in[L,L[:0:-1]][L[0]<3])

온라인으로 사용해보십시오 - 메모리 부족없이 가장 작은 테스트 사례 만 실행

언 골프 드 :

이 버전은을 사용하지 않으므로 exec실제로 메모리 부족없이 모든 테스트 사례를 테스트 할 수 있습니다.

n=input()
i=1
L=[]
while~-n:
 i+=1;c=0
 while n%i<1:c+=1;n/=i
 if c:L+=[i]*c
if L[0]<3:L=L[:0:-1]
T='SPMFLQUIXNCWORAGZTEJHVDBKY'
print''.join(T[[p for p in range(3,104)if all(p%k for k in range(2,p))].index(q)]for q in L)

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

루비 , 139 138 134 125 120 115 + 7 = 146 145 141 132 127 122 바이트

-rprime+7 바이트에 플래그를 사용합니다 .

@daniero에서 -1 바이트 -4 바이트의 존재에 대한 소수를 검사하는 대신 정기적으로 나눗셈 검사를 수행 할 수 있음을 기억하여 -4 바이트 2.

@ mbomb007의 Python 솔루션에서 -9 바이트는 일치하는 문자를 검색하는 더 짧은 방법을 상기시킵니다.

후행 공백이 허용되므로 -5 바이트입니다.

감지에서 -5 바이트 Enumerable#find_index

->n{x=Prime.prime_division n;x.reverse!if n%2<1;x.map{|i,c|" SPMFLQUIXNCWORAGZTEJHVDBKY"[Prime.find_index i]*c}*''}

온라인으로 사용해보십시오! (모든 테스트 사례)

설명

->n{                                   # Anonymous procedure with one argument n
    x=Prime.prime_division n;          # Get prime factorization of n, sorted
                                       # p0^e0 * p1^e1 ... -> [[p0,e0],[p1,e1],...]
    x.reverse!if n%2<1;                # Reverse if divisible by 2
    x.map{|i,c|                        # For each prime/exponent pair:
        " SPMFLQUIXNCWORAGZTEJHVDBKY"[ # Get corresponding character by obtaining:
            Prime.find_index i]        # Determine index of the current prime
                               *c      # Repeat the letter by the supplied exponent
                                 }*''} # Join all letter sequences together

배쉬 + GNU 유틸리티 + bsd-games 패키지, 170

최적이 아닌 것 같지만 작동합니다.

p='printf %03d\n'
a=(`factor $1`)
x=$[a[1]<3]
$p `primes 3 104`|paste - <(fold -1<<<SPMFLQUIXNCWORAGZTEJHVDBKY)|join -o1.2 - <($p ${a[@]:x+1})|(((x))&&tac||cat)|tr -d \\n

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

젤리 , 33 바이트

ÆfÆCUṖ$¹e@?1’ị“¡3ḅḲ+Ṿɼ¡ẏƙẊƘ’œ?ØA¤

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

Japt , 51 50 바이트

49 바이트의 코드, -P플래그의 경우 +1

%2?Uk :Uk Åw)£`yspmflquixncÙgz’jhvdbk`g#ho fj bX

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

Japt 만 몇 가지 기능을 더 가지고 있다면 이것은 더 짧을 수 있습니다 ...

설명

`yspmflquixncÙgz’jhvdbk`Japt가 압축 할 수있는만큼 압축 된 다른 문자열을 사용합니다 (원래보다 3 바이트 짧습니다!). 현재 Japt의 유일한 내장 압축 도구는 일반적인 소문자 쌍을 단일 바이트 문자로 대체합니다.

실제 코드를 살펴 보자.

%2?Uk :Uk Å  w)
%2?Uk :Uk s1 w)
%2?             // If the input mod 2 is non-zero,
   Uk           //   take the prime factors of the input (U).
      :Uk       // Otherwise, take the prime factors of the input,
          s1 w  //   slice off the first one (2), and reverse.

그런 다음 결과에서 다음과 같이 £각 항목을 바꾸는 데 사용됩니다 X.

"string"g#h o fj bX
"string"g104o fj bX

         104o         // Create the range [0...104).
              fj      // Filter to only items Z where Z.j() is truthy (Z is prime).
                      // This results in the list of prime numbers from 2 to 103.
                 bX   // Take the index of X in this list.
"string"g             // Get the char in the compressed string at that index.
                      // For `y`, the index is 26, but since the string is only 26 chars
                      // long, Japt wraps around and grabs the first char in the string.

결과는이 시점에서 문자 배열이므로 -P플래그는 단일 문자열로 결합하고 결과는 암시 적으로 출력으로 전송됩니다.

젤리 , 40 바이트

Æfḟ2ÆCṚ⁸Ḃ¤¡Ṛị“YSPMFLQUIXNCWORAGZTEJHVDBK

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

모든 테스트 케이스를 한 번에 확인하십시오! (약간 수정 됨)

Pyth , 54 47 바이트

isaacg 덕분에 7 바이트

s__W%Q2@L."AZ❤O❤❤❤❤❤❤Q❤9❤❤×❤❤"xL_MP#r_3_103-PQ2

( ❤인쇄 불가능한 캐릭터를 나타냅니다)

Pyth에는 많은 기본 제공 기능이 없습니다 ...

16 진 덤프 :

0000000: 73 5f 5f 57 25 51 32 40 4c 2e 22 41 5a 03 4f f3 s__W%Q2@L."AZ.O.
0000010: 14 af 15 ed f5 51 90 39 d5 18 d7 20 a8 22 78 4c .....Q.9... ."xL
0000020: 5f 4d 50 23 72 5f 33 5f 31 30 33 2d 50 51 32    _MP#r_3_103-PQ2

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

J , 59 바이트

'SPMFLQUIXNCWORAGZTEJHVDBKY'{~(p:>:i.26)i.[:|.@}.^:(2={.)q:

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

아주 간단합니다 ...

'SPMFLQUIXNCWORAGZTEJHVDBKY'{~(p:>:i.26)i.[:|.@}.^:(2={.)q:
                              (p:>:i.26)                      first 26 primes after 2
                                        i.                    for which the indices is
                                                         q:   prime factors
                                            |.@}.             remove first and reverse
                                                 ^:           if
                                                   (2={.)     the first entry is 2
                            {~                                reverse index
'..........................'                                  hardcoded string

PHP, 173 바이트

for($i=2;1<$n=&$argn;$n%$i?++$i:$r[]=$i.!$n/=$i)for($t=$i;$i>2&!$w[$i]&&$i%--$t;$t>2?:$w[$i]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++]);$r[0]>2?:rsort($r);foreach($r as$s)echo$w[$s];

온라인 버전

넓히는

for($i=2;1<$n=&$argn; # loop till input is 1
$n%$i?++$i:$r[]=$i.!$n/=$i) #after loop add value to result if input is divisible and divide input
  for($t=$i;$i>2&!$w[$i]&&$i%--$t; # loop if number is gt 2 and not in letter array till number is divisible 
  $t>2?:$w[$i]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++]) # if is prime add to letter array
  ; # make nothing in the loop
$r[0]>2?:rsort($r); # reverse result array if 2 is in result array
foreach($r as$s) # loop result array
  echo$w[$s]; # Output 

PHP, 178 바이트

for($z=2;$p<26;$t>1?:$w[$z]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++])for($t=++$z;$z%--$t;);for($i=2;1<$n=&$argn;)$n%$i?++$i:$r[]=$i.!$n/=$i;$r[0]>2?:rsort($r);foreach($r as$s)echo$w[$s];

온라인 버전

넓히는

for($z=2;$p<26;
$t>1?:$w[$z]=SPMFLQUIXNCWORAGZTEJHVDBKY[$p++]) # after loop if is prime add to letter array
  for($t=++$z;$z%--$t;); 
for($i=2;1<$n=&$argn;)  # loop till input is 1
  $n%$i?++$i:$r[]=$i.!$n/=$i; #add value to result if input is divisible and divide input
$r[0]>2?:rsort($r); # reverse result array if 2 is in result array
foreach($r as$s) # loop result array
  echo$w[$s]; # Output 

파이썬, 1420 바이트

lambda x:(lambda a,b,e,k,l,m,q,p:len.__name__[:a].join(dict(zip((lambda n:(lambda n,f,g:f(n,e,[],f,g))(n,lambda n,i,r,f,g:g(n,i+b,r,f,g)if i<n else r,lambda n,i,r,f,g:f(n,i,[r,r+[i]][all(i%x!=a for x in[e]+r)],f,g)))(l*e*(k*l+b)),(lambda n,o,t:(lambda n,f,g:f(n, len.__name__[:a],f,g))(n,lambda n,s,f,g:g(n,s,f,g)if n>o else s,lambda n,s,f,g:f(n//t,s+chr(n%t),f,g)))((((((k<<e)-b)<<m)+m)<<((k<<q)+(k<<b)))+(((((k<<e)-b)<<e)+b)<<((k<<q)-(b<<b)))+((((((b<<k)+b))<<l)+b)<<((((k<<e)-b)<<l)+(b<<b)))+(((((k<<e)-b)<<l)-k)<<((m<<m)+p))-(((p<<m)-b)<<((m<<m)-(b<<b)))+(((m<<k)+b)<<((((m<<e)-b)<<k)-(b<<b)))+(((((k<<e)-b)<<l)-m)<<((((b<<l)+b)<<k)+k))-(((((b<<l)-b)<<l)-p)<<((b<<p)+(b<<b)))-(((p<<k)-b)<<((((b<<l)-b)<<k)+k))-(((k<<q)-b)<<((p<<l)))+(((m<<m)+m)<<((((k<<e)+b)<<k)-b))-(((k<<m)+b)<<((k<<m)-b))-(((m<<m)+k)<<((((k<<e)-b)<<k)-(b<<b)))+(((((k<<e)+b)<<e)+b)<<((m<<l)-(b<<e)))-(((((k<<e)+b)<<e)+b)<<((((b<<l)+b)<<e)-b))+((((((b<<k)+b))<<k)+b)<<((p<<k)))+(((((k<<e)-b)<<k)-k)<<((k<<l)))+(((m<<l)+b)<<((m<<k)))+(((m<<e)-b)<<((b<<m)+(b<<b)))+((((((b<<k)+b))<<e)-b)<<((k<<k)+b))+(((m<<k)-b)<<((b<<l)+b))-((((k<<e)-b))<<((k<<e)))+(((m<<e)+b)<<e)-b,b,b<<l*e)))[i]for i in(lambda x: [x.remove(e), x[::-b]][b] if e in x else x)((lambda x:(lambda x,g,h:g(x,b,[],g,h))(x,lambda x,n,r,g,h:h(x,n+b,r,g,h)if x>b else r,lambda x,n,r,g,h:h(x//n,n,r+[n],g,h)if x%n==a else g(x,n,r,g,h)))(x))))(*[x for x in range(True<<len(len.__name__))])

이것은 분명히 일부를 단축시킬 수는 있지만 숫자 나 문자열 리터럴없이 문제를 해결하려는 시도입니다. 나는 이것이 코드 골프 문제라는 것을 알고 있으며 이것은 정확히 짧지는 않지만 어쨌든 공유하고 싶었습니다. 이것이 규칙을 위반하는지 여부는 확실하지 않습니다.

만들기가 즐거웠습니다. 이 블로그 게시물 의 알고리즘을 사용하여 "SPMFLQUIXNCWORAGZTEJHVDBKY"의 ASCII 숫자 표현을 사용하는 비트 시프트 식으로 줄였습니다. 나는 또한 일반적 으로이 블로그에서 많은 영감을 얻었습니다. 나는 그것을 직접 시험 해보고 싶었습니다.

여기 에 좀 더 알아보기 쉬운 버전이 있으며 좀 더 합리적인 변수 이름도 있습니다