विस्तार और अनुबंध

Question

इनपुट के रूप में एक सकारात्मक पूर्णांक $k$ लें । साथ प्रारंभ $n := 1$ और बार-बार वृद्धि $n$ दस में से सबसे बड़ी पूर्णांक शक्ति से $i$ कि इस तरह $i \le n$ और $i + n \le k$ ।

दोहराएँ जब तक $n = k$ और के सभी मध्यवर्ती मूल्यों की एक सूची प्रदान $n$ दोनों प्रारंभिक सहित, $1$ और अंतिम $k$ ।

इस प्रक्रिया के दौरान, विकास शुरू में पूर्व असमानता से सीमित होगा, और बाद में केवल बाद में; विकास एक प्रारंभिक "विस्तार" अवधि का रूप लेगा, जिसके दौरान $n$ को कभी-बड़ी शक्तियों द्वारा बढ़ाया जाता है, उसके बाद "अनुबंध" अवधि, जिसके दौरान $n$ को "छोटी" करने के लिए कभी-छोटी शक्तियों द्वारा बढ़ाया जाता है। सही संख्या पर।

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

1 => [1]
10 => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
321 => [1,  2,  3,  4,  5,  6,  7,  8,  9,
        10, 20, 30, 40, 50, 60, 70, 80, 90,
        100, 200, 300, 310, 320, 321]
1002 => [1,   2,   3,   4,   5,   6,   7,   8,   9,
         10,  20,  30,  40,  50,  60,  70,  80,  90,
         100, 200, 300, 400, 500, 600, 700, 800, 900,
         1000, 1001, 1002]

यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

Comments

क्या हम सूची वापस करने के बजाय संख्याओं को प्रिंट कर सकते हैं?

— आदम

@ Adám हां, आप कर सकते हैं।

— फल

Answer 1

हास्केल , 72 68 64 63 बाइट्स

f=(1!)
c!t|t==c=[c]|t>c=c:(c+10^(pred.length.show.min c$t-c))!t

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

-4 बाइट्स के लिए धन्यवाद श्रीकोटिलिज्म ओ'जैसिक!

प्रयोग

f 321
[1,2,3,4,5,6,7,8,9,10,20,30,40,50,60,70,80,90,100,200,300,310,320,321]

व्याख्या

c!t         -- c=current number, t=target number
 |t==c=[c]  -- Target is reached, return last number
 |t>c=c:(c+10^(pred.length.show.min c$t-c))!t
      c:                                        -- Add current number to list
                                min c$t-c       -- The minimum of the current number, and the difference between the current number and the target
                    length.show.                -- The length of this number
               pred.                            -- Minus 1
           10^(                          )      -- Raise 10 to this power
         c+                                     -- Add that to the current number
        (                                 )!t   -- Recursion

Comments

PPCG में आपका स्वागत है! पहला जवाब अच्छा लगा।

— अरनुलद

मैं हास्केल को नहीं जानता, लेकिन शायद इनमें से कोई भी सुझाव मदद कर सकता है: हास्केल में गोल्फिंग के लिए टिप्स और <सभी भाषाओं में गोल्फिंग के लिए टिप्स> । लेकिन मैं सहमत हूं, अच्छा जवाब। मुझ से +1।

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

साइट पर आपका स्वागत है! के बाद से (^)उच्च पूर्वता है की तुलना में (+)आप के आसपास कोष्ठक की जरूरत नहीं है (^)अभिव्यक्ति। उसी के लिए (!)और(:)

— गेहूं जादूगर

pred.length.show.min c$t-cको छोटा किया जा सकता है length(show.min c$t-c)-1। बेनामी फ़ंक्शन स्वीकार्य हैं, इसलिए आप हास्केल में गोल्फिंग नियमों केf= बारे में हमारे गाइड में बताए अनुसार इसे छोड़ सकते हैं ।

— लकोनी

गार्ड के बजाय, आप केवल एक मामले और एक सशर्त का उपयोग कर सकते हैं c!t=c: if t>c then (c+10^(length(show.min c$t-c)-1))!t else []:। यह कुछ और बाइट्स को बचाने के लिए इस टिप को लागू करने की अनुमति देता है : इसे ऑनलाइन आज़माएं!

— लिकोनी

Answer 2

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

f=n=>n?[...f(n-(1+/(^10)?(0*$)/.exec(n)[2])),n]:[]

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

कैसे?

सिद्धांत

