양의 정수가 주어 n > 2졌습니다. 다음과 같이 배열로 변환합니다.

1. 2빈 배열 을 반환하는 것과 같다면
2. 그렇지 않으면 n오름차순으로 정렬 된 모든 소수 요소의 배열을 만든 다음 각 요소를 소수 시퀀스의 인덱스로 바꾸고 마지막으로 각 요소를 배열로 변환

예를 들어 숫자 46를 배열 로 변환 합니다. 먼저, 주요 요소 배열로 변환하십시오.

[2, 23]

번호는 23입니다 9그래서 교체, 일 총리 2빈 배열과 23함께 [9]. 이제 배열은 다음과 같습니다.

[[], [9]]

의 주요 요인은 9다음 3과 3같습니다.

[[], [3, 3]]

둘 다 동일하게 수행하십시오 3.

[[], [[2], [2]]]

그리고 마지막으로:

[[], [[[]], [[]]]]

이제 인코딩하기 위해 각 열린 괄호를 1각 닫는 괄호로 바꾸고 0모든 끝나는 0을 제거하고 끝에서 1을 떨어 뜨립니다 1. 이진 숫자입니다. 위의 예를 사용하면

[ ] [ [ [ ] ] [ [ ] ] ]

| | | | | | | | | | | |
| | | | | | | | | | | |
V V V V V V V V V V V V

1 0 1 1 1 0 0 1 1 0 0 0

이제 마지막 3 개의 0과 마지막 0을 삭제하십시오 1. 숫자하게 10111001되는 185진수. 이것이 예상되는 결과입니다. 배열에서 기본 배열의 이진 변환 괄호는 포함되지 않습니다.

입력

n보다 큰 양의 정수 2.

산출

인코딩 된 정수 n.

규칙 및 IO 형식

• 표준 규칙이 적용됩니다.
• 입력은 문자열 또는 숫자 일 수 있습니다 (그러나 문자열의 경우 10 진이어야합니다).
• 출력은 문자열 또는 숫자 일 수 있습니다 (그러나 문자열의 경우 10 진수 여야합니다).
• 이것은 code-golf 이며 바이트 단위로 가장 짧은 대답이 이깁니다!

테스트 사례

요청시 더 많은 테스트 사례.

3 ---> 1
4 ---> 2
5 ---> 3
6 ---> 5
7 ---> 6
8 ---> 10
9 ---> 25
10 ---> 11
10000 ---> 179189987
10001 ---> 944359
10002 ---> 183722
10003 ---> 216499
10004 ---> 2863321
10005 ---> 27030299
10006 ---> 93754
10007 ---> 223005
10008 ---> 1402478

모래 상자

껍질 , 35 31 30 29 26 25 24 22 20 19 15 바이트

@Zgarb 덕분에 -7 바이트!

Zgarb 덕분에 간접적으로 추가 4 바이트를 절약했습니다.

ḋhΣhgφṁȯ`Jḋ2⁰ṗp

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

설명

     φ             -- Define a recursive function which calls itself ⁰ and is applied to an Integer
      ṁ       p    -- map then concatenate over its prime factors
             ṗ     --   return their indices into the primes
            ⁰      --   and then recur, applying ⁰ to that number
       ȯ`Jḋ2       --   then surround it between the list [1,0] (binary 2)
    g              -- group adjacent equal elements
   h               -- drop last element (trailing 0s)
  Σ                -- concatenate
 h                 -- drop the last element
ḋ                  -- interpret as base 2

젤리 ,  22 20  19 바이트

Outgolfer Erik 덕분에 -1 ( t오른쪽이 아닌 양쪽에서 꼬리가 0 œr임)

ÆfÆC$ÐLŒṘO%3ḟ2Ḋt0ṖḄ

2보다 큰 정수를 가져와 0보다 큰 정수를 리턴하는 모나드 링크 (2는 원래 스펙에 따라 0을 리턴 함).

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

방법?

이것은 바이너리 배열의 생성을위한 서수 조작으로 주어진 설명을 거의 정확하게 복제합니다 ...

ÆfÆC$ÐLŒṘO%3ḟ2Ḋt0ṖḄ - Link: number n (>=2)
     ÐL             - loop until no more changes occur:
    $               -   last two links as a monad:
