Monday Mini-Golf:ชุดของความท้าทายรหัสสั้น ๆกอล์ฟโพสต์ (หวังว่า!) ทุกวันจันทร์

Fibonacci เหมือนลำดับจะได้รับโดยใช้วิธีการเดียวกับที่มีชื่อเสียงลำดับฟีโบนักชี ; นั่นคือแต่ละหมายเลขF (n)ถูกค้นพบโดยการเพิ่มตัวเลขสองตัวก่อนหน้านี้ในลำดับ ( F (n) = F (n-1) + F (n-2) ) หรือโดยการลบตัวเลขสองตัวถัดไป ( F (n) = F (n + 2) - F (n + 1) ) ความแตกต่างที่สำคัญคือลำดับเหล่านี้สามารถเริ่มต้นด้วยตัวเลขสองตัวใด ๆ การจัดทำดัชนีเป็นศูนย์ของลำดับเหล่านี้ไม่แน่นอน แต่สำหรับตอนนี้เราจะใช้กฎนี้:

• หมายเลขที่ 0 ในลำดับที่เหมือน Fibonacci คือหมายเลขสุดท้ายซึ่งเล็กกว่าหมายเลขก่อนหน้า

ตัวอย่างเช่นลำดับฟีโบนักชีอาจจะเขียนเป็น1, 0, 1, 1, 2, 3, 5...ดังนั้นจำนวน 0 0ในลำดับเป็นคนเดียว

ท้าทาย

เป้าหมายของการท้าทายคือการเขียนโปรแกรมหรือฟังก์ชั่นที่ใช้จำนวนเต็มสามตัวในรูปแบบใดก็ได้:

• AและBหมายถึงตัวเลขสองตัวที่จะเริ่มสร้างลำดับ
• Nความยาวของลำดับผลลัพธ์เป็นเอาต์พุต

และส่งออกตัวเลขNแรกของลำดับเริ่มต้นที่ 0

รายละเอียด

• อาจใช้ A , BและNในลำดับและรูปแบบใดก็ได้ตราบใดที่แยกออกจากกันอย่างชัดเจน หากคุณใช้คำสั่ง / รูปแบบอื่นโปรดระบุว่ามันคืออะไร
• คุณอาจสมมติว่าA , BและNเป็นจำนวนเต็มบวกเสมอ
• คุณอาจจะคิดว่าไม่มีคือไม่เกิน 100 x >= 2^31และลำดับผลจะไม่ประกอบด้วย
• ถ้าAใหญ่กว่าBดังนั้นBคือหมายเลขที่ 0 ในลำดับ
• เอาต์พุตจะต้องคั่นด้วยช่องว่างเครื่องหมายจุลภาคและ / หรือบรรทัดใหม่
• อนุญาตการเว้นวรรคหรือการขึ้นบรรทัดใหม่ แต่ไม่ใช่เครื่องหมายจุลภาคต่อท้าย

การทดสอบกรณี

ตัวอย่างที่ 1:

8 13 10

การทำงานย้อนกลับจากจนกว่าเราจะพบว่าจำนวนขนาดใหญ่กว่าก่อนหน้านี้ที่เราได้รับ8 13 13 8 5 3 2 1 1 0 1ดังนั้นจึง0เป็นหมายเลขที่ 0 ในลำดับนี้ เราจะพิมพ์ออกมา0และสมาชิก 9 คนถัดไป:

0 1 1 2 3 5 8 13 21 34

ตัวอย่างที่ 2:

23 37 5

อีกครั้งการทำงานย้อนหลังเพื่อหาจำนวน 0 37 23 14 9 5 4 1 3เราพบ หมายเลข 0 ในเวลานี้คือ1ดังนั้นเราจึงพิมพ์ออกมาพร้อมกับสมาชิก 4 คนถัดไป:

1 4 5 9 14

ตัวอย่างที่ 3:

4 3 8

ด้วยหมายเลขนี้เราไม่จำเป็นต้องย้อนกลับเพื่อหาหมายเลขที่ 0 เพราะ3เล็กกว่า4:

3 7 10 17 27 44 71 115

ตัวอย่างที่ 4:

29 47 11

ผล:

1 3 4 7 11 18 29 47 76 123 199

เกณฑ์การให้คะแนน

นี่คือรหัส - กอล์ฟดังนั้นรหัสที่ถูกต้องสั้นที่สุดในหน่วยไบต์ชนะ Tiebreaker ไปที่การโพสต์ก่อนหน้านี้ ผู้ชนะจะได้รับเลือกในวันจันทร์ที่ 28 ก.ย. โชคดี!

แก้ไข:ขอแสดงความยินดีกับผู้ชนะของคุณ @Jakube โดยใช้ Pyth ขนาด 23 ไบต์ที่น่าทึ่ง!

Pyth, 23 ไบต์

AQWgHGA,-HGG)VvwHA,H+GH

ลองออนไลน์: การสาธิตหรือชุดทดสอบ

สไตล์การเขียนโปรแกรม Pyth ค่อนข้างผิดปกติ บางครั้งการเขียนโปรแกรมที่ใช้งานได้มีข้อเสีย

คำอธิบาย:

AQWgHGA,-HGG)VvwHA,H+GH  Q = input list of the two starting numbers
AQ                       G, H = Q (unpacking Q)
  WgHG                   while H >= G:
      A,-HGG                G, H = [H - G, G]
            )            end while
              vw         read a number from input
             V           for N in range(^):
                H           print H
                 A,H+GH     G, H = [H, G + H]

เรติน่า65 65ไบต์

+`(1*),\1(1*)
$2,$1
+`(1*)(,1*);1\B
$1$2$2$1;
^1*,|;1
<empty>

ที่นี่ <empty>แสดงถึงบรรทัดต่อท้ายที่ว่างเปล่า เรียกใช้รหัสเป็นไฟล์เดียวกับ-sธง

รูปแบบการป้อนข้อมูลคือ

A,B;N

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

8 13 10

อยากจะเป็น

11111111,1111111111111;1111111111

และผลผลิต

,1,1,11,111,11111,11111111,1111111111111,111111111111111111111,1111111111111111111111111111111111

คำอธิบาย

+`(1*),\1(1*)
$2,$1

ก่อนอื่นเราลดAและBไปที่องค์ประกอบที่ 0 และ -1 +บอก Retina เพื่อให้การทำซ้ำเปลี่ยนตัว regex นี้จนกว่าทั้ง regex หยุดการจับคู่หรือการทดแทนไม่ได้ปรับเปลี่ยนสตริง ดังกล่าวจะรวบรวม regex Aเข้าไปในกลุ่มที่ 1 ด้วย(1*)แล้วทำให้แน่ใจว่าBอย่างน้อยเป็นใหญ่เป็นAในขณะที่จับB-Aกับ\1(1*)ในกลุ่ม 2. A>Bเพื่อให้แน่ใจว่านี้วงนี้ยุติครั้งเดียว

การเปลี่ยนตัวจะเปลี่ยนA,Bเป็นB-A,Aโดยการตั้งค่าการจับคู่เป็น$2,$1โดยการตั้งค่าการแข่งขันไป

+`(1*)(,1*);1\B
$1$2$2$1;

ตอนนี้เราได้รับหมายเลขแรกของผลลัพธ์ที่ต้องการในสตริง (เช่นเดียวกับก่อนหน้านั้นซึ่งเราจะต้องกำจัดออกในภายหลัง) เปลี่ยนตัวตอนนี้เพิ่มอีกหมายเลขหนึ่งเป็นผลรวมของตัวเลขสองที่ผ่านมาในขณะที่การจาก1 เพราะการที่เรามีอยู่แล้วจำนวนหนึ่งที่เราอยากให้เรื่องนี้เกิดขึ้นเฉพาะN N-1เราทำสิ่งนี้โดยทำให้มั่นใจ\Bว่ายังมีอย่างน้อย;11ในตอนท้ายของสตริง หากเราเรียกค่าสองค่าสุดท้ายของลำดับCและDจากนั้น regex จะจับภาพCเป็นกลุ่ม 1 และ,Dเป็นกลุ่มสอง $1$2เราเขียนกลับผู้ที่มี จากนั้นเราก็ยังเขียนซึ่งแปล$2$1 ,D+Cโปรดทราบว่าเราจะไม่เขียนเดี่ยวที่1เราจับคู่Nจึงลดความมันลง

