พื้นหลัง

ลำดับ 1-2-3-Tribonacci

ลองจินตนาการถึงวินาทีที่คุณสามารถสร้างลำดับฟีโบนักชีโดยแทนที่สูตรการทำซ้ำมาตรฐานด้วยสิ่งต่อไปนี้:

โดยพื้นฐานแล้วแทนที่จะรวมสองครั้งสุดท้ายเพื่อให้ได้คะแนนถัดไปคุณจะรวมสามครั้งสุดท้าย นี่เป็นพื้นฐานสำหรับลำดับ 1-2-3-Tribonacci

เกณฑ์ของบราวน์

สถานะเกณฑ์ของ Brown ที่คุณอาจแทนค่าจำนวนเต็มใด ๆ เป็นผลรวมของสมาชิกของลำดับที่จัดทำโดย:

1. 

2. สำหรับทั้งหมดที่nมากกว่า 1

สิ่งนี้มีความหมายสำหรับความท้าทาย

คุณอาจอธิบายจำนวนเต็มบวกใด ๆ เป็นผลรวมของสมาชิกของลำดับ 1-2-3-Tribonacci ที่เกิดขึ้นตามเงื่อนไขเริ่มต้นต่อไปนี้:

สิ่งนี้เรียกว่าสำหรับทุกค่าในลำดับนี้อัตราส่วนระหว่างเทอมจะไม่เกิน 2 (อัตราส่วนโดยเฉลี่ยอยู่ที่ประมาณ 1.839)

วิธีเขียนในระบบการแสดงตัวเลข

สมมติว่าคุณใช้การแทนค่าแบบเอนด์เอนเดียน จัดเรียงสมาชิกตามลำดับดังนี้:

1  2  3  6 11 20 37 68

จากนั้นคุณจะใช้หมายเลขของคุณที่จะเป็นตัวแทน (สำหรับการทดสอบของเราขอบอกว่ามันเป็น63) และหาค่าที่กำหนด 1-2-3-Tribonacci ซึ่งรวมไป 63 (ใช้ค่าที่ใหญ่ที่สุดครั้งแรก!) ถ้าจำนวนนั้นเป็นส่วนหนึ่งของผลรวมให้ใส่ 1 อันใต้ 0 ถ้าไม่

1  2  3  6 11 20 37 68
0  0  0  1  0  1  1  0

คุณสามารถทำสิ่งนี้สำหรับจำนวนเต็มใด ๆ ที่ระบุ - เพียงตรวจสอบว่าคุณใช้ค่าที่ใหญ่ที่สุดด้านล่างใส่ของคุณก่อน!

คำจำกัดความ (สุดท้าย)

เขียนโปรแกรมหรือฟังก์ชั่นที่จะทำสิ่งต่อไปนี้ให้ป้อนจำนวนเต็มบวกn(เขียนในฐานมาตรฐาน) ระหว่าง 1 และค่าสูงสุดของภาษาของคุณ:

1. แปลงค่าเป็นการแสดงตัวเลข 1-2-3-Tribonacci ที่กำหนดไว้
2. ใช้การแทนแบบไบนารี่นี้และอ่านราวกับว่ามันเป็นไบนารี่ ซึ่งหมายความว่าตัวเลขยังคงเหมือนเดิม แต่สิ่งที่พวกเขาหมายถึงการเปลี่ยนแปลง
3. ใช้เลขฐานสองนี้แล้วแปลงเป็นฐานของหมายเลขเดิม
4. เอาท์พุทหรือส่งกลับจำนวนใหม่นี้

อย่างไรก็ตามตราบใดที่เอาต์พุตนั้นถูกต้องคุณไม่จำเป็นต้องทำตามขั้นตอนเหล่านี้ หากคุณพบสูตรบางอย่างที่สั้นกว่า (และเทียบเท่าทางคณิตศาสตร์) อย่างน่าอัศจรรย์อย่าลังเลที่จะใช้มัน

ตัวอย่าง