Æf                  -     prime factorisation (includes duplicates & vectorises)
  ÆC                -     count primes less than or equal (vectorises)
                    -   ...note for entries of 2 this yields [1]
                    -      then for entries of 1 it yields [], as required
       ŒṘ           - get a Python representation - just like in the OP,
                    -    something like: "[[], [[[]], [[]]]]" (for an input of 46)
         O          - convert to ordinals e.g. [91,91,93,44,32,91,91,91,93,93,44,32,91,91,93,93,93,93]
          %3        - modulo by 3         e.g. [ 1, 1, 0, 2, 2, 1, 1, 1, 0, 0, 2, 2, 1, 1, 0, 0, 0, 0]
            ḟ2      - filter discard twos e.g. [ 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0]
              Ḋ     - dequeue             e.g. [ 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0]
               t0   - strip zeros         e.g. [ 1, 0, 1, 1, 1, 0, 0, 1, 1]
                 Ṗ  - pop                 e.g. [ 1, 0, 1, 1, 1, 0, 0, 1]
                  Ḅ - binary to decimal   e.g. 185

파이썬 2 , 212 177 바이트

lambda n:int(g(n).rstrip("0")[1:-1],2)
g=lambda n:"1%s0"%"".join(map(g,p(n)))
def p(n,i=0,j=1):
 while n>1:
  j+=1;P=q=1;exec"P*=q*q;q+=1;"*~-j;i+=P%q
  while n%j<1:yield i;n/=j

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

프라임 빌트인이 없으면 바이트 수가 실제로 아프고 더 큰 프라임으로 TIO에서 시간이 초과됩니다. 용도는 XNOR 의 소수성 확인합니다.

파이썬 2 + gmpy2 , 175 바이트

lambda n:int(g(n).rstrip("0")[1:-1],2)
g=lambda n:"1%s0"%"".join(map(g,p(n)))
def p(n,i=0,j=1):
 while n>1:
  j+=1;i+=is_prime(j)
  while n%j<1:yield i;n/=j
from gmpy2 import*

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

이 버전은 더 큰 테스트 사례 (예 : 10000-10008)에서 시간 초과되지 않습니다.

매스 매 티카, 125 119 바이트