निम्नलिखित चरण $n=0$ तक दोहराए जाते हैं :

• $k$$n$
• $k$$n$$10$
• घटाएँ$x=10^k$$n$

कार्यान्वयन

$x$

+---- leading '1'
|
1 + /(^10)?(0*$)/.exec(n)[2]
     \____/\___/
        |    |
        |    +---- trailing zeros (the capturing group that is appended to the leading '1')
        +--------- discard one zero if n starts with '10'

'10'$10$$n=\color{red}{10}\color{green}{00}$$n=\color{red}{10}23\color{green}{00}$'10'

Comments

सरल नोटिंग आप केवल एक चर का ट्रैक रखते हुए "बैकवर्ड" पुनरावृत्ति कर सकते हैं! यह थोड़ा भ्रमित है कि आप का उपयोग kकुछ चुनौती विवरण में से पूरी तरह से अलग के लिए (वास्तव में अपने nओ पी के का एक मिश्रण है nऔर kऔर अपने xअपने है i।)

— Orjan Johansen

Answer 3

पायथन 2 , 61 बाइट्स

f=lambda k,n=1:n<k and[n]+f(k,n+10**~-len(`min(n,k-n)`))or[n]

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

Answer 4

पर्ल 6 , 48 41 बाइट्स

->\k{1,{$_+10**min($_,k-$_).comb/10}...k}

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

स्पष्टीकरण:

->\k{                                   }  # Anonymous code block taking k
     1,                             ...k   # Start a sequence from 1 to k
       {                           }       # Where each element is
        $_+          # The previous element plus
           10**      # 10 to the power of
                           .comb     # The length of
               min($_,k-$_)          # The min of the current count and the remainder
                                /10  # Minus one

Answer 5

एपीएल (Dyalog यूनिकोड) , 30 बाइट्स ^SBCS

बेनामी tacit उपसर्ग समारोह। स्टडआउट करने के लिए अलग-अलग लाइनों पर प्रिंट करता है।

{⍺=⍵:⍺⋄⍺∇⍵+10*⌊/⌊10⍟⍵,⍺-⎕←⍵}∘1

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

{}∘1$n$

 ⍺=⍵$k$$n$

  ⍺$k$

 ⋄ अन्य:

  ⎕←⍵$n$

  ⍺-  से घटाएँ$k$

  ⍵,$n$

  10⍟ $\log_{10}$

  ⌊ उन मंजिल

  ⌊/ उनमे से न्यूनतम

  10* दस उस की शक्ति को उठाया

  ⍵+ $n$

  ⍺∇ उसी का उपयोग करके पुनरावृत्ति$k$$n$

 

Answer 6

05AB1E , 15 बाइट्स

