n > 2ได้รับจำนวนเต็มบวก เราแปลงเป็นอาร์เรย์ดังนี้

1. หากเท่ากับ2ส่งคืนอาร์เรย์ว่าง
2. มิฉะนั้นสร้างอาร์เรย์ของnปัจจัยสำคัญทั้งหมดที่เรียงลำดับจากน้อยไปมากจากนั้นแต่ละองค์ประกอบจะแทนที่ด้วยดัชนีในลำดับตัวเลขจำนวนมากและในที่สุดก็เปลี่ยนแต่ละองค์ประกอบเป็นอาร์เรย์

ตัวอย่างเช่นให้แปลงตัวเลข46เป็นอาร์เรย์ ประการแรกเปลี่ยนให้เป็นอาเรย์ของปัจจัยหลัก:

[2, 23]

จำนวน23เป็น9วันที่สำคัญดังนั้นแทนที่2กับอาร์เรย์ที่ว่างเปล่าและมี23 [9]ตอนนี้ Array จะกลายเป็น:

[[], [9]]

ปัจจัยสำคัญของการ9เป็น3และ3ดังนั้น:

[[], [3, 3]]

ทำเช่นเดียวกันสำหรับทั้งสอง3:

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

และในที่สุดก็:

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

ตอนนี้เพื่อเข้ารหัสมันเราเพียงแค่แทนที่วงเล็บเปิดแต่ละอัน1และแต่ละวงเล็บปิดด้วย0แล้วเอาศูนย์สิ้นสุดทั้งหมดแล้วปล่อยหนึ่ง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

1ตอนนี้ก็ลดลงในช่วงสามศูนย์และที่ผ่านมา จำนวนกลาย10111001เป็น185เลขทศนิยม นั่นคือผลลัพธ์ที่คาดหวัง ขอให้สังเกตว่าในอาเรย์ไปเป็นวงเล็บการแปลงแบบไบนารีของอาเรย์หลักจะไม่รวมอยู่

อินพุต

จำนวนเต็มบวกมากกว่าn2

เอาท์พุต

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

Sandbox

Husk , 35 31 30 29 26 25 24 22 20 19 15 ไบต์

-7 ไบต์ขอบคุณ @Zgarb!

บันทึกเพิ่มอีก 4 ไบต์โดยอ้อมขอบคุณZgarb

ḋ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 ไบต์

-1 ต้องขอบคุณErik the Outgolfer (ศูนย์หางจากทั้งสองด้านt, แทนที่จะมาจากด้านขวาœr)

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

ลิงก์ monadic ที่ใช้จำนวนเต็มมากกว่า 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

Python 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

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

ลองออนไลน์!

รุ่นนี้ไม่ได้หมดเวลาในกรณีทดสอบขนาดใหญ่ (เช่น 10,000 - 1,0008)

Mathematica, 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}และ {1, 0}2

ลองใช้กับ 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'

ลองออนไลน์!

นี่เป็นความยุ่งเหยิงที่แท้จริงซึ่งแน่นอนว่าต้องการการเล่นกอล์ฟเพิ่มเติม (เช่นการลบคำจำกัดความของฟังก์ชันที่ชัดเจน) ฉันคิดว่าการชกมวยที่ฉันทำมาโดยเฉพาะอย่างยิ่งสิ่งที่นำมาสู่จำนวน bytecount เพราะฉันไม่รู้ว่าฉันกำลังทำอะไรอยู่ที่นี่ นอกจากนี้ฉันค่อนข้างแน่ใจว่ามีบางส่วนในตัวฉันลืมเกี่ยวกับ (เช่นฉันรู้สึกว่า_2,~_1,อาจมีในตัว)

คำอธิบาย (ungolfed)

คำนำ

นั่งให้แน่นเพราะนี่จะไม่ใช่คำอธิบายสั้น ๆ กระแทกแดกดันภาษาสั้น ๆ ถูกจับคู่กับคน verbose

ฉันจะแยกมันออกเป็นสองสามฟังก์ชัน

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 อันสุดท้ายและเลขศูนย์ต่อท้าย
• decode แปลงจากรายการเลขฐานสองเป็นตัวเลข