Flatten[#//.{{1}->{1,0},a_/;a>1:>{1,List/@PrimePi[Join@@Table@@@FactorInteger@a],0}}]/.{1,d__,1,0..}:>{d}~FromDigits~2&

약간 다른 접근법을 사용합니다. 소수를로 변환 {1, index, 0}하고 2를 로 변환 합니다 {1, 0}.

Wolfram Sandbox에서 사용해보십시오

용법:

f = Flatten[ ...

f[10008]

1402478

젤리 , 35 바이트

ÆfẎW€ÆC2,“”y¹ß€Ṇ?
ÇŒṘḊ⁾][iЀḟ0t1Ṗ’Ḅ

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

J, 74 73 66 바이트

3 :'#.(}.~ >:@i.&1)&.|.2+}.;<@(_2,~_1,[:>:[:_1&p:q:) ::<"0@;^:_ y'

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

이것은 확실히 추가 골프가 필요한 실제 혼란입니다 (예 : 명시 적 기능 정의 제거). 나는 내가하고있는 권투가 특히 내가하고있는 일을 정말로 알지 못하기 때문에 바이트 수를 늘리는 것이라고 생각합니다 (많은 시행 착오를 거쳤습니다). 또한, 난 꽤 확실 I (예 : I 같은 느낌에 대해 잊고 몇 가지 내장 기능이 있다는 것을 _2,~_1,아마가 내장되어 있습니다).

설명 (ungolfed)

전문

이것은 간단한 설명이 아니기 때문에 꽉 앉으십시오. 아이러니하게도, 간결한 언어는 장황한 사람과 짝을 이루었습니다.

이것을 몇 가지 기능으로 나누겠습니다

encode  =. 3 : '<@(_2,~_1, [: >: [: _1&p: q:) ::<"0@;^:_ y'
convert =. 3 : '2 + }. ; y'
drop    =. (}.~ >:@i.&1)&.|.
decode  =. #.

• encode [와] 대신 _1과 _2를 사용하여 정수를 인코딩합니다.
• convert _1과 _2의 목록을 1과 0의 목록으로 변환
• drop 마지막 1과 후행 0을 삭제합니다
• decode 이진 목록에서 숫자로 변환

나는 ungolfed 형식으로 표현 된 46에 대한 샘플 호출을 진행할 것입니다.

   decode drop convert encode 46
185

인코딩

여기에 설명 할 것이 많이 있습니다.

3 : '<@(_2,~_1, [: >: [: _1&p: q:) ::< "0@;^:_ y'
                                           ^:_      Do until result converges
                                          ;          Raze (remove all boxing)
                                       "0            For each
                               q:                     Factorize
                         _1&p:                        Get index of prime
                   >:                                 Add 1 (J zero-indexes)
            _1,                                       Prepend -1
        _2,~                                          Append -2
     <                                                Box resulting array
                                   ::                If there is an error
                                     <                Box the element

명시 적 함수 정의 3 : '[function]'는 함수를 REPL에있는 것처럼 모든 인수를 대체하는 올바른 인수를 사용하여 함수를 평가합니다 y(이는 비용을 지불하면서 대문자 ( [:), atops ( @) 및 ats ( @:) 를 사용하지 않아도됨을 의미합니다 ) 몇 바이트).

46의 입력에 대한 각 연속 반복에 대한 모양은 다음과 같습니다.

┌─────────┐    ┌──┬─────┬─────────┬──┐    ┌──┬──┬──┬──┬───────┬───────┬──┬──┐
│_1 1 9 _2│ => │_1│_1 _2│_1 2 2 _2│_2│ => │_1│_1│_2│_1│_1 1 _2│_1 1 _2│_2│_2│ =>
└─────────┘    └──┴─────┴─────────┴──┘    └──┴──┴──┴──┴───────┴───────┴──┴──┘

┌──┬──┬──┬──┬──┬─────┬──┬──┬─────┬──┬──┬──┐    
│_1│_1│_2│_1│_1│_1 _2│_2│_1│_1 _2│_2│_2│_2│ => the final iteration is just every
└──┴──┴──┴──┴──┴─────┴──┴──┴─────┴──┴──┴──┘    value in its own box

이 함수는 ::값을 "괄호"에 중첩시키기 위해 불리한 값 ( )을 사용합니다 (여기에 사용 된 대괄호는 -1과 -2입니다). 기본적으로 우리가 인수를 사용하여 소수 지수로 변환 할 때마다 _1이 앞에 붙고 _2가 추가되어 괄호 역할을합니다. 해당 요소에서 함수를 호출 q:하면 음수를 인수 화하려고 할 때 오류가 발생 하므로 그대로 반환합니다 . 운 좋게도 1을 분해하려고 할 때 오류가 발생 q:하지 않고 빈 배열을 원하는대로 반환합니다.

변하게 하다

3 : '2 + }. ; y'
            ;     Raze (remove boxing)
         }.       Behead (remove head)
     2 +          Add 2

변환은 훨씬 간단합니다. 첫 번째 요소뿐만 아니라 모든 권투를 제거한 다음 모든 것을 1과 0으로 변환합니다 (2를 추가하여 간단히)

하락

(}.~ >:@i.&1)&.|.
             &.|.  Reverse, apply the left function, and then undo
 }.~ >:@i.&1        Drop the leading zeroes and first 1
        i.&1         Index of first one
     >:              Add 1
 }.~                 Drop

이렇게하면 목록이 바뀌고 첫 번째 값을 찾은 다음 모든 값을 해당 값까지 삭제 한 다음 목록을 다시 되돌립니다.

풀다

디코드는 #.1과 0의 목록을 가져 와서 이진수로 변환 하는 내장 함수 입니다.

망막 , 244 (227) 225 바이트

+%(G`
\d+
$*0¶$&$*
+`^00(0+)
0$1¶$0
A`^(00+?)\1+$
^0+
$0;1
+`(1+)¶0+(?=¶)
$0;1$1
+`¶(11+?)(\1)*$
¶$1¶1$#2$*1
1$

m`^11$
[]
m`^1+
[¶$.0$*0¶]
+s`(0+);(1+)(.+¶)\1¶
$1;$2$3$2¶
0+;1+¶

)`1+
$.0
T`[]¶`10_
10+$

1
01
+`10
011
^0+