ให้ฟังก์ชั่นfเป็นฟังก์ชั่นที่อธิบายโดยคำจำกัดความและให้[]เป็นตัวแทนของขั้นตอนที่ดำเนินการ (ในฐานะที่เป็น endian น้อยแม้ว่ามันจะไม่สำคัญ) (คุณไม่จำเป็นต้องทำตามกระบวนการนี้นี่เป็นเพียงกระบวนการที่อธิบายไว้):

>>> f(1)
[1]
[1]
[1]
1

>>> f(5)
[5]
[0, 1, 1]
[6]
6

>>> f(63)
[63]
[0, 0, 0, 1, 0, 1, 1]
[104]
104

Javascript 117 111 bytes

ขอบคุณ @theonlygusti ที่ช่วยตีกอล์ฟขนาด 5 ไบต์

x=>{r=0;a=[1,2,3];i=1;while(a[++i]<x)a[i+1]=a[i]+a[i-1]+a[i-2];for(;x;i--)if(x>=a[i]){r+=1<<i;x-=a[i]}return r}

มันทำงานอย่างไร

ก่อนอื่นฟังก์ชันจะสร้างหมายเลข tribonacci ทั้งหมดจนกว่าจะพบว่ามีค่ามากกว่าอินพุต

a=[1,2,3];i=1;for(;a[++i]<x;)a[i+1]=a[i]+a[i-1]+a[i-2];

ถัดไปมันจะค้นหารายการตัวเลข หากตัวเลขมีค่าน้อยกว่าอินพุตจะเพิ่ม 2 ^ (ดัชนีของตัวเลขนั้น) ให้กับค่าส่งคืนและลดอินพุตด้วยตัวเลขนั้น

for(;x;i--)if(x>=a[i]){r+=1<<i;x-=a[i]}

ในที่สุดมันก็จะส่งคืนผลลัพธ์

ลองออนไลน์

Python 2 , 110 102 ไบต์

-3 ไบต์ต้องขอบคุณ Rod (เคล็ดลับที่เรียบร้อยสำหรับการหล่อบูลีนiไปยัง int ด้วย+iดังนั้นการ`+i`ทำงานซ้ำ)

n=input()
x=[3,2,1]
r=''
while x[0]<n:x=[sum(x[:3])]+x
for v in x:i=n>=v;n-=v*i;r+=`+i`
print int(r,2)

ลองออนไลน์!

JavaScript (ES6), 97 93 ไบต์

ที่นี่เราใช้reduce()กับฟังก์ชันแบบเรียกซ้ำ เราคิดว่าผลลัพธ์เป็น 31 บิต (ซึ่งเป็นปริมาณที่ไม่ได้ลงนามมากที่สุดที่ JS สามารถทำงานกับการดำเนินการระดับบิตได้อย่างง่ายดาย)

n=>[...Array(x=31)].reduce(p=>(c=(F=k=>k<4?k:F(--k)+F(--k)+F(--k))(x--))>n?p:(n-=c,p|1<<x),0)

ประสิทธิภาพการทำงานที่ชาญฉลาดนี้ไม่ชัดเจนว่ามีประสิทธิภาพมาก

สำหรับความอยากรู้อยากเห็น:

• อัตราส่วนระหว่างจำนวนการโทรไปยังF()การreduce()ทำซ้ำN + 1 กับการทำซ้ำ N การแปลงต่อไปยัง Tribonacci Constant (≈ 1.83929) อย่างรวดเร็ว ดังนั้นบิตเพิ่มเติมแต่ละรายการในค่าใช้จ่ายจะใช้เวลาประมาณสองเท่าของเวลาก่อนหน้า
• ด้วย 31 บิตF()ฟังก์ชันเรียกว่าดี 124 ล้านครั้ง

ทดสอบ

หมายเหตุ: การดำเนินการนี้อาจใช้เวลา 1 หรือ 2 วินาที

let f =

