जियोमेट्रिक क्रम का आविष्कार करें

18

हास्केल में यह साफ-सुथरा (क्लोकिंग) सुविधा है जहां आप इसे तीन नंबर दे सकते हैं और यह उनमें से एक अंकगणितीय अनुक्रम का अनुमान लगा सकता है। उदाहरण के लिए, [1, 3..27]के बराबर है [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27]।

यह अच्छा है और सभी लेकिन अंकगणितीय क्रम काफी सीमित हैं। जोड़, कश । गुणा कहां पर है। यह कूलर नहीं होगा अगर ऐसा ज्यामितीय दृश्यों किया [1, 3..27]लौटने [1, 3, 9, 27]?

चुनौती

एक प्रोग्राम / फ़ंक्शन लिखें जो तीन सकारात्मक पूर्णांकों को लेता है a , b , और c और आउटपुट जहां x सबसे बड़ा पूर्णांक है c जिसे एक पूर्णांक के रूप में 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 नियम लागू होते हैं ।
  • मानक खामियों को मना किया जाता है ।
  • ख हमेशा से विभाज्य हो जाएगा एक ।
  • एक < b ≤ ग
  • यह चुनौती सभी भाषाओं में सबसे छोटा दृष्टिकोण खोजने के बारे में नहीं है, बल्कि, यह प्रत्येक भाषा में सबसे छोटा दृष्टिकोण खोजने के बारे में है ।
  • आपका कोड बाइट्स में स्कोर किया जाएगा , आमतौर पर एन्कोडिंग UTF-8 में, जब तक कि अन्यथा निर्दिष्ट न हो।
  • अंतर्निहित कार्य (गणितज्ञ में एक: 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
code-golf  math  number  sequence 
— totallyhuman
स्रोत
@ Adám No. (पहला परीक्षण मामला देखें)
— user202729
1
ध्यान दें कि सूत्र बस b ^ n / a ^ n-1 है । N = 0
— H.PWiz
2
बेशक मैथेमेटिका में एक अंतर्निहित ...
— नील
क्या यह स्वीकार्य है यदि परिणाम फ़्लोटिंग पॉइंट त्रुटियों के कारण बिल्कुल पूर्णांक नहीं हैं?
— लुइस मेंडो
@LuisMendo हाँ।
— 22

जवाबों:

6

भूसी , 8 बाइट्स

~↑≤Ṡ¡o//

इनपुट ऑर्डर बी, सी, ए में है । इसे ऑनलाइन आज़माएं!

व्याख्या

~↑≤Ṡ¡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)। फिर Ṡफ़ीड एक करने के लिए o//b, करने के लिए परिणाम खिलाती ¡है, और फिर देता है एक अपने दूसरे तर्क के लिए। अभिव्यक्ति (o//b)aएक फ़ंक्शन देती है जो एक संख्या लेती है और इसे a / b से विभाजित करती है , और ¡इस फ़ंक्शन को इसके दूसरे तर्क पर प्रसारित करती है, जो कि है ।

यहाँ परिवर्तनों की एक श्रृंखला है जो स्पष्टीकरण की कल्पना करती है:

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

वैकल्पिक समाधान एक, बी, सी में स्पष्ट चर का उपयोग करते हुए :

↑≤⁰¡*/⁵²
— Zgarb
स्रोत
4

प्रोटॉन , 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— मिस्टर एक्सकोडर
स्रोत
1
लोग वास्तव में इस भाषा को याद करते हैं? : D
— HyperNeutrino
1
@ हैपरनेट्रिनो मैं सक्रिय रूप से इसका उपयोग करता हूं :)
— श्री एक्सकोडर
3
मुझे पता है कि मैं शायद कोई जवाब नहीं प्राप्त करने जा रहा हूँ, लेकिन क्यों?
— श्री Xcoder
3

जावास्क्रिप्ट (ईएस 6), 41 37 बाइट्स

@Neil के लिए 4 बाइट्स को सहेजा गया

के रूप में इनपुट लेता है (b,c)(a)।

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

परीक्षण के मामलों

कोड स्निपेट दिखाएं

टिप्पणी की गई