1

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

이것은 문제에서 입증 된 알고리즘을 따르는 직접적인 접근 방식입니다. 주요 인덱스 생성은 기하 급수적으로 복잡하므로 더 큰 입력에 대한 시간 초과

설명:

+%(G`                Repeatedly apply on each line:
\d+                      If the line is a number, convert it to unary 0s and 1s
$*0¶$&$*
+`^00(0+)                Generate all prefixes of the zeros greater than 1
0$1¶$0
A`^(00+?)\1+$            Remove non-prime strings of zeros
^0+                      Index the first zero set (00) as 1
$0;1
+`(1+)¶0+(?=¶)           Index the rest of the zeroes as their prime index
$0;1$1
+`¶(11+?)(\1)*$          Compute prime factors of input value
¶$1¶1$#2$*1
1$                       Remove the 1 factor (not really prime)

m`^11$                   Turn all 2 prime factors to []
[]
m`^1+                    Surround all non-2 prime factors in brackets
[¶$.0$*0¶]
+s`(0+);(1+)(.+¶)\1¶     Convert non-2 prime factors to their index
$1;$2$3$2¶
0+;1+¶                   Remove the list of primes

)`1+                     Return all primes back to decimal ready to be repeated
$.0
T`[]¶`10_            Then convert all [ to 1 and ] to 0, and remove linefeeds
10+$                 Remove the final 1 and trailing zeroes

1                    Convert from binary to unary
01
+`10
011
^0+

1                    Convert from unary to decimal

하스켈 , 162 (160) 155 바이트

sum.zipWith((*).(2^))[0..].tail.snd.span(<1).(r%)
r=zip[1..][x|x<-[2..],all((>0).mod x)[2..x-1]]
_%1=[]
((i,q):p)%n|mod n q<1=r%div n q++0:r%i++[1]|1<3=p%n

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

설명:

r=zip[1..][x|x<-[2..],all((>0).mod x)[2..x-1]]소수와 소수의 튜플의 무한 목록을 정의합니다 [(1,2),(2,3),(3,5),(4,7),(5,11),(6,13), ...].

이 함수 (%)는이 목록 r과 숫자를 가져 와서 n역수를 배열로 표현합니다. 이것은 r우리가 나누는 소수를 찾을 때까지 단계별로 수행됩니다 n. 우리는 반복적으로이 총리의 인덱스의 표현을 결정하고 묶어야 0과 1및의 표현 앞에 추가 n하는 소수로 나눈합니다.

의 경우 앞에 오는 0 ( )과 다음 ( )이 삭제 되는 n=46목록이 생성 [0,0,0,1,1,0,0,1,1,1,0,1]됩니다 . 그 후리스트는 요소 별 2의 거듭 제곱리스트를 곱하고 결과리스트를 합산하여 10 진수로 변환됩니다 .snd.span(<1)1tailsum.zipWith((*).(2^))[0..]

자바 스크립트, 289 바이트

바이트는 쉼표 뒤에 더 나은 줄 바꿈이없는 JavaScript 코드 (더 나은 형식화 및 가독성을 위해서만 삽입 됨) (256 바이트)와 Chrome을 사용할 때 필요한 명령 줄 스위치의 추가 문자 (33 바이트)의 합계입니다.

'use strict'
var f=(n,i=2,r=[])=>n>1?n%i?f(n,i+1,r):f(n/i,i,r.concat(i)):r,
c=(p,r=1,i=2)=>i<p?f(i)[1]?c(p,r,i+1):c(p,r+1,i+1):r-1?f(r).map(h):[],
h=a=>c(a),
s=a=>a.reduce((r,e)=>r+s(e),'1')+' ',
o=i=>+('0b'+s(f(i).map(h)).trim().replace(/ /g,'0').slice(1,-1))

더 길고 읽기 쉬운 버전 :