n=>[...Array(x=31)].reduce(p=>(c=(F=k=>k<4?k:F(--k)+F(--k)+F(--k))(x--))>n?p:(n-=c,p|1<<x),0)

console.log(f(63))

Mathematica, 78 74 ไบต์

Fold[#+##&,#~NumberDecompose~Reverse@LinearRecurrence[{1,1,1},{1,2,3},#]]&

LinearRecurrence[{1,1,1},{1,2,3},#]สร้างรายการความยาวเท่ากับอินพุตของหมายเลข 1-2-3 tribonacci ( {1,1,1}แสดงถึงผลรวมของคำสามคำก่อนหน้านี้ในขณะที่{1,2,3}เป็นค่าเริ่มต้น) จากนั้น#~NumberDecompose~ค้นหาวิธี greediest ในการเขียนอินพุตเป็นผลรวมขององค์ประกอบของรายการ (นี่คือฟังก์ชั่นเดียวกันที่จะย่อยสลายจำนวนเงินเป็นทวีคูณของ ตัวอย่างเช่นสกุลเงินที่มีอยู่) ในที่สุดFold[#+##&,...]แปลงรายการไบนารีผลลัพธ์เป็นจำนวนเต็ม (ฐาน -10)

การส่งก่อนหน้า:

Fold[#+##&,#~NumberDecompose~Reverse@Array[If[#<4,#,Tr[#0/@(#-Range@3)]]&,#]]&

ตามปกติแล้วเป็นกรณี (แม้ว่าจะไม่ใช่ด้านบน) รุ่น golfed นี้ช้ามากในอินพุตที่มีขนาดใหญ่กว่า 20 หรือมากกว่านั้นเพราะมันสร้าง (ด้วยการเรียกซ้ำที่ไม่เหมาะสม) รายการของเผ่าที่มีความยาวเป็นอินพุต แทนที่สุดท้าย#ด้วยขอบเขตที่สมเหตุสมผลเช่นRound[2Log@#+1]ผลลัพธ์ในประสิทธิภาพที่ดีขึ้นมาก

Haskell, 95 ไบต์

(a!b)c=a:(b!c)(a+b+c)
e#(r,c)|c-e<0=(2*r,c)|1<2=(2*r+1,c-e)
f n=fst$foldr(#)(0,n)$take n$(1!2)3

ตัวอย่างการใช้งาน: ->f 63 ลองออนไลน์! .104

มันทำงานอย่างไร: !สร้างลำดับ 1-2-3-Tribonacci ป.ร. ให้ไว้1, 2และ3เป็นพารามิเตอร์เริ่มต้นที่เราใช้เวลาแรกnองค์ประกอบของลำดับ จากนั้นเราจะพับจากฟังก์ชันที่เหมาะสม#ซึ่งจะลบองค์ประกอบถัดไปeจากnและตั้งค่าบิตในค่าส่งคืนrถ้าeต้องการหรือปล่อยให้บิตตั้งค่า การตั้งค่าบิตเพิ่มขึ้นเป็นสองเท่าrและการเพิ่มการตั้งค่าบิตจะเพิ่มขึ้น1เป็นสองเท่า

เยลลี่ 31 ไบต์

S=³
3RUµḣ3S;µ<³Ạµ¿µŒPÇÐfṀe@ЀµḄ

ลองออนไลน์!

ฉันเกือบจะแน่ใจว่ามีวิธีที่สั้นกว่ามากในการบรรลุเป้าหมายนี้ในเยลลี่

อย่างไร?

S=³ - Link 1, compare sum to input: list
S   - sum
  ³ - 3rd command line argument which is 1st program argument.
 =  - equal?

3RUµḣ3S;µ<³Ạµ¿µŒPÇÐfṀe@ЀµḄ - Main link: n
3RU                         - range(3) upended -> [3,2,1]
   µ    µ   µ¿              - while
         <³                 - less than input (vectorises)
           Ạ                - all?
    ḣ3S;                    -     head(3), sum, and concatenate
                                  [3,2,1] -> [6,3,2,1] -> [11,6,3,2,1] -> ...
              µ             - monadic chain separation, call the result x
               ŒP           - power set of x - e.g. for [6,3,2,1] -> [[],[6],[3],[2],[1],[6,3],[6,2],[6,1],[3,2],[3,1],[2,1],[6,3,2],[6,3,1],[6,2,1],[3,2,1],[6,3,2,1]]
                  Ðf        - filter keep
                 Ç          -     last link (1) as a monad (those that sum to the input)
                    Ṁ       - maximum (e.g. an input of 63 would yield [[37,20,6],[37,20,3,2,1]], the maximum of which is [37,20,6], the one with the largest numbers used)
                         µ  - monadic chain separation (to have x as the right argument below)
                     e@Ѐ   - exists in with reversed arguments mapped over x (e.g. [37,20,6] with x = [68,37,20,11,6,3,2,1] yields [0,1,1,0,1,0,0,0])
                          Ḅ - convert from binary to integer.        

Perl 6 , 93 91 bytes

-2 ไบต์ขอบคุณ b2gills

{my@f=1,2,3,*+*+*...*>$^n;sum @f».&{$_~~any first *.sum==$n,@f.combinations}Z*(2 X**^∞)}

มันทำงานอย่างไร

• อันดับแรกสร้างลำดับ 1-2-3-Tribonacci จนถึงองค์ประกอบแรกที่มีขนาดใหญ่กว่าอินพุต:

  my @f = 1, 2, 3, *+*+* ... * > $^n;

• ขึ้นอยู่กับว่ามันจะพบส่วนย่อยของลำดับที่เพิ่มขึ้นในการป้อนข้อมูล:

  first *.sum==$n, @f.combinations

• ตามที่มันสร้างรายการบูลีนระบุว่าแต่ละองค์ประกอบของลำดับเป็นส่วนหนึ่งของผลรวม:

  @f».&{$_~~any ...}

• และในที่สุดมันก็ตีความรายการของ True = 1, False = 0 ค่าเป็นฐาน 2 และส่งกลับเป็นหมายเลข (ฐาน 10):

  sum ... Z* (2 X** ^∞)

JavaScript (ES6), 61 60 ไบต์

n=>(g=(x,y,z)=>(n>x&&g(y,z,x+y+z)*2)+!(n<x||![n-=x]))(1,2,3)

คำนวณตัวเลข 1-2-3-Tribonacci จนกว่าจะถึงหมายเลขเดิมจากนั้นเมื่อการเรียกซ้ำคลายลงพยายามที่จะลบแต่ละตัวในทางกลับกันโดยเพิ่มผลลัพธ์เป็นสองเท่า

แก้ไข: บันทึก 1 ไบต์ขอบคุณ @Arnauld

รุ่นที่151 148 145 ไบต์

@set/ar=0,n=%1
@call:c 3 2 1
@echo %r%
@exit/b
:c
@set/as=%1+%2+%3
@if %n% gtr %3 call:c %s% %*
@set/ar*=2
@if %n% geq %3 set/an-=%3,r+=1

คำตอบของ JavaScript พอร์ตของฉัน แก้ไข: บันทึกไว้ 3 ไบต์โดยผ่านการขัดแย้งย่อยของฉันในการสั่งซื้อย้อนกลับและอีก 3 ไบต์โดยใช้บุคคล@s @echo offในแต่ละบรรทัดแทน

วุ้น , 19 18 17 ไบต์

Ḣx3+
BÇL¡2ị
²Ç€»ċ

ลองออนไลน์!

พื้นหลัง

แทนที่จะพยายามแปลงจำนวนเต็มเป็นฐาน 1,2,3-Tribonacci จากเลขฐานสองเป็นจำนวนเต็มเราจะทำตรงกันข้าม: แปลงจำนวนเต็มเป็นเลขฐานสองจากนั้นแปลงจากฐาน 1,2,3-Trionacci เป็นจำนวนเต็มและกลับ ค่าสูงสุดที่ตรงกับอินพุต สามารถทำได้อย่างง่ายดาย

เราจะยกตัวอย่างกระบวนการสำหรับการป้อนข้อมูล63โดยเฉพาะขั้นตอนที่มีการทดสอบ104 ในระบบเลขฐานสองจากที่สำคัญที่สุดไปถึงตัวเลขที่สำคัญน้อยที่สุด104เท่ากับ

 1  1  0  1  0  0  0
37 20 11  6  3  2  1

โดยที่แถวที่สองแสดงค่าตำแหน่งของตัวเลขเหล่านั้น

เราสามารถขยายลำดับ 1,2,3-Tribonacci ไปทางขวาโดยสังเกตว่าตัวเลขที่เพิ่มเข้ามานั้นสอดคล้องกับสูตรแบบเรียกซ้ำ สำหรับตัวเลขสามหลักจะทำให้

 1  1  0  1  0  0  0  0  0  0
37 20 11  6  3  2  1  0  1  0

ตอนนี้ในการคำนวณค่าของเลขฐาน 1,2,3-Tribonacci เราสามารถใช้สูตรเรียกซ้ำได้ เนื่องจากแต่ละหมายเลขคือผลรวมของตัวเลขสามตัวทางด้านขวา (ในตารางด้านบน) เราสามารถลบตัวเลขแรกและเพิ่มไปยังตัวเลขสามหลักแรกของอาร์เรย์ที่เหลือ หลังจาก7ขั้นตอนซึ่งเท่ากับจำนวนเลขฐานสอง104เราหายากเหลือเพียงสามหลัก

 1  1  0  1  0  0  0  0  0  0
37 20 11  6  3  2  1  0  1  0

    2  1  2  0  0  0  0  0  0
   20 11  6  3  2  1  0  1  0

       3  4  2  0  0  0  0  0
      11  6  3  2  1  0  1  0

          7  5  3  0  0  0  0
          6  3  2  1  0  1  0

            12 10  7  0  0  0
             3  2  1  0  1  0

               22 19 12  0  0
                2  1  0  1  0

                  41 34 22  0
                   1  0  1  0

                     75 63 41
                      0  1  0

ทีนี้เนื่องจากตัวเลขที่เหลืออยู่ตัวแรกและตัวสุดท้ายมีค่าเป็นตำแหน่ง0ผลลัพธ์ก็คือตัวเลขกลางนั่นคือ 63 63

มันทำงานอย่างไร

²Ç€»ċ   Main link. Argument: n

²       Yield n². Since 1.839² = 3.381921 > 2, the range [1, ..., n²] will contain
        the answer. Better bounds, at the cost of additional bytes are possible.
 Ç€     Map the the second helper link over [1, ..., n²].
   »    Take the maximum of n and each result.
    ċ   Count the occurrences of n.


BÇL¡2ị  Second helper link. Left argument: k. Right argument: n

B       Convert k to binary. Let's call the result A.
  L     Length; count the number of binary digits. Let's call the result l.
 Ç ¡    Apply the first helper link l times to A.
    2ị  Retrieve the second element.


Ḣ×3+    First helper link. Argument: A (array)

Ḣ       Head; pop and yield the first element of A.
 x3     Repeat it thrice.
   +    Add the result, component by component, to the beheaded A.

เยลลี่ ( ส้อม ) 17 16 ไบต์

ḣ3S;µ¡
3RṚdzæFṪḄ

บันทึกแล้ว 1 ไบต์ขอบคุณ @Dennis ผู้เล่นกอล์ฟโดยที่ไม่ต้องวิ่ง

สิ่งนี้ขึ้นอยู่กับทางแยกของ Jelly ที่ฉันยังคงผิดหวังในการใช้อะตอม Frobenius แก้ปัญหาที่มีประสิทธิภาพ สำหรับผู้ที่สนใจฉันต้องการจับคู่ความเร็วของ Mathematica FrobeniusSolveและโชคดีที่มีคำอธิบายเกี่ยวกับวิธีการของพวกเขาในกระดาษ "การเปลี่ยนแปลงและค้นหา Repfigits: Balancing a Knapsack" โดย Daniel Lichtblau

คำอธิบาย

ḣ3S;µ¡  Helper link. Input: a list
    µ   Create monadic chain
ḣ3        Take the first 3 items
  S       Sum
   ;      Prepend to the list
     ¡  Repeat it n (initial argument from main) times

3RṚdzæFṪḄ  Main link. Input: integer n
3          The constant 3
 R         Range. Makes [1, 2, 3]
  Ṛ        Reverse. Makes [3, 2, 1]
   Ç       Call the helper link on that list.
           Generates the first (n+3) 123-Tribonacci values in reverse
    ³      Get n
     æF    Frobenius solve for n using the first n 123-Tribonacci values in reverse
       Ṫ   Tail. Take the last value. The results of Frobenius solve are ordered
           where the last result uses the least
        Ḅ  Unbinary. Convert digits from base 2 to base 10

dc , 110 102 ไบต์

?se1sa2sb3sc_1sf[laddSdlbdsalcdsb++sclf1+sfle>y]dsyx0sk[lk2lf^+skler-se]sr[Lddle!<rlf1-dsf0!>z]dszxlkp

ดูเหมือนว่าจิตใจที่ดีจะคิดเหมือนกัน เห็นได้ชัดว่าอัลกอริทึมที่ฉันสร้างขึ้นเพื่อหลีกเลี่ยงข้อ จำกัด ของdcมันคือสิ่งเดียวกับที่ใช้ในคำตอบของ @ LliwTelrac โดยบังเอิญ น่าสนใจ

ลองออนไลน์!

Python 2 , 93 ไบต์

n=input();y=k=n*n
while y>n:
 x=y=z=0;k-=1
 for t in bin(k):x+=t=='1';x,y,z=y+x,z+x,x
print k

นี่คือพอร์ตของ คำตอบของฉัน Jelly

ลองออนไลน์!

bash + อรรถประโยชน์ของ BSD (OS X, ฯลฯ ), 53 ไบต์

jot $[2#$1**4]|egrep -v '[2-9]|11(1|$)'|sed $[2#$1]!d

bash + โปรแกรมอรรถประโยชน์ GNU (ทำงานภายใต้ BSD ด้วย), 59 ไบต์

seq -f2o%.fp $[2#$1**2]|dc|egrep -v '11(1|$)'|sed $[2#$1]!d

อินพุตและเอาต์พุตในทั้งสองข้างต้นอยู่ในรูปแบบไบนารี

ลองรุ่น GNU ที่ TIO (ตัวอย่างที่เชื่อมโยงเพื่อแสดงอินพุต 111111 ซึ่งคือ 63 ในไบนารี่และเอาท์พุตของ 1101000 ซึ่ง 104 ในไบนารี่)

ฉันไม่คิดว่า TIO จะเสนอตัวเลือก BSD แต่ถ้าคุณมี Mac ให้ใช้งานคุณสามารถลองใช้ได้ทั้งสองวิธี (โปรแกรม 59- ไบต์คือประโยชน์มากมายเร็วกว่าโปรแกรม 53 ไบต์.)

น่าเสียดาย, seqไม่สามารถทิ้งลงในโซลูชัน BSD แทนjotเนื่องจากรูปแบบเอาต์พุตสำหรับseqแตกต่างกันสำหรับเอาต์พุตที่สูงกว่า 999999 (สิ่งนี้เริ่มเป็นปัญหาสำหรับอินพุตประมาณ 32 ตั้งแต่ 32 ^ 4> 1000000)

คุณสามารถแทนที่jotข้างต้นด้วยseq -f%.fเพื่อให้สิ่งนี้ทำงานกับยูทิลิตี้ GNU แต่สำหรับ 59 ไบต์เดียวกันคุณสามารถใช้โซลูชัน GNU ด้านบนซึ่งเร็วกว่ามาก