Haskell 은이 깔끔한 (-looking) 기능을 제공하여 세 개의 숫자를 제공 할 수 있으며 그로부터 산술 시퀀스를 유추 할 수 있습니다. 예를 [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는 가장 큰 정수이다 ≤ C 로 표현 될 수있다 여기서, n은 양의 정수이다.[a, b, b × (b ÷ a), b × (b ÷ a)², ..., x]b × (b ÷ a)ⁿ

즉, 출력은 r 이어야 합니다.

r₀ = a
r₁ = b
r_n = b × (b ÷ a)^n-1
r_last = greatest integer ≤ c that can be represented as b × (b ÷ a)ⁿ
         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]

몇 가지 더 나은 형식으로 :

— 완전히 인간적인
소스

@ Adám No. (첫 번째 테스트 사례 참조)

— user202729

1

수식은 단순히 b ^ n / a ^ n-1 입니다. n = 0

— H.PWiz

2

물론 Mathematica에는 빌트인 기능이 있습니다.

— Neil

부동 소수점 오류로 인해 결과가 정확히 정수가 아닌 경우 허용됩니까?

— Luis Mendo

@LuisMendo 예.

— 완전히 인간적인

6

껍질 , 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를 생성합니다 . 다음으로 나머지 프로그램을 세 부분으로 나눕니다 . 이 피드 C 에 와 에 , 및 콤바인과 결과 . 결과는 그 인수 이하인 경우 체크 함수 C , 및 이 보유하고있는 요소의 최장 프리픽스 걸린다.~~(↑)(≤)(Ṡ¡o//b)≤Ṡ¡o//b↑≤c↑≤c

(Ṡ¡o//b)a원하는 무한 목록으로 평가 하는 방법을 보여줍니다 . 괄호 안의 부분은로 나뉩니다 Ṡ(¡)(o//b). 이어서 Ṡ피드 에 , 그 결과를 공급 하고 제공 를 두번째 인수. 이 표현식 은 숫자를 받아서 a / b로 나누는 함수를 제공하고 두 번째 인수 ( a ) 에서이 함수를 반복 합니다 .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 순서 로 명시 적 변수를 사용하는 대체 솔루션 :

↑≤⁰¡*/⁵²

— 자브
소스

5

파이썬 2 , 42 바이트

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

온라인으로 사용해보십시오!

재귀 적 접근, 42 41 바이트

^{ovs 덕분에 -1 바이트}

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

온라인으로 사용해보십시오!

— 막대
소스

4

양성자 , 35 바이트

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

온라인으로 사용해보십시오!

— 미스터 Xcoder
소스

1

사람들은 실제로이 언어를 기억합니까? : D

— HyperNeutrino

1

@HyperNeutrino 나는 그것을 적극적으로 사용 합니다 :)

— Mr. Xcoder

3

나는 아마 어떤 대답도받지 못할 것이란 것을 알고 있지만 왜 공감대를 선택해야합니까?

— Mr. Xcoder

3

자바 스크립트 (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

— 아르나 울드
소스

1

논쟁을 다시 정리하면 나에게 도움이된다 (b,c)=>g=a=>a>c?[]:[a,...g(b,b*=b/a)].

— Neil

3

Pari / GP , 38 바이트

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

온라인으로 사용해보십시오!

— 알레프 알파
소스

2

Wolfram Language (Mathematica) , 22 바이트

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

온라인으로 사용해보십시오!

— 알레프 알파
소스

2

파이썬 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 에게 감사드립니다 !

— 매니쉬 쿤두
소스

1

def + return -> lambda. 파이썬 팁.

— user202729

1

또한 할 수 있습니다 import*.

— user202729

1

당신은 while i<=c:i++(목록 이해 + 로그 대신)를 사용하여 많은 바이트를 절약 할 수 있습니다

— Rod

@Rod 로그없이 while 루프를 어떻게 사용해야합니까? idk 얼마나 오래 반복

— Manish Kundu

1

바이트 -1 .

— user202729

2

옥타브 , 38 35 바이트

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

온라인으로 사용해보십시오!

@LuisMendo의 MATL 접근 방식은 log세 번 반복되었지만 옥타브에서 3 바이트를 절약 합니다.

— 상치
소스

2

펄 6 , 26 24 바이트

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

온라인으로 사용해보십시오!

Perl 6의 시퀀스 연산자 ...는 기본적으로 기하학적 시리즈를 유추 할 수 있습니다.

업데이트 : ... 가능 하지만이 상황에서는 추론하지 않습니다.

— 션
소스

1

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

— 에미 냐
소스

1

MATL , 17 바이트

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

온라인으로 사용해보십시오!

MATL에서 볼을 굴리기 만하면됩니다. 나는 이것을 해결하는 덜 장황한 방법이 없다고 상상할 수 없다.

— 상치
소스

1

... 삼중 부정하지 마십시오.

— user202729

2

@ user202729 나는 당신이 사고가 아니라는 것을 어떻게 얻지 못했는지

— 안다

"의도하지 않은 일을 어떻게 얻지 못했는지

— 모르겠다

@HyperNeutrino No.

— Sanchises

공을 계속 굴려 라

— Luis Mendo 22:57에

1

하스켈, 35 바이트

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

온라인으로 사용해보십시오!

— 니미
소스

1

34 바이트 . (더 많은 "도전의 정신으로", 끔찍한 부동 소수점 오류)

— user202729

@ user202729 : (바이트를 저장하지 않고 : 별도의 대답으로 게시하시기 바랍니다 exp<$>[...])

— nimi

1

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

— 루이스 멘도
소스

1

정말 좋습니다. 내가 재사용과 고투 a하고 c(I로 시작하는 많은 실패한 시도가 y/i),하지만이 방법을 사용하면 깔끔하게 모든 것을 함께 유지한다.

— Sanchises

1

이 방법은 실제로 Octave에서 3 바이트 더 짧았습니다.

— Sanchises

0

펄, 38 바이트

포함 +3에 대한 -n합니다 (이 use 5.10.0펄에게 5.10 기능의 잠금을 해제하는 것은 무료입니다)

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

그런 다음 다음과 같이 실행하십시오.

geosequence.pl <<< "1 3 26"

— 톤호 스펠
소스

0

빨강 , 50 바이트

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

온라인으로 사용해보십시오!

— 갈렌 이바노프
소스

0

apt , 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

— 얽히고 설킨
소스

0

클린 , 63 바이트

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

온라인으로 사용해보십시오!

— 뇨
소스

0

TI-BASIC, 31 바이트

사용자의 입력을 받아서에 출력 Ans합니다. 나는 n = 1 + ln (c / b) / ln (b / a)를 얻는 c = b ⁿ / a ^n-1 에서 n을 해결했습니다 . 그것은 n = 1 + log _{b / a} (c / b)와 같습니다. 골프 목적으로, 나는 시퀀스를 -1에서 시작하여 0에서 n이 아닌 n-1에서 끝냅니다.

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

— 카 모로소 94
소스

0

APL (Dyalog Unicode) , 38 바이트

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

온라인으로 사용해보십시오!

접두사 Dfn. 순서대로의 입력을 받아 a b c, 및 용법 ⎕IO←0( I ndex O rigin)

게시하기 전에 6 바이트를 면도 해주신 @ErikTheOutgolfer에게 감사드립니다.

어떻게?

{(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 ⊆

— 살레
소스

0

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

— 웨이 준 저우
소스

0

실 로스 , 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

온라인으로 사용해보십시오!

우리는 세 개의 숫자를 읽습니다. 두 번째 숫자 / 첫 번째 숫자로 공통 비율을 계산하십시오. 그런 다음 상한보다 클 때까지 시리즈를 실행합니다.

— 로한 j 준 왈라
소스

0

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! 로 컴파일해야합니다

— 바츠
소스

69 바이트n;f(a,b,c){for(float r=n=0;r=pow(b/a,n++)*a,r<=c&&printf("%f ",r););}

— ceilingcat

0

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 ...

⊣/ 첫 번째 열을 가져옵니다

⊆⊢ 배열을 블록으로 분할

⍵∘≥ ⍵ 모든 원소보다 크거나 같다

⊃ 첫 번째 블록을 가져 가라.

— H.PWiz
소스

기하학적 시퀀스 추론

도전

명세서

테스트 사례

껍질 , 8 바이트

설명

파이썬 2 , 42 바이트

재귀 적 접근, 42 41 바이트

양성자 , 35 바이트

자바 스크립트 (ES6), 41 37 바이트

테스트 사례

댓글

Pari / GP , 38 바이트

Wolfram Language (Mathematica) , 22 바이트

파이썬 3, 93 90 74 73 바이트

옥타브 , 38 35 바이트

펄 6 , 26 24 바이트

05AB1E , 12 바이트

MATL , 17 바이트

하스켈, 35 바이트

MATL , 12 바이트

설명

펄, 38 바이트

빨강 , 50 바이트

apt , 14 바이트

설명

클린 , 63 바이트

TI-BASIC, 31 바이트

APL (Dyalog Unicode) , 38 바이트

어떻게?

Stax , 14 바이트 ^CP437

설명

실 로스 , 73 바이트

C (gcc), 82 바이트

APL (Dyalog) , 23 바이트 ( SBCS )

설명 :

기하학적 시퀀스 추론

도전

명세서

테스트 사례

껍질 , 8 바이트

설명

파이썬 2 , 42 바이트

재귀 적 접근, 42 41 바이트

양성자 , 35 바이트

자바 스크립트 (ES6), 41 37 바이트

테스트 사례

댓글

Pari / GP , 38 바이트

Wolfram Language (Mathematica) , 22 바이트

파이썬 3, 93 90 74 73 바이트

옥타브 , 38 35 바이트

펄 6 , 26 24 바이트

05AB1E , 12 바이트

MATL , 17 바이트

하스켈, 35 바이트

MATL , 12 바이트

설명

펄, 38 바이트

빨강 , 50 바이트

apt , 14 바이트

설명

클린 , 63 바이트

TI-BASIC, 31 바이트

APL (Dyalog Unicode) , 38 바이트

어떻게?

Stax , 14 바이트 CP437

설명

실 로스 , 73 바이트

C (gcc), 82 바이트

APL (Dyalog) , 23 바이트 ( SBCS )

설명 :

Stax , 14 바이트 ^CP437