'use strict';
const f = (n,i=2,r=[]) => n>1 ? n%i ? f(n,i+1,r) : f(n/i,i,r.concat(i)) : r;
const c = (p,r=1,i=2) => i<p ? f(i)[1] ? c(p,r,i+1) : c(p,r+1,i+1) : r-1 ? f(r).map(h) : [];
const h = i => c(i);
const s = a => a.reduce((r,e) => r+s(e),'1')+' ';
const o = i => +('0b'+s(f(i).map(h)).trim().replace(/ /g,'0').slice(1,-1));

몇 가지 간단한 설명 :

f 순전히 기능적인 꼬리 재귀 인수 분해 알고리즘입니다.

cr소수의 소수에서 소수 p가 발생 하는 위치를 계산하고 [](if p=2및 r=1)를 반환하거나 r재귀를 통해 인수 분해하고 추가 프로세스 를 수행합니다.

h불행히도 두 번째와 세 번째 인수 로 map제공된 함수를 호출 할 때 필요한 작은 도우미 함수 이므로이 함수를 직접 전달하면 제공된 기본값을 무시합니다 (이 함정을 극복하는 데 약간의 시간이 걸렸습니다. 교체numberOfCurrentElementwholeArraych 그 정의로 몇 바이트 더 길어집니다).

s생성 된 배열을 문자열로 변환합니다. 우리는 사용하는 blank대신에 0우리가 사용할 수 있도록 trim()에서 o.

oi출력을 리턴하는 입력 값으로 호출 할 함수 입니다. 스펙에 필요한 2 진 문자열 표시를 생성하고이를 10 진수로 변환합니다.

편집 :chrome --js-flags="--harmony-tailcalls" 꼬리 재귀를 최적화 하려면 Chrome을 시작해야합니다 ( https://v8project.blogspot.de/2016/04/es6-es7-and-beyond.html 참조 ). 또한 엄격 모드를 사용해야합니다.

다음 테스트는 일부 값의 경우 계산이 약간 느리다는 것을 보여줍니다 ( 10007내 컴퓨터 에서 가장 긴 시간은 6 초 이상임). 흥미롭게도 테일 재귀를 최적화하지 않으면 스택 오버플로가 없을 때 계산이 훨씬 빠릅니다 (약 요소 5).

for (let i=3; i<=10008; i==10 ? i=10000 : ++i) {
    let time = new Date().getTime();
    let val = o(i);
    time = new Date().getTime() - time;
    document.write(i + ': ' + o(i) + ' (computed in ' + time + ' ms)<br>');
}

tinylisp , 209 바이트

(load library
(d [(q((N)(map(q((P)([(length(filter prime?(1to P))))))(reverse(prime-factors N
(d B(q((L)(c 1(insert-end 0(foldl concat(map B L
(d T(q((N)(if(mod N 2)(/ N 2)(T(/ N 2
(q((N)(T(from-base 2(t(B([ N

마지막 줄은 지정된 인코딩을 계산하는 명명되지 않은 함수입니다. 온라인으로 사용해보십시오!

프리 골프 버전

이것은 골프를 시작하기 전에 내가했던 코드입니다.

(load library)

(def prime-index
 (lambda (P)
  (length (filter prime? (1to P)))))

(def to-list
 (lambda (N)
  (map to-list
   (map prime-index
    (reverse (prime-factors N))))))

(def to-bits
 (lambda (L)
  (cons 1
   (insert-end 0
    (foldl concat
     (map to-bits L))))))

(def trim
 (lambda (N)
  (if (mod N 2)
   (div2 N 2)
   (trim (div2 N 2)))))

(def encode
 (lambda (N)
  (trim
   (from-base 2
    (tail (to-bits (to-list N)))))))

05AB1E , 18 바이트

ΔÒ.Ø>}¸»Ç3%2K0ܨ2β

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

설명:

Δ    }       # loop until a fixed point
 Ò           # replace each number with its prime factorization
  .Ø>        # replace each prime with its 1-based index
¸»           # after the loop: join to a string
  Ç          # get ASCII value of each character
   3%        # modulo 3 (maps '[' to 1, ']' to 0, ' ' to 2, ',' to 2)
     2K      # remove 2s
       0Ü    # trim trailing 0s
         ¨   # remove the last 1
          2β # parse as base 2