14

प्रोग्रामिंग भाषाओं की एक संख्या मौजूदा संख्या के अंत में अंक को 'समवर्ती' के माध्यम से बड़े पूर्णांक का निर्माण करती है। उदाहरण के लिए, भूलभुलैया , या एडाप्ट । अंकों को अंत तक पहुंचाने से मेरा मतलब है कि, यदि मौजूदा संख्या , और अंक , तो परिणाम संख्या । $45$ $7$ $457\:(45 \times 10 + 7)$

एक निर्मित संख्या एक संख्या है जिसे एकल अंकों की संख्याओं के गुणकों के उपयोग के माध्यम से इस तरह बनाया जा सकता है: AKA इन 9 अनुक्रमों में से एक में एक तत्व: $1, 2, 3, 4, 5, 6, 7, 8, 9$

1, 12, 123, 1234, 12345, \dots

$1, 12, 123, 1234, 12345, \: \dots$

2, 24, 246, 2468, 24690, \dots

$2, 24, 246, 2468, 24690, \: \dots$

3, 36, 369, 3702, 37035, \dots

$3, 36, 369, 3702, 37035, \: \dots$

4, 48, 492, 4936, 49380, \dots

$4, 48, 492, 4936, 49380, \: \dots$

5, 60, 615, 6170, 61725, \dots

$5, 60, 615, 6170, 61725, \: \dots$

6, 72, 738, 7404, 74070, \dots

$6, 72, 738, 7404, 74070, \: \dots$

7, 84, 861, 8638, 86415, \dots

$7, 84, 861, 8638, 86415, \: \dots$

8, 96, 984, 9872, 98760, \dots

$8, 96, 984, 9872, 98760, \: \dots$

9, 108, 1107, 11106, 111105, \dots

$9, 108, 1107, 11106, 111105, \: \dots$

अनुक्रम का निर्माण कैसे किया जाता है, इसका एक उदाहरण प्रदान करने के लिए, यहां बताया गया है कि निर्माण में का क्रम कैसा है : $a = 3$

\begin{aligned} u_{1} = & a = & 3 & = 3 \\ u_{2} = & 10 \times u_{1} + 2 \times a = & 30 + 6 & = 36 \\ u_{3} = & 10 \times u_{2} + 3 \times a = & 360 + 9 & = 369 \\ u_{4} = & 10 \times u_{3} + 4 \times a = & 3690 + 12 & = 3702 \\ u_{5} = & 10 \times u_{4} + 5 \times a = & 37020 + 15 & = 37035 \\ u_{6} = & 10 \times u_{5} + 6 \times a = & 370350 + 18 & = 370368 \end{aligned}

$\begin{align} u_1 = && a = && 3 & = 3\\ u_2 = && 10 \times u_1 + 2 \times a = && 30 + 6 & = 36 \\ u_3 = && 10 \times u_2 + 3 \times a = && 360 + 9 & = 369 \\ u_4 = && 10 \times u_3 + 4 \times a = && 3690 + 12 & = 3702 \\ u_5 = && 10 \times u_4 + 5 \times a = && 37020 + 15 & = 37035 \\ u_6 = && 10 \times u_5 + 6 \times a = && 370350 + 18 & = 370368 \\ \end{align}$

⋮

$\vdots$

\begin{aligned} u_{33} = & 10 \times u_{32} + 33 \times a = & 37 \dots 260 + 99 & = 37 \dots 359 \\ u_{34} = & 10 \times u_{33} + 34 \times a = & 37 \dots 359 + 102 & = 37 \dots 3692 \end{aligned}

$\begin{align} u_{33} = && 10 \times u_{32} + 33 \times a = && 37\dots260 + 99 & = 37\dots359 \\ u_{34} = && 10 \times u_{33} + 34 \times a = && 37\dots359 + 102 & = 37\dots3692 \end{align}$

⋮

$\vdots$

_{$u_{33}$ और को प्रदर्शित करने के लिए शामिल किया गया जब । एक बहुत अंकों की अंतरिक्ष के लिए बाहर बिंदीदार। $u_{34}$ $n \times a \ge 100$}

