Haskellมีคุณสมบัติที่ประณีต (- มอง) ซึ่งคุณสามารถให้ตัวเลขสามตัวและสามารถอนุมานลำดับเลขคณิตจากพวกเขา ยกตัวอย่างเช่นเทียบเท่ากับ[1, 3..27][1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27]

มันยอดเยี่ยมและทั้งหมดยกเว้นลำดับเลขคณิตค่อนข้าง จำกัด นอกจากนี้pfft การคูณของมันอยู่ที่ไหน มันจะไม่เย็นถ้ามันไม่ได้ลำดับเรขาคณิตเช่น[1, 3..27]กลับมา[1, 3, 9, 27]?

ท้าทาย

เขียนโปรแกรม / ฟังก์ชั่นที่ใช้เวลาสามจำนวนเต็มบวก, ขและคและผลที่xเป็นจำนวนเต็มยิ่งใหญ่ที่สุด≤ คที่สามารถแสดงเป็นที่nเป็นจำนวนเต็มบวก[a, b, b × (b ÷ a), b × (b ÷ a)2, ..., x]b × (b ÷ a)n

นั่นคือเอาต์พุตควรเป็นrเช่นนั้น:

r0 = a
r1 = b
rn = b × (b ÷ a)n-1
rlast = greatest integer ≤ c that can be represented as b × (b ÷ a)n
         where n is a positive integer

ข้อมูลจำเพาะ

• กฎระเบียบมาตรฐาน I / O ใช้
• ช่องโหว่มาตรฐานจะต้องห้าม
• ขมักจะหารด้วย
• a < b ≤ c
• ความท้าทายนี้ไม่ได้เกี่ยวกับการหาวิธีการที่สั้นที่สุดในทุกภาษาค่อนข้างมันเป็นเรื่องเกี่ยวกับการหาวิธีการที่สั้นที่สุดในแต่ละภาษา
• รหัสของคุณจะได้รับคะแนนเป็นไบต์มักจะอยู่ในการเข้ารหัส UTF-8 เว้นแต่จะระบุไว้เป็นอย่างอื่น
• ฟังก์ชั่นในตัว (Mathematica อาจมีหนึ่ง: P) ที่คำนวณลำดับนี้ได้รับอนุญาตแต่รวมถึงการแก้ปัญหาที่ไม่ต้องพึ่งพาบิวด์อิน
• คำอธิบายแม้สำหรับภาษา "ปฏิบัติ" จะได้รับการสนับสนุน

กรณีทดสอบ

a   b   c     r

1   2   11    [1, 2, 4, 8]
2   6   100   [2, 6, 18, 54]
3   12  57    [3, 12, 48]
4   20  253   [4, 20, 100]
5   25  625   [5, 25, 125, 625]
6   42  42    [6, 42]

ในรูปแบบที่ดีขึ้นไม่กี่:

1 2 11
2 6 100
3 12 57
4 20 253
5 25 625
6 42 42

1, 2, 11
2, 6, 100
3, 12, 57
4, 20, 253
5, 25, 625
6, 42, 42

Husk , 8 ไบต์

~↑≤Ṡ¡o//

การป้อนข้อมูลที่อยู่ในลำดับB, C เป็น ลองออนไลน์!

คำอธิบาย

