Haskell có tính năng (trông giống) gọn gàng này, nơi bạn có thể cung cấp cho nó ba số và nó có thể suy ra một chuỗi số học từ chúng. Ví dụ, [1, 3..27]tương đương với [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27].

Điều đó thật tuyệt và tất cả nhưng trình tự số học khá hạn chế. Ngoài ra, pfft . Phép nhân là nơi nó ở. Sẽ không hay hơn nếu nó thực hiện các chuỗi hình học như [1, 3..27]quay trở lại [1, 3, 9, 27]?

Thử thách

Viết chương trình / hàm lấy ba số nguyên dương a , b và c và xuất ra trong đó x là số nguyên lớn nhất ≤ c có thể được biểu diễn trong đó n là số nguyên dương.[a, b, b × (b ÷ a), b × (b ÷ a)2, ..., x]b × (b ÷ a)n

Đó là, đầu ra phải là r , sao cho:

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

Thông số kỹ thuật

• Quy tắc I / O tiêu chuẩn được áp dụng .
• Sơ hở chuẩn bị cấm .
• b sẽ luôn chia hết cho a .
• a < b ≤ c
• Thách thức này không phải là tìm ra cách tiếp cận ngắn nhất trong tất cả các ngôn ngữ, mà là tìm cách tiếp cận ngắn nhất trong mỗi ngôn ngữ .
• Mã của bạn sẽ được ghi theo byte , thường là trong mã hóa UTF-8, trừ khi được quy định khác.
• Các hàm tích hợp (Mathicala có thể có một: P) tính toán chuỗi này được cho phép nhưng bao gồm một giải pháp không dựa vào tích hợp được khuyến khích.
• Giải thích, ngay cả đối với các ngôn ngữ "thực tế", được khuyến khích .

Các trường hợp thử nghiệm

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]

Trong một vài định dạng tốt hơn:

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 byte

~↑≤Ṡ¡o//

Đầu vào theo thứ tự b, c, a . Hãy thử trực tuyến!

Giải trình

~↑≤Ṡ¡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.

Luồng điều khiển trong chương trình này hơi khó theo dõi. Đầu tiên, b được đưa đến ngoài cùng bên phải /, tạo ra một hàm /bchia cho b . Tiếp theo, ~chia chương trình còn lại thành ba phần : ~(↑)(≤)(Ṡ¡o//b). Đây thức ăn c đến ≤và một để Ṡ¡o//b, và máy liên hợp kết quả với ↑. Kết quả của ≤clà một hàm kiểm tra xem đối số của nó có nhiều nhất là c hay không và ↑≤clấy tiền tố dài nhất của các phần tử mà phần tử này giữ.

Nó vẫn còn để hiển thị cách (Ṡ¡o//b)ađánh giá vào danh sách vô hạn mong muốn. Phần trong ngoặc được chia thành Ṡ(¡)(o//b). Sau đó Ṡcung cấp một đến o//b, cung cấp kết quả cho ¡, và sau đó đưa ra một đối số thứ hai của nó. Biểu thức (o//b)ađưa ra một hàm lấy một số và chia nó cho a / b và ¡lặp lại hàm này trên đối số thứ hai của nó, đó là a .

Dưới đây là một loạt các biến đổi trực quan hóa lời giải thích:

  (~↑≤Ṡ¡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)

Giải pháp thay thế sử dụng các biến rõ ràng theo thứ tự a, b, c :

↑≤⁰¡*/⁵²

Python 2 , 42 byte

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

Hãy thử trực tuyến!

Phương pháp đệ quy, 42 41 byte

^{-1 byte nhờ vào lò nướng}

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

Hãy thử trực tuyến!

Proton , 35 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 41 37 byte

Đã lưu 4 byte nhờ @Neil

Đưa đầu vào là (b,c)(a).

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

Các trường hợp thử nghiệm

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ình luận

(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 byte

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 22 byte

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

Hãy thử trực tuyến!

Python 3, 93 90 74 73 byte

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])

Dùng thử trực tuyến

Cảm ơn Rod và user202729 đã giúp tôi giảm khá nhiều byte!

Octave , 38 35 byte

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

Hãy thử trực tuyến!

Hóa ra cách tiếp cận MATL của @ LuisMendo cũng tiết kiệm 3 byte trong Octave, mặc dù lặp lại logba lần.

Perl 6 , 26 24 byte

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

Hãy thử trực tuyến!

Toán tử trình tự của Perl 6 ...có thể suy ra chuỗi hình học nguyên bản.

Cập nhật: ... Có thể , nhưng trong tình huống này không suy ra thì nó ngắn hơn một chút.

05AB1E , 12 byte

Nhập theo thứ tự c,b,a

ÝmI¹Ý<m/ʒ¹›_

Hãy thử trực tuyến!

Giải trình

Ý              # 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 byte

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

Hãy thử trực tuyến!

Chỉ để có được quả bóng lăn trong MATL. Tôi không thể tưởng tượng rằng không có cách nào ít giải quyết vấn đề này.

Haskell, 35 byte

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

Hãy thử trực tuyến!

MATL , 12 byte

y/ivZlZ}3$:W

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

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 byte