(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
— Arnauld
स्रोत
1
तर्कों का पुनर्पाठ मुझे देता है (b,c)=>g=a=>a>c?[]:[a,...g(b,b*=b/a)]।
— नील
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])

यह ऑनलाइन की कोशिश करो

रॉड और user202729 के लिए धन्यवाद मुझे कुछ बाइट्स कम करने में मदद करने के लिए!

— मनीष कुंडू
स्रोत
1
def + return -> lambda। पायथन टिप्स।
— user202729
1
आप भी कर सकते हैं import*।
— user202729
1
आप while i<=c:i++बहुत सारे बाइट्स बचाने के लिए (बजाय सूची समझ + लॉग का उपयोग कर सकते हैं )
— रॉड
@ क्या मुझे लॉग के बिना लूप का उपयोग कैसे करना चाहिए? idk कितनी देर तक चलना
— मनीष कुंडू
1
— user202729
2

पर्ल 6 , 26 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पर्ल 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
— Emigna
स्रोत
1

MATL , 17 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बस MATL में गेंद को रोल करने के लिए। मैं सोच भी नहीं सकता कि इसे हल करने की कोई क्रिया कम नहीं है।

— Sanchises
स्रोत
1
... कोई ट्रिपल नकार कृपया।
— user202729
2
@ user202729 मैं यह नहीं देखता कि आप यह कैसे नहीं पा सकते हैं कि यह एक दुर्घटना नहीं थी। :)
— Sanchises
क्या आपका मतलब यह नहीं है कि "मैं यह नहीं देखता कि आप कैसे नहीं पा सकते थे जो कि अनायास नहीं हुआ था": P
— HyperNeutrino
@ हैपरनेट्रिनो नं।
— Sanchises
— लुइस मेंडो
1

हास्केल, 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— nimi
स्रोत
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(मेरे पास शुरू करने के कई असफल प्रयास हैं y/i), लेकिन इस पद्धति का उपयोग करके, आप बड़े करीने से सब कुछ एक साथ रखते हैं।
— Sanchises
1
यह दृष्टिकोण वास्तव में ऑक्टेव में 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

जाप , 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

टीआई-बेसिक, 31 बाइट्स

उपयोगकर्ता और इनपुट से इनपुट लेता है Ans। मैंने n = c + b n / a -1 में n के लिए हल किया , n = 1 + ln (c / b) / ln (b / a) प्राप्त किया। यह n = 1 + लॉग के समान है 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
— kamoroso94
स्रोत
0

एपीएल (डायलॉग यूनिकोड) , 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

स्टेक्स , 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

इसे ऑनलाइन आज़माएं!

हम तीन नंबर पढ़ते हैं। दूसरे नंबर / पहले वाले द्वारा सामान्य अनुपात की गणना करें। तब हम श्रृंखला के माध्यम से चलाते हैं जब तक कि हम ऊपरी बाउंड से अधिक न हों।

— रोहन झुनझुनवाला
स्रोत
0

सी (जीसीसी), 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!

— vazt
स्रोत
69 बाइट्सn;f(a,b,c){for(float r=n=0;r=pow(b/a,n++)*a,r<=c&&printf("%f ",r););}
— छत
0

APL (Dyalog) , 23 बाइट्स ( SBCS) )

यह तर्क लेता है अब छोड़ दिया और पर ग सही पर,

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

इसे ऑनलाइन आज़माएं!

एक छोटा रास्ता होने की संभावना है, लेकिन मैंने सोचा कि ÷\ प्यारा था।

व्याख्या की:

{...}स्वायत्त कार्य onom है 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 ..

⍺,Prepend ⍺:2 6 6 3 18 9 54 27 162 81 ...

⊣/⍵2⍴ हर दूसरे तत्व को प्राप्त करें (साथ ही कुछ अनुगामी दोहराव):

  ⍵2⍴से एक ⍵पंक्ति, 2स्तंभ मैट्रिक्स बनाएं2 6 6 3 18 9 54 ...

  ⊣/ पहला स्तंभ प्राप्त करें

⊆⊢ सरणी को ब्लॉकों में विभाजित करें जहां

⍵∘≥ ⍵ सभी तत्वों से अधिक या बराबर है

⊃ पहले ऐसे ब्लॉक लें

— H.PWiz
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.