^1*,|;1
<empty>

ในที่สุดเราจำเป็นต้องกำจัดองค์ประกอบที่ 1 ของลำดับเช่นเดียวกับส่วนที่เหลือ;1จากNซึ่งเราก็ทำได้โดยการจับคู่อย่างใดอย่างหนึ่งและแทนที่ด้วยสตริงที่ว่างเปล่า

Python 2, 93 87 67 61 60 ไบต์

i,j,l=input()
while j/i:i,j=j-i,i
exec"i,j=j,i+j;print i;"*l

รับค่าอินพุต (เป็นรายการตัวอักษรแบบหลาม[8,10,13])

ทำงานออกเทอมที่ 0

จากนั้นพิมพ์ลำดับของการเพิ่มเติมจนกว่าจะถึงความยาว

CJam, 26 23 ไบต์

ขอบคุณเดนนิสที่ช่วยประหยัด 3 ไบต์

q~{_@\-_g)}g\@{_@+_p}*t

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

ทดสอบที่นี่

คำอธิบาย

สิ่งนี้จะไปอีกขั้นหนึ่งเมื่อค้นหาองค์ประกอบที่ 0 นั่นคือมันจะยุติลงเมื่อค่าใดค่าหนึ่งเป็นลบ

q~      e# Read and evaluate input, pushing N, B and A on the stack.
{       e# do while...
  _@\-  e#   B, A = A, B-A
  _W>   e#   Check if A is still non-negative.
}g
\@      e# Reorder N B A into A B N.
{       e# Run the following N times...
  _@+   e#   A, B = B, A+B
  _p    e#   Print B.
}*
t       e# The last A, B are still on the stack. We remove them by trying to
        e# execute a ternary operator: it pops the first two values but then
        e# terminates the program with an error, because there is no third value.

เขาวงกต , 58 54 49 46 44 ไบต์

ขอบคุณ Sp3000 สำหรับการแนะนำการใช้ค่าลบล้างระดับบิตซึ่งบันทึกสองไบต์

??#"{=
  ;  -
@"~~:}
~""
?
"}}:=
(   +
{{\!:

B A Nรูปแบบอินพุตเป็น เอาต์พุตเป็นรายการที่คั่นด้วยบรรทัดใหม่

คำอธิบาย

(ล้าสมัยเล็กน้อยแนวคิดพื้นฐานยังคงเหมือนเดิม แต่เค้าโครงของโค้ดจะแตกต่างกันในตอนนี้)

สิ่งนี้ใช้แนวคิดเดียวกันกับคำตอบ CJam ของฉัน (เครดิตยังคงไปที่เดนนิส): เมื่อย้อนรอยลำดับเราจะไม่หยุดจนกว่าเราจะได้รับค่าลบ (ซึ่งทำให้เรามีองค์ประกอบที่ 1 และ 2 ของลำดับ) จากนั้นเราจะเริ่มเพิ่มพวกเขาก่อนพิมพ์ค่าแรก

วิธีนี้ใช้เทคนิคการตีลูกกอล์ฟ Labyrinth สองครั้งที่ดี ลองดูรหัสในส่วน:

?"
}

IP เริ่ม?ไปทางขวา (ซึ่งอ่านA) บน"(a-op) มันกระทบจุดจบดังนั้นมันจึงหันกลับมาดำเนินการ?อีกครั้ง (กำลังอ่านB) สุดท้าย}ย้ายBไปที่สแต็คเสริม ปลายตายบันทึกไบต์มากกว่าไร้เดียงสา

?
?
}

ตอนนี้วนรอบซึ่งหาจุดเริ่มต้นของลำดับ:

)(:{
"  -
" "`?...
=}""

The )((increment-decrement) คือ no-op แต่จำเป็นเพื่อให้แน่ใจว่าส่วนบนสุดของสแต็กเป็นบวกที่ทางแยก (เช่นที่ IP หันไปทางตะวันออก) :ที่ซ้ำกันA, {การย้ายBกลับไปกองหลักคำนวณ- A-Bสิ่งที่เราต้องการจริงๆคือB-Aแม้ว่าดังนั้น`ปฏิเสธค่า

นี่คือสี่แยกทาง สำหรับผลลัพธ์ที่เป็นลบ IP จะเลี้ยวซ้ายไปที่การ?อ่านNและการย้ายไปยังส่วนถัดไปของโปรแกรม หากผลลัพธ์เป็นศูนย์ IP จะเคลื่อนที่ไปทางทิศใต้เลี้ยวเข้ามุมและยังคงอยู่ในลูป หากผลลัพธ์เป็นค่าบวก IP จะเลี้ยวขวา (ตะวันตก) เลี้ยวที่มุมและเลี้ยวขวาอีกครั้ง (ตะวันตกอีกครั้ง) ดังนั้นมันจะยังคงอยู่ในลูป ฉันคิดว่านี่อาจเป็นรูปแบบทั่วไปเพื่อแยกความแตกต่างจากค่าที่ไม่เป็นลบ (หรือค่าบวกจากค่าที่ไม่เป็นบวก):

                v
                "
               """>negative
non-negative <"""

อย่างน้อยฉันก็ไม่สามารถหารูปแบบกะทัดรัด / มีประโยชน์สำหรับกรณีนี้ได้

อย่างไรก็ตามในขณะที่Aไม่เป็นเชิงลบห่วงยังคง}ย้ายAไปกองเสริมและ=สัญญาแลกเปลี่ยนและAB

ครั้งหนึ่งเคยAเป็นลบ?อ่านNและเราย้ายเข้าไปในวงที่สอง:

 }:=+:
 }   !
