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

挑战

写一个程序/功能带有三个正整数一个，b，和c ^和输出，其中X是的最大整数≤ Ç其可以被表示为其中Ñ是一个正整数。[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规则。
• 标准的漏洞被禁止。
• b将永远是整除一个。
• 一个 < b ≤ Ç
• 挑战并不是要找到所有语言中最短的方法，而是要找到每种语言中最短的方法。
• 除非另有说明，否则您的代码将以字节计分，通常采用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

外壳，8字节

~↑≤Ṡ¡o//

输入顺序为b，c，a。 在线尝试！

说明

~↑≤Ṡ¡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被馈送到最右边/，产生一个/b除以b的函数。接下来，~将剩余程序分为三个部分：~(↑)(≤)(Ṡ¡o//b)。这种饲料Ç到≤和一对Ṡ¡o//b，并结合的结果↑。的结果≤c是一个函数，该函数检查其参数是否最多为c，并↑≤c采用其持有的元素的最长前缀。

它仍然显示如何(Ṡ¡o//b)a评估所需的无限列表。括号中的部分分为Ṡ(¡)(o//b)。然后Ṡ将a馈入o//b，将结果馈入¡，然后将其第二个参数提供给a。该表达式(o//b)a给出一个函数，该函数接受一个数字并将其除以a / 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字节

@Neil节省了4个字节

将输入作为(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 35字节

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

在线尝试！

事实证明，尽管重复log了三遍，@ LuisMendo的MATL方法也以八度保存了3个字节。

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。我在c = b ⁿ / a ^n-1中求解n ，得到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⍴⍺,÷\⍵⍴⌽⍺}

在线尝试！

可能有一种更短的方法，但我认为那÷\很可爱。

解释：

{...}匿名函数⍺is a b，⍵is 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 ...

  ⊣/ 获取第一列

⊆⊢ 将数组拆分为块

⍵∘≥ ⍵ 大于或等于所有元素

⊃ 采取第一个这样的块