1[=ÐIαD_#‚ßg<°+

@PaulMutser का पोर्ट (पहला) हास्केल उत्तर , इसलिए उसे सुनिश्चित करना सुनिश्चित करें !!

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

आउटपुट संख्याओं को सीमांकित किया गया।
यदि यह एक सूची होनी चाहिए, तो मुझे 3 बाइट्स जोड़ने होंगे:

X[DˆÐIαD_#‚ßg<°+}¯

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

1             # Push a 1 to the stack
 [            # Start an infinite loop
  =           #  Print the current number with trailing newline (without popping it)
  Ð           #  Triplicate the current number
   Iα         #  Get the absolute difference with the input
     D        #  Duplicate that absolute difference
      _       #  If this difference is 0:
       #      #   Stop the infinite loop
      ‚ß      #  Pair it with the current number, and pop and push the minimum
        g<°   #  Calculate 10 to the power of the length of the minimum minus 1
           +  #  And add it to the current number

Answer 7

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

1µ«³_$DL’⁵*$+µ<³$п

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

Answer 8

वोल्फ्राम भाषा (गणितज्ञ) , 51 बाइट्स

Union@NestList[#+10^Floor@Log10@Min[s-#,#]&,1,s=#]&

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

Answer 9

बैच, 131 बाइट्स

@set/an=i=1
:e
@if %n%==%i%0 set i=%i%0
@echo %n%
:c
@set/an+=i
@if %n% leq %1 goto e
@set/an-=i,i/=10
@if %i% neq 0 goto c

एक कमांड-लाइन पैरामीटर के रूप में इनपुट लेता है और STDOUT को संख्याओं की सूची आउटपुट करता है। स्पष्टीकरण:

@set/an=i=1

10 की शक्ति के साथ शुरू करें n=1और i=1उसका प्रतिनिधित्व करें।

:e
@if %n%==%i%0 set i=%i%0

i10 से गुणा करें यदि 10 nकी अगली शक्ति तक पहुंच गया है।

@echo %n%

का वर्तमान मूल्य आउटपुट n।

:c
@set/an+=i
@if %n% leq %1 goto e

दोहराएँ, जबकि iकरने के लिए जोड़ा जा सकता है nयह इनपुट को पार किए बिना।

@set/an-=i,i/=10

पिछले मान को पुनर्स्थापित करें nऔर i10 से विभाजित करें ।

@if %i% neq 0 goto c

यदि iशून्य नहीं है, तो फिर से जोड़ने iका प्रयास nकरें।

Answer 10

आर , 67 65 बाइट्स

-2 बाइट्स ग्यूसेप के लिए धन्यवाद

k=scan();o=1;i=10^(k:0);while(T<k)o=c(o,T<-T+i[i<=T&i+T<=k][1]);o

बहुत साधारण। यह 10 से अधिक शक्तियों का एक सेट लेता है जो रिवर्स ऑर्डर में आवश्यक होगा i।

(मैं i=10^rev(0:log10(k))इसके बजाय का उपयोग करना पसंद करूंगा i=10^(k:0)क्योंकि बाद वाला कम्प्यूटेशनल रूप से अप्रभावी है, लेकिन गोल्फ गोल्फ है!)।

फिर थोड़ी देर के लूप में, शर्तों को लागू करता है iऔर पहले (यानी सबसे बड़ा) लेता है; अद्यतन n, और उत्पादन के लिए संलग्न है

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

Comments

के Tबजाय का उपयोग करके एक बाइट सहेजें n; यह 2 होना चाहिए, लेकिन मुझे नहीं लगता कि TRUEयह स्वीकार्य आउटपुट है k=1, इसलिए हम सेट करते हैं o=+T। कोशिश करो!

— Giuseppe

यह भयावह कोडिंग है, मुझे यह पसंद है। संक्षेप में, मैं सेट कर सकता हूं o=1, और उस दूसरी बाइट को प्राप्त कर सकता हूं ।

— एरोन हेमैन

Answer 11

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

1+«ạæḟ⁵«Ɗɗ¥Ƭ

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

Answer 12

पिप , 27 बाइट्स

Wa>Po+:y/t*Y1Ty>o|o+y>ay*:t

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

छद्मकोश में:

a = args[0]
o = 1
print o
while a > o {
  y = 1
  till y > o || o + y > a
    y *= 10
  o += y / 10
  print o
}

मैं बहुत खुश हूँ कि मैं इस एल्गोरिथ्म को छोटा करने के लिए आवेदन करने में सक्षम था। लूप हैडर में सामान को इनिशियलाइज़, अपडेट और प्रिंट करके, मैं लूप बॉडी के लिए घुंघराले ब्रेस की ज़रूरत से बचने में सक्षम था। शायद एक गोल्फ एल्गोरिथ्म है, हालांकि।

Answer 13

जाप , 18 बाइट्स

ÆT±ApTmTnU)sÊÉÃf§U

कोशिश करो

ÆT±ApTmTnU)sÊÉÃf§U     :Implicit input of integer U
Æ                      :Map the range [0,U)
 T±                    :  Increment T (initially 0) by
   A                   :  10
    p                  :  Raised to the power of
     Tm                :    The minimum of T and
       TnU             :      T subtracted from U
          )            :    End minimum
           s           :    Convert to string
            Ê          :    Length
             É         :    Subtract 1
              Ã        :End map
               f       :Filter
                §U     :  Less than or equal to U

Answer 14

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 123 122 बाइट्स

m=>{var a=new[]{1}.ToList();int s;for(;(s=a.Last())<m;)a.Add(s+(int)Math.Pow(10,(int)Math.Log(s<m-s?s:m-s,10)));return a;}

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

Answer 15

प्रोलॉग (एसडब्ल्यूआई) , 142 बाइट्स

L-D-M:-append(L,[D],M).
N-L-C-X-R-I:-I=1,C is X*10,N-L-C-C-R-1;D is C+X,(D<N,L-D-M,N-M-D-X-R-I;D>N,N-L-C-(X/10)-R-0;L-D-R).
N-R:-N-[]-0-1-R-1.

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

कल या कुछ और आने वाला स्पष्टीकरण