यह अभी भी स्पष्ट नहीं हो सकता है कि इन अनुक्रमों का निर्माण कैसे किया जाता है, इसलिए यहां उन्हें समझने के दो अलग-अलग तरीके हैं:

प्रत्येक अनुक्रम एकल अंक से शुरू होता है। अगला शब्द उस अंक के अगले कई लेने से मिलता है, पिछले शब्द को गुणा करना और कई को जोड़ना। क्रम में: $10$

$u_{n} = 10 \times u_{n - 1} + n \times a, u_{1} = a$ $u_n = 10 \times u_{n-1} + n \times a, \: \: u_1 = a$

जहां एकल अंक है ( के माध्यम से ) $a$ $1$ $9$

से प्रत्येक अनुक्रम में किसी भी बिंदु पर तत्वों (ले उदाहरण के लिए) के गुणज हैं से करने के लिए , जहां द्वारा निर्माण किया है $9$ $n = 3$ $123\dots$ $1$ $9$ $123\dots$ $u_{n+1} = 10 \times u_n + n$ $(1, 12, 123, \dots, 123456789, 1234567900, 12345679011, \dots)$

तो पहला मान , दूसरा , तीसरा , आदि। $1 \times 1, 2, 3, \dots, 8, 9$ $12 \times 1, 2, 3, \dots, 8, 9$ $123 \times 1, 2, 3, \dots, 8, 9$

आपका काम एक निर्माण संख्या को इनपुट के रूप में लेना है और इसका निर्माण करने के लिए उपयोग किए गए प्रारंभिक अंक का उत्पादन करना है। आप मान सकते हैं कि इनपुट हमेशा एक निर्मित संख्या होगी, और से अधिक होगी । यह एक एकल अंक हो सकता है, जो अपने आप में वापस मैप करता है। $0$

आप किसी भी उचित तरीके से इनपुट ले सकते हैं, जिसमें अंकों की एक सूची, एक स्ट्रिंग आदि के रूप में शामिल है। यह स्वीकार्य है (हालांकि अनुशंसित नहीं है), या आपके चयन के किसी अन्य आधार पर इनपुट लेने के लिए।

यह एक कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है!

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

       u_n        => a
 37035            => 3
 6172839506165    => 5
 5                => 5
 246913580244     => 2
 987654312        => 8
 61728395061720   => 5
 1111104          => 9
 11111103         => 9
 111111102        => 9
 2469134          => 2
 98760            => 8
 8641975308641962 => 7

या दो सूचियों के रूप में:

[37035, 6172839506165, 5, 246913580244, 987654312, 61728395061720, 1111104, 11111103, 111111102, 2469134, 98760, 8641975308641962]
[3, 5, 5, 2, 8, 5, 9, 9, 9, 2, 8, 7]

जब मैंने इस चुनौती को पोस्ट किया, तो मुझे यह महसूस नहीं हुआ कि ग्रिम के उत्तर में इस्तेमाल की गई विधि से इसे इतना सरल बनाया जा सकता है , और इसलिए यह उन उत्तरों में बहुत रुचि होगी जो इसे हल करने के लिए एक गणितीय दृष्टिकोण लेते हैं, बजाय एक 'अंक' के। चाल (स्पष्ट रूप से सभी मान्य उत्तर समान रूप से मान्य हैं, बस मुझे जो देखने में दिलचस्पी होगी)।

code-golf number sequence

— केर्ड सिक्काहिराहिंग
स्रोत

सैंडबॉक्स पोस्ट । मैं जेली में एक 9 बाइट समाधान है, अगर कोई भी चुनौती देना चाहता है।

— caird coinheringaahing

26

05AB1E , 7 5 4 बाइट्स

>9*н

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

>            # input + 1
 9*          # * 9
   н         # take the first digit

— ग्रिमी
स्रोत

6

हम्म, जो इस चुनौती के लिए अच्छी तरह से नहीं