Bao gồm +3cho -n( use 5.10.0để mở khóa các tính năng perl 5.10 là miễn phí)

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

Sau đó chạy như:

geosequence.pl <<< "1 3 26"

Đỏ , 50 byte

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

Hãy thử trực tuyến!

Japt , 14 byte

ÆWpX zVpXÉÃf§U

Thử nó

Giải trình

                    :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

Sạch sẽ , 63 byte

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

Hãy thử trực tuyến!

TI-BASIC, 31 byte

Lấy đầu vào từ người dùng và đầu ra trong Ans. Tôi đã giải cho n trong c = b ⁿ / a ^n-1 , nhận n = 1 + ln (c / b) / ln (b / a). Điều đó giống như n = 1 + log _{b / a} (c / b). Với mục đích chơi gôn, tôi bắt đầu trình tự của mình ở -1 và kết thúc ở n-1 thay vì 0 đến n.

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

APL (Dyalog Unicode) , 38 byte

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

Hãy thử trực tuyến!

Tiền tố Dfn. Đưa đầu vào theo thứ tự a b cvà sử dụng ⎕IO←0( I ndex O rigin)

Cảm ơn @ErikTheOutgolfer đã cạo 6 byte khỏi điều này trước khi tôi đăng nó.

Làm sao?

{(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 byte ^CP437

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

16 byte khi giải nén,

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

Chạy và gỡ lỗi trực tuyến!

Đưa đầu vào ở dạng [b, a, c].

Khá chắc chắn @recursive có giải pháp tốt hơn.

Giải trình

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 byte

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

Hãy thử trực tuyến!

Chúng tôi đọc ba số. Tính tỷ lệ chung theo số thứ hai / số thứ nhất. Sau đó, chúng tôi chạy qua chuỗi cho đến khi chúng tôi lớn hơn giới hạn trên.

C (gcc), 82 byte

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);}

Hãy thử trực tuyến!

Tính toán và in r_n = b^n/a^(n-1)cho đến khi r_n > c.

Phải được biên dịch với -lm!

APL (Dyalog) , 23 byte ( SBCS )

Điều này có các đối số ab ở bên trái và c ở bên phải,

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

Hãy thử trực tuyến!

Có khả năng là một cách ngắn hơn, nhưng tôi nghĩ rằng ÷\ là dễ thương.

Giải thích:

{...}Hàm anonomous là a b, ⍵là c. Hãy cùng nói nàoa b c = 2 6 100

⌽⍺Đảo ngược ⍺:6 2

⍵⍴Lặp lại ⍵thời gian:6 2 6 2 6 2 6 2 ...

÷\ Giảm bằng cách chia trên các tiền tố: 6 (6÷2) (6÷(2÷6)) (6÷(2÷(6÷2))).. = 6 3 18 9 54 ..

⍺,Chuẩn bị ⍺:2 6 6 3 18 9 54 27 162 81 ...

⊣/⍵2⍴ Nhận mọi yếu tố khác (cộng với một số lần lặp lại):

  ⍵2⍴Tạo một ⍵hàng, 2ma trận cột từ2 6 6 3 18 9 54 ...

  ⊣/ Lấy cột đầu tiên

⊆⊢ Chia mảng thành các khối trong đó

⍵∘≥ ⍵ lớn hơn hoặc bằng tất cả các yếu tố

⊃ Lấy khối đầu tiên như vậy