?"({{\

เรารู้ว่าNมันเป็นบวกดังนั้นเราสามารถพึ่งพา IP ที่เลี้ยวซ้าย (ทิศเหนือ) ตอนนี้ร่างกายลูปคือ:

}}:=+:!\{{(

ในคำ: ย้ายทั้งสองNและAบนสแต็คเสริม ซ้ำBสลับสำเนาที่มีAและเพิ่มAสำเนาอื่น ๆ Bของ Bซ้ำอีกครั้งเพื่อพิมพ์ค่าปัจจุบันของ พิมพ์บรรทัดใหม่ ย้ายBและกลับไปที่กองหลักและลดลงNN

ในขณะที่Nเป็นบวก IP จะเลี้ยวขวา (ทิศเหนือ) วนรอบต่อไป เมื่อNถึงศูนย์รหัสจะสิ้นสุดในทางที่ค่อนข้างแฟนซี:

IP เคลื่อนตรงไปข้างหน้า (ตะวันตก) ความ?พยายามที่จะอ่านจำนวนเต็มอื่น แต่เราได้มาถึง EOF แล้วดังนั้นมันจึงผลักดัน0แทน `พยายามปฏิเสธสิ่งนั้น แต่ยังคงเป็นศูนย์ ดังนั้น IP ยังคงเคลื่อนที่ไปทางตะวันตกเลี้ยวเข้ามุมแล้วค่อยลงไป@ที่จุดจบของโปรแกรม

ฉันสงสัยว่าฉันสามารถวาง@ในตำแหน่งที่ถูกกว่าได้หรือไม่ (ปัจจุบันมีค่าใช้จ่าย 3 ตัวอักษรช่องว่าง) โดยการเปลี่ยนทั้งสาม"รอบให้`เป็นแบบไม่มีคอมโบ (เช่น)() แต่ฉันยังไม่สามารถทำงานนี้ได้

C, 105 102 100 ไบต์

main(a,b,n,t){for(scanf("%d%d%d",&a,&b,&n);t=b-a,t>=0;a=t)b=a;for(;n--;b=t)t=a+b,printf("%d ",a=b);}

ขอบคุณ @ C0deH4cker สำหรับการตีกอล์ฟขนาด 2 ไบต์!

ลองมันออนไลน์บนIdeone

Matlab / Octave, 115 125ไบต์

function x=f(x,n)
while x(2)>=x(1)
x=[abs(x(1)-x(2)) x];end
x=x([2 1]);for k=1:n-1
x=[x(1)+x(2) x];end
x=x(n:-1:1);

f([8 13],10)ฟังก์ชั่นที่ควรจะเรียกว่าเป็น

ตัวอย่าง (Matlab):

>> f([8 13],10)
ans =
     0     1     1     2     3     5     8    13    21    34

หรือลองออนไลน์ (คู่)

Haskell, 67 65 56 ไบต์

a#b|a>b=b:scanl(+)(a+b)(a#b)|1>0=(b-a)#a
n%a=take n.(a#)

ขอบคุณ @nimi สำหรับคำแนะนำ

สิ่งนี้นิยามฟังก์ชัน ternary infix %ซึ่งถูกเรียกใช้ในรูปแบบ(n%a)bตัวอย่างเช่น:

> (10%8)13
[0,1,1,2,3,5,8,13,21,34]

คำอธิบาย

ฟังก์ชั่นไบนารี infix ที่#กำหนดไว้ในบรรทัดแรกใช้เวลาในสองจำนวนเต็มaและbและส่งกลับลำดับเหมือนฟีโบนักชีที่ไม่มีที่สิ้นสุดaและbเกิดขึ้นเป็นองค์ประกอบที่ต่อเนื่องกัน

a#b                                       -- Define a#b:
   |a>b=                                  -- if a>b, then a#b is
        b:                                -- the sequence that starts with b and
          scanl(+)     (a#b)              -- continues with the sums of prefixes of a#b
                  (a+b)                   -- plus the additional term a+b;
                            |1>0=(b-a)#a  -- otherwise, it's (b-a)#a.

ฟังก์ชั่น%ใช้เวลาเพียงแค่ครั้งแรกองค์ประกอบของna#b

> <>, 33 31 + 1 สำหรับ -v = 32 bytes

&:{:@(?v:}-$&
-1;!?:&<$+{oan::$&

อินพุตต้องถูกพุชบนสแต็กโดยใช้ -v เนื่องจากการแยกเลขทศนิยมไม่สำคัญใน> <>

คำอธิบาย:

ฉันจะแสดงสแต็คหลังจากการดำเนินการแต่ละครั้ง (กลุ่ม) มันเริ่มต้นด้วย [F (n), F (n + 1), N]

บรรทัดแรกจะลดลงเซเรียอาถึงเทอมที่ 0:

& removes N from the stack to put it into a register. [F(n), F(n+1)]
:{:@ move the stack and duplicate items to get [F(n+1), F(n), F(n+1), F(n)]
(?v compares the two top items of the stack and branch to the second line if F(n+1) < F(n) [F(n+1), F(n)]
:} move the stack and duplicate its top to get [F(n), F(n+1), F(n)]
- substracts the two top items and put the result on top of the stack [F(n), F(n+1) - F(n)]
$ switchs the top two values of the stack. [F(n+1) - F(n), F(n)]
& retrieve the value from the register. iteration complete, since [F(n+1) - F(n), F(n), N] can also be read as [F(n-1), F(n), N]

บรรทัดที่สองจะขึ้นเซเรียอาจนกระทั่งพิมพ์คำศัพท์ N:

< changes the code pointer direction to the left [F(0), F(-1)]
& retrieves the stored value back from the stack [F(0), F(-1), N]
:?!; copies N to compare it to 0, stops if it is [F(0), F(-1), N]
1- decreases it [F(0), F(-1), N-1]
& stores it back [F(0), F(-1)]
$:: makes the stack [F(-1), F(0), F(0), F(0)]
n{ prints the top of the stack then left shifts it [F(0), F(0), F(-1)]
ao displays a line feed (ascii character 0x0a) [F(0), F(0), F(-1)]
+ adds the two top values [F(0), F(-1) + F(0)]
$ switch the two top values. iteration complete since [F(-1) + F(0), F(0)] which can be read as [F(1), F(0)]

Java, 113 78 76 ไบต์

เครดิตไปที่ ETH การผลิตสำหรับการจัดหาอัลกอริทึมที่ฉันใช้ในคำตอบนี้

(a,b,n)->{for(;a<=b;b-=a)a=b-a;for(;n-->0;b+=a,a=b-a)System.out.println(b);}

ลองที่นี่

คำอธิบาย:

(a,b,n)->{
    for (;a<=b;b=b-a)a=b-a;  //Compute previous terms while a <= b
    for (;n-->0;b=a+b,a=b-a) //Compute and print next terms while n > 0
    System.out.println(b);   //Print term
}

วิธีดั้งเดิม113 93 ไบต์

ดูเหมือนกอล์ฟมากขึ้น;)

String a(int a,int b,int n){return n<0?a+" "+a(b,a+b,n+1):n>0?a>b?a(b,a+b,-n):a(b-a,a,n):"";}

ลองที่นี่

คำอธิบาย:

String a(int a, int b, int n){
    return 
    n < 0 ?                           //If n < 0
        a + " " + a(b, a + b, n + 1)  //Return a + next terms and increment n.
    :                                 //Else
        n > 0 ?                       //If n > 0
            a > b ?                   //If a > b
                a(b, a + b, -n)       //Negate n and return terms.
            :                         //If a <= b
                a(b - a, a, n)        //Generate previous term.
        :                             //If n == 0
            ""                        //Return nothing.
    ;
}

Javascript (ES6), 83 73 63 ไบต์

This might have been golfed to the max. We'll see.

(a,b,n)=>{while(a<=b)b-=a=b-a;for(;n--;console.log(a=b-a))b+=a}

Ungolfed:

function f(a,b,n) {
  // repeat until we find the 0th item...
  while (a <= b) {  // if a = 5, b = 8:
    a = b - a;      // a = (8 - 5) = 3
    b = b - a;      // b = (8 - 3) = 5
  }
  // repeat n times...
  while (n-- > 0) { // if a = 5, b = 8:
    b += a;         // b = (8 + 5) = 13
    a = b - a;      // a = (13 - 5) = 8
    console.log(a); // print out each item
  }
}

Mathematica 112

Will golf it eventually

z[a_, b_, n_] := (
  f[0] := Min[a, b];
  f[1] := Max[a, b];
  f[x_] := f[x - 1] + f[x - 2];
  f /@ Range[n]
  )

CJam, 40 bytes

l~:A;{_@_@)<}{_@\-\}w\{A(:A0>}{_p_@+}w\;

Baby steps. This is my first CJam program ever, so I'm proud it works at all.

It takes input in the same form as in the examples.

I've now seen I could reduce it to 33 bytes using the { ... }* construct.

l~:A;{_@_@)<}{_@-z\}w\A{_p_@+}*;;

And I could even reduce it by one more by using the ternary operator to clean the stack and produce an error.

Ruby, 141 bytes

def u a,b,n,z=""
n<1 ? z.chop : u(b,a+b,n-1,z+"#{a} ")
end 
def d a,b,z=0
a.abs>b ? z : d(b-a,a,[a,b]) 
end 
def f a,b,n
x,y=d a,b 
u x,y,n
end 

Execution

f function produces the desired output, argument names match the variable names from the question

f(8,13,10) # returns => "0 1 1 2 3 5 8 13 21 34"

Nothing clever:

• u (up) function computes n elements in the fibonacci sequence starting with a,b using recursion
• d (down) function finds the 0th and 1st element given two end elements using recursion
• f (fibonacci) function puts the two together

Mathematica, 59 bytes

If[#>#2,LinearRecurrence[{1,1},#2+{0,#},#3],#0[#2-#,#,#3]]&

Ruby, 81 75 73

a,b,n=23,37,5;while(c=b-a)<a;b,a=a,c;end;p a;[*2..n].map{b=c+a;c,a=a,b;p b}

Shortened by 6 Bytes when replacing for-loop with range.map

a,b,n=23,37,5;while(c=b-a)<a;b,a=a,c;end;p a;[*2..n].map{p b=c+a;c,a=a,b}

Saved another 2 bytes by moving print statement

Pyke, 24 bytes (non-competing)

DA/IDA-],X_r)QVDsRe
R]);

Try it here!

Jelly, 14 bytes

Ḋ;_/Ɗ>/¿+⁹С/Ṗ

Try it online!

Common Lisp, 91 bytes

(lambda(a b n)(do((x a(- y x))(y b x))((> x y)(dotimes(k n)(print y)(psetf y(+ y x)x y)))))

Try it online!