— झुकता है

9

आपके पास चुनौती स्पष्टीकरण के 800 बाइट्स के लिए लगभग 1 बाइट कोड है। : p

— Arnauld

1

आप कैसे समाधान के साथ आते हैं और यह सही क्यों है?

— जोएल

7

@Joel a (n-1) th का क्रम a से शुरू होता है a * (((10**n - 1) / 9 - n) / 9)। 9 से गुणा करें और जोड़ते हैं a*n, और आप प्राप्त करते हैं a * ((10**n - 1) / 9), अंक को एक बार दोहराया गया एन। a*nN = 1 के लिए कामों के बजाय 9 को जोड़ देता है , और बड़े n के लिए निरंतर अंतर घातीय वृद्धि के बगल में नगण्य है।

— ग्रैमी

3

@ ग्रेमी स्पष्टीकरण के लिए बहुत बहुत धन्यवाद। हो सकता है कि आप इसे अपनी पोस्ट में डाल सकते हैं।

— योएल

3

मैथॉल्फ , 6 बाइट्स

)9*▒├Þ

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

दुर्भाग्य से, headMathGolf में कोई ऑपरेशन नहीं है , इसलिए मुझे ▒├Þस्ट्रिंग में कनवर्ट करने के लिए, बाईं ओर से पॉप और स्टैक के शीर्ष पर सभी को त्यागना होगा।

— मजाक कर रहा है
स्रोत

2

जेली , 5 बाइट्स

‘×9DḢ

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

ग्रिम के दृष्टिकोण का उपयोग करना ।

— आउटगोल्फ को एरिक करें
स्रोत

2

स्टैक्स , 5 बाइट्स

^9*Eh

इसे चलाएं और डीबग करें

— ओलिवर
स्रोत

2

जाप `-g` , 7 6 5 बाइट्स

-1 बाइट शैगी को धन्यवाद

एक स्ट्रिंग के रूप में इनपुट लेता है

i°U*9

कोशिश करो | कई इनपुट का परीक्षण करें

— ओलिवर
स्रोत

1

5 बाइट्स , एक स्ट्रिंग के रूप में इनपुट लेना।

— झबरा

2

चारकोल , 7 बाइट्स

§Ｉ×⁹⊕Ｎ⁰

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। @ ग्रिम की विधि निश्चित रूप से। यहाँ एक 27 बाइट गणितीय दृष्टिकोण है:

ＮθＷ¬№Ｅχ×κ↨υχθ⊞υＬυＩ⌕Ｅχ×ι↨υχθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। अमान्य इनपुट पर क्रैश। स्पष्टीकरण:

Ｎθ

निर्मित संख्या को इनपुट करें।

Ｗ¬№Ｅχ×κ↨υχθ

से सभी नंबरों से आधार 10 में एक संख्या के रूप सूची व्याख्या गुणा 0करने के लिए 9, और निर्माण नंबर दिखाई देता है कि क्या देखते हैं।

⊞υＬυ

सूची की लंबाई को अपने आप में पुश करें। लिस्ट इसलिए फॉर्म की हो जाती है [0, 1, 2, ..., n]।

Ｉ⌕Ｅχ×ι↨υχθ

निर्मित संख्याओं को फिर से बनाएँ लेकिन इस बार उस सूचकांक को खोजें और आउटपुट करें जिस पर इनपुट नंबर दिखाई दिया।

— नील
स्रोत

2

भूलभुलैया , 28 22 20 बाइट्स