~↑≤Ṡ¡o//  Implicit inputs.
       /  a/b as exact rational number.
     o/   Divide by a/b (so multiply by b/a).
    ¡     Iterate that function
   Ṡ      on a. Result is the infinite list [a, b, b^2/a, b^3/a^2, ..
 ↑        Take elements from it while
~ ≤       they are at most c.

โฟลว์ควบคุมในโปรแกรมนี้ยากที่จะติดตาม ครั้งแรกที่ขจะถูกป้อนเข้าขวาสุด/ผลิตฟังก์ชั่น/bที่แบ่งโดยข ถัดไป~แยกโปรแกรมที่เหลือออกเป็นสามส่วน: ~(↑)(≤)(Ṡ¡o//b). ฟีดนี้คไป≤และไปและรวมผลกับ ผลลัพธ์ของการเป็นฟังก์ชั่นที่ตรวจสอบว่าอาร์กิวเมนต์ของมันเป็นอย่างมากṠ¡o//b↑≤cคและ↑≤cใช้คำนำหน้ายาวที่สุดขององค์ประกอบที่นี้ถือ

มันยังคงแสดงให้เห็นว่า(Ṡ¡o//b)aประเมินไปยังรายการที่ไม่มีที่สิ้นสุดที่ต้องการได้อย่างไร Ṡ(¡)(o//b)ส่วนในวงเล็บคือแยกออกเป็น แล้วṠฟีดจะฟีดผลให้แล้วให้อาร์กิวเมนต์ที่สอง การแสดงออกให้ฟังก์ชั่นที่ใช้จำนวนและแบ่งมันโดยA / Bและiterates ฟังก์ชั่นนี้ในอาร์กิวเมนต์ที่สองซึ่งเป็นo//b¡(o//b)a¡

นี่คือชุดของการเปลี่ยนแปลงที่เห็นภาพคำอธิบาย:

  (~↑≤Ṡ¡o//) b c a
= (~↑≤Ṡ¡o/(/b)) c a
= ~(↑)(≤)(Ṡ¡o/(/b)) c a
= ↑(≤c)((Ṡ¡o/(/b)) a)
= ↑(≤c)(Ṡ(¡)(o/(/b)) a)
= ↑(≤c)(¡(o/(/b)a) a)
= ↑(≤c)(¡(/(/ba))a)
Last line in English: takeWhile (atMost c) (iterate (divideBy (divideBy b a)) a)

โซลูชันทางเลือกโดยใช้ตัวแปรที่ชัดเจนตามลำดับa, b, c :

↑≤⁰¡*/⁵²

Python 2 , 42 ไบต์

a,b,c=input()
x=b/a
while c/a:print a;a*=x

ลองออนไลน์!

วิธีแบบเรียกซ้ำ42 41 ไบต์

^{-1 ไบต์ขอบคุณ ovs}

f=lambda a,b,c:c/a*[a]and[a]+f(b,b*b/a,c)

ลองออนไลน์!

โปรตอน 35 ไบต์

f=(a,b,c)=>c//a?[a]+f(b,b*b/a,c):[]

ลองออนไลน์!

JavaScript (ES6), 41 37 ไบต์

บันทึกแล้ว 4 ไบต์ขอบคุณ @Neil

(b,c)(a)จะเข้าเป็น

(b,c)=>g=a=>a>c?[]:[a,...g(b,b*=b/a)]

กรณีทดสอบ

let f =

(b,c)=>g=a=>a>c?[]:[a,...g(b,b*=b/a)]

console.log(JSON.stringify(f(2,11)(1)))
console.log(JSON.stringify(f(6,100)(2)))
console.log(JSON.stringify(f(12,57)(3)))
console.log(JSON.stringify(f(20,253)(4)))
console.log(JSON.stringify(f(42,42)(6)))

แสดงความคิดเห็น

(b, c) =>                 // main function taking b and c
  g = a =>                // g = recursive function taking a
    a > c ?               //   if a is greater than c:
      []                  //     stop recursion and return an empty array
    :                     //   else:
      [ a,                //     return an array consisting of a, followed by 
        ...g(             //     the expanded result of a recursive call to g()
          b,              //       with a = b
          b *= b / a      //       and b = b * ratio
        ) ]               //     end of recursive call

Pari / GP , 38 ไบต์

f(a,b,c)=powers(b/a,logint(c\a,b/a),a)

ลองออนไลน์!

ภาษา Wolfram (Mathematica)ขนาด 22 ไบต์

PowerRange[#,#3,#2/#]&

ลองออนไลน์!

Python 3, 93 90 74 73 ไบต์

x=lambda a,b,c,i=0,q=[]:a*(b/a)**i>c and q or x(a,b,c,i+1,q+[a*(b/a)**i])

ลองใช้ออนไลน์

ขอบคุณRodและuser202729 ที่ช่วยฉันลดขนาดไบต์ลงได้บ้าง!

อ็อกเทฟ38 38ไบต์

@(a,b,c)exp(log(a):log(b/a):log(c))

ลองออนไลน์!

กลับกลายเป็นว่าวิธีการ MATL @ @ LuisMendo ยังประหยัด 3 ไบต์ใน Octave แม้จะทำซ้ำlogสามครั้ง

Perl 6 , 26 24 ไบต์

{$^a,$^b,$b²/$a...^*>$^c}
{$^a,*×$^b/$a...^*>$^c}

ลองออนไลน์!

ผู้ประกอบการลำดับ Perl 6 ของ ...สามารถอนุมานได้ว่าเป็นชุดเรขาคณิต

อัปเดต: ... สามารถทำได้แต่ในสถานการณ์นี้ไม่ได้อนุมานว่ามันสั้นกว่าเล็กน้อย

05AB1E , 12 ไบต์

ป้อนข้อมูลในการสั่งซื้อ c,b,a

ÝmI¹Ý<m/ʒ¹›_

ลองออนไลน์!

คำอธิบาย

Ý              # push the range [0 ... c]
 m             # raise b to the power of each
  I            # push a
   ¹Ý          # push the range [0 ... c]
     <         # decrement each
      m        # push a to the power of each
       /       # elementwise division of ranges
        ʒ      # filter, keep only elements that are
         ¹›_   # not greater than c

MATL , 17 ไบต์

t:,qtiw^w]x/tb>~)

ลองออนไลน์!

เพียงเพื่อให้ลูกบอลกลิ้งใน MATL ฉันไม่สามารถจินตนาการได้ว่าจะมีวิธีแก้ปัญหานี้น้อยลง

Haskell, 35 ไบต์

(a#b)c|a>c=[]|d<-div b a*b=a:(b#d)c

ลองออนไลน์!

MATLขนาด 12 ไบต์

y/ivZlZ}3$:W

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

y     % Implicitly take two inputs, and duplicate the first onto the top
/     % Divide
i     % Take third input
v     % Vertically concatenate the three numbers into a column vector
Zl    % Binary logarithm, element-wise
Z}    % Split the vector into its three components
3$:   % Three-input range. Arguments are start, step, upper limit
W     % 2 raised to that, element-wise. Implicit display

Perl, 38 ไบต์

รวม+3สำหรับ-n( use 5.10.0เพื่อปลดล็อคคุณลักษณะ perl 5.10 ฟรี)

#!/usr/bin/perl -n
use 5.10.0;
/ \d+/;say,$_*=$&/$`until($_+=0)>$'

จากนั้นเรียกใช้เป็น:

geosequence.pl <<< "1 3 26"

สีแดง 50 ไบต์

g: func[a b c][if a <= c[print a g b b * b / a c]]

ลองออนไลน์!

Japt , 14 ไบต์

ÆWpX zVpXÉÃf§U

ลองมัน

คำอธิบาย

                    :Implicit input of integers U=c, V=a & W=b
Æ         Ã         :Range [0,U) and pass each X through a function
 WpX                :  W to the power of X
     z              :  Floor divide by
      VpXÉ          :  V to the power of X-1
           f§U      :Filter elements less than or equal to U

ทำความสะอาด , 63 ไบต์

import StdEnv
$a b c=takeWhile((>=)c)[a:map(\n=b*b^n/a^n)[0..]]

ลองออนไลน์!

TI-BASIC, 31 ไบต์

Ansนำข้อมูลจากผู้ใช้และผลใน ฉันแก้หา n ใน c = b ⁿ / a ^n-1 , รับ n = 1 + ln (c / b) / ln (b / a) มันเหมือนกับ n = 1 + log _{b / a} (c / b) สำหรับจุดประสงค์ของการเล่นกอล์ฟฉันเริ่มต้นลำดับที่ -1 และจบที่ n-1 แทนที่จะเป็น 0 ถึง n

Prompt A,B,C
seq(B(B/A)^N,N,-1,logBASE(C/B,B/A

APL (Dyalog Unicode) , 38 ไบต์

{(g≤⊃⌽⍵)⊆g←f,(⍵[1]*p+1)÷(f←⊃⍵)*p←⍳⊃⌽⍵}

ลองออนไลน์!

คำนำหน้า Dfn รับอินพุตตามลำดับa b cและใช้⎕IO←0( I ndex O rigin)

ขอบคุณ @ErikTheOutgolfer สำหรับการโกน 6 ไบต์จากนี้ก่อนที่ฉันจะโพสต์

อย่างไร?

{(g≤⊃⌽⍵)⊆g←f,(⍵[1]*p+1)÷(f←⊃⍵)*p←⍳⊃⌽⍵} ⍝ Prefix Dfn. Input ⍵ is a vector
                                    ⌽⍵  ⍝ Reverse ⍵. Yields c b a
                                   ⊃    ⍝ Pick the first element (c)
                                  ⍳     ⍝ Index. Yields the integers 0..c-1
                                p←      ⍝ Assign to the variable p
                               *        ⍝ Exponentiate
                         (f←⊃⍵)         ⍝ Pick the first element of ⍵ (a) and assign to f
                                        ⍝ This yields the vector (a^0, a^1, ..., a^c-1)
                        ÷               ⍝ Element-wise division
                    p+1)                ⍝ The vector 1..c
                   *                    ⍝ Exponentiate
              (⍵[1]                     ⍝ Second element (because of ⎕IO←0) of ⍵ (b)
                                        ⍝ This yields the vector (b^1, b^2, ..., b^c)
            f,                          ⍝ Prepend f (a). This yields the vector 
                                        ⍝ (a, b^1/a^0, b^2/a^1, ...)
          g←                            ⍝ Assign the vector to g
         ⊆                              ⍝ Partition. This takes a boolean vector as left
                                        ⍝ argument and drops falsy elements of the right argument.
     ⊃⌽⍵)                               ⍝ Pick the last element of ⍵ (c)
  (g≤                                   ⍝ Check if each element of g≤c. Yields the boolean
                                        ⍝ vector that is the left argument for ⊆

Stax , 14 ไบต์^CP437

ü╞¥ß¥║/,5å╘⌂åº

16 ไบต์เมื่อคลายการแพค

E~Y/y{;^<}{[*gfm

เรียกใช้และแก้ไขข้อบกพร่องออนไลน์!

[b, a, c]จะเข้าในรูปแบบของ

ค่อนข้างแน่ใจว่า @recursive มีวิธีแก้ปัญหาที่ดีกว่า

คำอธิบาย

E~                              Parse  input, put `c` on input stack
  Y/                            Store `a` in register `y` and calculate `b`/`a`
    y                           Put `y` back to main stack, stack now (from top to bottom): [`a`, `b`/`a`]
     {   }{  gf                 generator
      ;^<                       Condition: if the generated number is smaller than the top of input stack (i.e. `c`)
           [*                   duplicate the second item in main stack and multiply it with the item at the top
                                   i.e. multiply last generated value by `b/a` and generate the value
              m                 Output array, one element on each line

SILOSขนาด 73 ไบต์

readIO
k=i
readIO
j=i
readIO
r=j/k
a=k
lbla
printInt a
a*r
b=i-a+1
if b a

ลองออนไลน์!

เราอ่านตัวเลขสามตัว คำนวณอัตราส่วนทั่วไปตามจำนวนที่สอง / หนึ่งแรก จากนั้นเราก็วิ่งไปตามลำดับจนกว่าเราจะมีค่ามากกว่าขอบเขตบน

C (gcc), 82 ไบต์

n;f(a,b,c){float r=0;for(n=0;r<=c;)(r=pow(b,n)/pow(a,n++-1))<=c&&printf("%f ",r);}

ลองออนไลน์!

คำนวณและพิมพ์r_n = b^n/a^(n-1)จนกระทั่งr_n > cจนกว่า

จะต้องรวบรวมด้วย-lm!

APL (Dyalog) 23 ไบต์ ( SBCS )

อาร์กิวเมนต์นี้ใช้อาร์กิวเมนต์abทางซ้ายและcทางด้านขวา

{⊃(⍵∘≥⊆⊢)⊣/⍵2⍴⍺,÷\⍵⍴⌽⍺}

ลองออนไลน์!

อาจเป็นวิธีที่สั้นกว่า แต่ฉันคิดว่า÷\น่ารัก

อธิบาย:

{...}Anonomous ฟังก์ชั่นเป็น⍺ a b, ⍵ถูกcถูกมาพูดกันa b c = 2 6 100

⌽⍺ ย้อนกลับ ⍺ :6 2

⍵⍴ ทำซ้ำ ⍵ครั้ง:6 2 6 2 6 2 6 2 ...

÷\ ลดการแบ่งตามคำนำหน้า: 6 (6÷2) (6÷(2÷6)) (6÷(2÷(6÷2))).. = 6 3 18 9 54 ..

⍺, ย่อหน้า ⍺ :2 6 6 3 18 9 54 27 162 81 ...

⊣/⍵2⍴ รับองค์ประกอบอื่น ๆ (รวมถึงการทำซ้ำต่อท้ายบางส่วน):

  ⍵2⍴ทำ⍵แถว2เมทริกซ์คอลัมน์จาก2 6 6 3 18 9 54 ...

  ⊣/ รับคอลัมน์แรก

⊆⊢ แบ่งอาร์เรย์ออกเป็นบล็อกที่

⍵∘≥ ⍵ มากกว่าหรือเท่ากับองค์ประกอบทั้งหมด

⊃ ใช้เวลาบล็อกแรกดังกล่าว