ฉันจะเดินผ่านการเรียกตัวอย่าง 46 ซึ่งแสดงในรูปแบบ ungolfed เสร็จแล้ว

   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:จะเกิดข้อผิดพลาดในการพยายามแยกตัวประกอบจำนวนลบ นอกจากนี้ยังโชคดีที่q:ไม่ได้ข้อผิดพลาดในการพยายามที่จะ factorize 1 และแทนที่จะส่งกลับอาร์เรย์ว่างเปล่า (ตามที่ต้องการ)

แปลง

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

การแปลงนั้นง่ายกว่ามาก มันเพียงเอาการชกมวยทั้งหมดรวมถึงองค์ประกอบแรกแล้วแปลงทุกอย่างเป็น 1 วินาทีและ 0 วินาที (เพียงเพิ่ม 2)

Drop

(}.~ >:@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

นี่เป็นการย้อนกลับรายการค้นหารายการแรกจากนั้นปล่อยค่าทั้งหมดจนถึงค่านั้นจากนั้นกลับรายการอีกครั้ง

ถอดรหัส

Decode เป็นฟังก์ชันในตัว#.ซึ่งรับรายการ 1s และ 0s แล้วแปลงเป็นเลขฐานสอง

เรติน่า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

Haskell , 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หารด้วยนายกนั้น

สำหรับn=46สิ่งนี้จะทำให้รายการ[0,0,0,1,1,0,0,1,1,1,0,1]ที่ศูนย์นำหน้า ( snd.span(<1)) และถัดไป1( tail) ถูกดร็อป sum.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 เป็นอัลกอริธึมการแยกตัวประกอบหางแบบเรียกซ้ำได้

cนับว่าสถานที่ใดที่rมีจำนวนเฉพาะpเกิดขึ้นในลำดับของจำนวนเฉพาะและส่งคืนทั้ง[](ถ้าp=2และr=1) หรือแยกตัวประกอบและประมวลผลเพิ่มเติมrโดยใช้การเรียกซ้ำ

hเป็นฟังก์ชั่นตัวช่วยเล็ก ๆ ซึ่งน่าเสียดายที่จำเป็นต้องmapเรียกฟังก์ชั่นที่ให้มาด้วยnumberOfCurrentElementเป็นอันดับที่สองและwholeArrayเป็นข้อโต้แย้งที่สามดังนั้นการแทนที่ค่าเริ่มต้นที่ระบุไว้ในcถ้าเราจะผ่านฟังก์ชั่นนี้โดยตรง การแทนที่hด้วยคำจำกัดความจะมีความยาวไม่กี่ไบต์)

sแปลงอาร์เรย์ที่สร้างขึ้นเป็นสตริง เราใช้blankแทน0เพื่อให้เราสามารถใช้ในtrim()o

oเป็นฟังก์ชั่นที่จะเรียกพร้อมกับค่าอินพุตiที่ส่งคืนเอาต์พุต มันสร้างการแสดงสตริงไบนารี่ที่ต้องการโดยสเปคและแปลงเป็นเลขฐานสิบ

แก้ไข: Chrome ต้องเริ่มต้นด้วยchrome --js-flags="--harmony-tailcalls"เพื่อเปิดใช้งานการเพิ่มประสิทธิภาพการเรียกซ้ำ (ดูhttps://v8project.blogspot.de/2016/04/es6-es7-and-beyond.html ) สิ่งนี้ยังต้องใช้โหมดเข้มงวด

การทดสอบต่อไปนี้แสดงให้เห็นว่าการคำนวณนั้นช้าเล็กน้อยสำหรับบางค่า (ที่ยาวที่สุดคือมากกว่าหกวินาทีสำหรับ10007คอมพิวเตอร์ของฉัน) ที่น่าสนใจคือหากไม่มีการเพิ่มประสิทธิภาพการเรียกซ้ำแบบหางการคำนวณจะเร็วขึ้นมาก (ประมาณ 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