9 10/;!@
? _ :
)*"""

ग्राइमी द्वारा बताए गए डिजिट -आधारित पद्धति को शून्य तक दोहराए जाने तक पूर्णांक विभाजन द्वारा लागू होता है।

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

— जोनाथन एलन
स्रोत

2

व्हॉट्सएप , 108 बाइट्स

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][S S S T    N
_Push_1][T  S S S _Add][S S S T S S T   N
_Push_9][T  S S N
_Multiply][S S S T  N
_Push_1][N
S S N
_Create_Label_LOOP][S S S T S T S N
_Push_10][T S S N
_Multiply][S N
S _Duplicate][S T   S S S T S N
_Copy_0-based_2nd]S N
T   Swap_top_two][T S S T   _Subtract][N
T   T   S N
_If_neg_jump_to_Label_PRINT][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT][S S S T    S T S N
_Push_10][T S T S _Integer_divide][T    S T S _Integer_divide][T    N
S T _Output_top_as_number]

पत्र S(स्थान), T(टैब), और N(नई-पंक्ति) केवल हाइलाइटिंग के रूप में जोड़े गए।
[..._some_action]केवल स्पष्टीकरण के रूप में जोड़ा गया।

पोर्ट @Grimy का 05AB1E उत्तर है , सिवाय इसके कि मेरे पास पहला अंक प्राप्त करने के लिए एक बिलिन नहीं है। ;)

इसे ऑनलाइन आज़माएं (कच्चे स्थान, टैब और नई लाइनों के साथ)।

छद्म कोड में स्पष्टीकरण:

Integer i = STDIN as integer
i = i + 1
i = i * 9
Integer t = 1
Start LOOP:
  t = t * 10
  If(i - t < 0):
    Call function PRINT
  Go to next iteration of LOOP

function PRINT:
  t = t / 10
  i = i / t    (NOTE: Whitespace only has integer-division)
  Print i as integer to STDOUT

— केविन क्रूज़सेन
स्रोत

2

पायथन 3 , 22 बाइट्स

lambda i:str(-~i*9)[0]

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

पोर्ट ऑफ ग्रिम का 05AB1E उत्तर

पायथन 3 , 74 बाइट्स

f=lambda i,j=1,k=2,l=1:l*(i==j)or f(i,*(10*j+k*l,l+1,k+1,2,l,l+1)[i<j::2])

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

व्याख्या

पुनरावर्ती कार्य। प्रत्येक अंक के लिए अनुक्रम से अधिक lशुरू, पर शुरू होता है 1। यदि इनपुट iवर्तमान पुनरावृत्ति के बराबर है j, तो संबंधित अंक lवापस आ जाता है। यदि jअनुक्रम में वर्तमान मान इनपुट मान से अधिक है i, तो यह अंक को बढ़ाएगा lऔर शुरू होगा। तर्क kका उपयोग गुणन कारक को बढ़ाने के लिए किया जाता है।

— Jitse
स्रोत

1

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

पिछले संस्करण के साथ मेरे पास 32-बिट बाधा उठाने के लिए @Grimy के लिए धन्यवाद।

ग्रिम की जादुई भस्म का उपयोग करना । एक स्ट्रिंग के रूप में इनपुट लेता है।

n=>(n*9+9+n)[0]

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

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

Naive brute बल दृष्टिकोण।

n=>(g=(k,x=i=0)=>x>n?g(k+1):x<n?g(k,++i*k+10*x):k)(1)

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

— Arnauld
स्रोत

-~n*9हो सकता है n*9+9, जो एक ही बाईटेकाउंट है, लेकिन अगर मुझे सही तरीके से समझा जाए तो 32-बिट सीमा से छुटकारा मिलना चाहिए।

— ग्रिम्मी

ब्रूट बल एक = = 10 के लिए काम करता है, जैसे14808

— नहुएल फौइलुल

1

@ नहुएलफौइल अगर हम एक = = 10 पर विचार करें, तो उत्तर अब अनूठा नहीं है (14808 = 4 का कार्यकाल = 12 हो सकता है, या = 14808 का पहला शब्द)। यदि किसी भी आउटपुट की अनुमति है, तो n=>nसभी इनपुट के लिए काम करता है।

— ग्रिम्मी

1

जावा 8, 23 बाइट्स

n->(n*9+9+"").charAt(0)

पोर्ट @Grimy का 05AB1E उत्तर है , इसलिए उसे सुनिश्चित करें!

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

लेकिन क्योंकि मैं @cairdCoinheringaahing के लिए बुरा महसूस करता हूं , यहां थोड़ा अधिक खर्च ( 83 बाइट्स ) के साथ एक जानवर-बल दृष्टिकोण है :

n->{long r=n,a=0,u,k;for(;++a<10;r=u>n?r:a)for(k=2,u=a;u<n;)u=u*10+k++*a;return r;}

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

स्पष्टीकरण:

n->{                 // Method with long as both parameter and return-type
  long r=n,          //  Result, starting at the input in case it's already a single digit
       a=0,          //  The digit to start the sequence with
       u,            //  The last number of the sequence we're building for digit a
       k;            //  Multiplier which increments each iteration
  for(;++a<10;       //  Loop in the range [1,9] (over each digit):
      r=u>n?         //    After ever iteration: if `u` is larger than the input:
            r        //     Keep the result the same
           :         //    Else:
            a)       //     Change the result to `a`
    for(k=2,         //   Reset `k` to 2
        u=a;         //   Reset `u` to the current digit `a`
        u<n;)        //   Inner loop as long as `u` is smaller than the input
      u=             //    Change `u` to:
        u*10         //     10 times the current `u`
            +k++*a;  //     With `k` multiplied by `a` added
                     //     (after which `k` increases by 1 with `k++`)
  return r;}         //  And after we iterated over each digit, return the result

— केविन क्रूज़सेन
स्रोत

0

PHP , 20 बाइट्स

<?=(_.++$argn*9)[1];

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

फिर भी एक और गंभीर उत्तर पोर्ट!

— Night2
स्रोत

0

जेली , 8 बाइट्स

RRḌ÷@fⱮ9

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

एक पूर्ण कार्यक्रम जो एक पूर्णांक लेता है और स्टार्टर अंक को प्रिंट करता है। ग्रिम की चालाक विधि का उपयोग नहीं करता है! बड़े इनपुट के लिए बहुत अक्षम है। निम्न संस्करण सभी परीक्षण मामलों को संभालता है, लेकिन एक बाइट अधिक समय तक है:

जेली , 9 बाइट्स

DJRḌ÷@fⱮ9

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

— निक केनेडी
स्रोत

0

Hy , 44 बाइट्स

(defn a[p](print(get(str(*(+(int p)1)9))0)))

ग्रिम की विधि का उपयोग करता है

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

— girobuz
स्रोत

0

केग `-rr` , 4 बाइट्स

⑨9*÷

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

बेशक, 05AB1E उत्तर के समान दृष्टिकोण का उपयोग करता है। नए -rr(रिवर्स और प्रिंट कच्चे) ध्वज का भी उपयोग करता है ।

ट्रांसपाइल्स:

from KegLib import *
from Stackd import Stack
stack = Stack()
printed = False
increment(stack)
integer(stack, 9)
maths(stack, '*')
item_split(stack)
if not printed:
    reverse(stack)
    raw(stack)

— Lyxal
स्रोत

0

Wren , 30 बाइट्स

ज्यादातर जवाबों का एक बंदरगाह।

Fn.new{|i|(i*9+9).toString[0]}

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

यह निर्मित संख्या का स्टार्टर क्या है?

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

05AB1E , 7 5 4 बाइट्स

मैथॉल्फ , 6 बाइट्स

जेली , 5 बाइट्स

स्टैक्स , 5 बाइट्स

जाप -g , 7 6 5 बाइट्स

चारकोल , 7 बाइट्स

भूलभुलैया , 28 22 20 बाइट्स

व्हॉट्सएप , 108 बाइट्स

पायथन 3 , 22 बाइट्स

पायथन 3 , 74 बाइट्स

व्याख्या

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

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

जावा 8, 23 बाइट्स

PHP , 20 बाइट्स

जेली , 8 बाइट्स

जेली , 9 बाइट्स

Hy , 44 बाइट्स

केग -rr , 4 बाइट्स

Wren , 30 बाइट्स

जाप `-g` , 7 6 5 बाइट्स

केग `-rr` , 4 बाइट्स