किसी को GAU नंबर नहीं पता

22

मुझे आपको GAU नंबर से मिलवाते हैं

GAU(1) = 1  
GAU(2) = 1122  
GAU(3) = 1122122333  
GAU(4) = 11221223331223334444  
GAU(6) = 11221223331223334444122333444455555122333444455555666666  
...  
GAU(10) = 11221223331223334444122333444455555122333444455555666666122333444455555666666777777712233344445555566666677777778888888812233344445555566666677777778888888899999999912233344445555566666677777778888888899999999910101010101010101010

यह चुनौती बहुत आसान है!

पूर्णांक n> 0 को देखते हुए GAU (n) के अंकों की संख्या ज्ञात कीजिए।

उदाहरण

चलो जीएयू (4) बनाते हैं
हम निम्नलिखित कदम उठाते हैं (जब तक कि हम 4 तक नहीं पहुंच जाते हैं) और उन्हें संक्षिप्त करें 

[1][122][122333][1223334444]

आपको हर संख्या को उसके मान के रूप में कई बार लिखना होगा, लेकिन आपको हर बार 1 से गिनती करनी होगी

आइए जीएयू (5) बनाने की कोशिश करें,
हमें 1 से 1 तक गिनना होगा

[1]

फिर 1 से 2 तक (लेकिन हर संख्या को उसके मान के अनुसार कई बार दोहराते हुए ) 

[122]

फिर 1 से 3 तक 

[122333]

फिर 1 से 4 तक 

[1223334444]

और अंत में 1 से 5 तक (यह अंतिम चरण है क्योंकि हम GAU ( 5 ) खोजना चाहते हैं ) 

[122333444455555]

अब हम इन सभी कदमों को लेते हैं और उन्हें
नतीजा देते हैं GAU (5) 

11221223331223334444122333444455555

हम इन GAU संख्याओं के अंकों की संख्या में रुचि रखते हैं।

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

Input⟼Output 

n   ⟼ Length(GAU(n))

1   ⟼ 1  
2   ⟼ 4  
3   ⟼ 10  
10  ⟼ 230   
50  ⟼ 42190  
100 ⟼ 339240  
150 ⟼ 1295790

यह एक कोड-गोल्फ चुनौती है।
बाइट्स में सबसे छोटा कोड जीत जाएगा।

यदि आपके पास अभी भी कोई सवाल है तो कृपया मुझे बताएं।
मैं वास्तव में चाहता हूं कि हर कोई इस जादू-छिपे-जटिल पैटर्न को समझे

code-golf  sequence 
4
जीएयू किस लिए खड़ा है?
— लीक नून
21
G
2
N = 9 तक, लंबाई टेट्राहेड्रल संख्या होती है, लेकिन इससे परे बहु अंकों की संख्या एक साधारण बंद रूप में
— मिलती है
FYI करें आपका परीक्षण मामला कहता है n ⟼ Length(GUA(n)), GAU (n) नहीं।
— नंबरमैन
2
@numbermaniac इसे स्थान देने के लिए धन्यवाद। GUA नंबर बिलकुल अलग हैं। वे अभी तक का आविष्कार नहीं किया गया है!

जवाबों:

14

SOGL V0.12 , 11 10 8 7 5 बाइट्स

∫∫l*+

यह कोशिश करो! - यह स्टैक पर इनपुट के साथ एक फ़ंक्शन के रूप में कहा जाता है और इनपुट बॉक्स खाली होने की उम्मीद है।
इनपुट बॉक्स से इनपुट लेते हुए 7 बाइट विकल्प:

0.∫∫l*+

यह कोशिश करो!

0      push 0
 .     push the input
  ∫    iterate over a range 1..POP (input) inclusive, pusing the current number
   ∫    iterate over 1..POP (above loops number) inclusive, pusing the current number
    l    push that numbers length without popping the number
     *   multiply the length by the number
      +  add to the zero, or whatever it is now
— dzaima
स्रोत
push that numbers length without popping the numberअच्छा
— एरिक आउटगॉल्फ
7

ब्रेन-फ्लैक , 166 बाइट्स

<>(((()()())({}){})())<>{({}[()]<({}({}<<>({}[()])((){[()](<()>)}{}){{}((((({})({})){}{}){}))<>(({}<({}())>){()<({}[({})])>}{})(<>)}{}<>>({}({})())))>)}{}({}<{}{}{}>)

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

व्याख्या

<>(((()()())({}){})())<>           # Initialize second stack with 9 and 10
{({}[()]<                          # Do main loop n times:
  ({}
    ({}
      <
        <>({}[()])                 # Subtract 1 from counter to next power of 10
        ((){[()](<()>)}{}){        # If reached a power of 10 (say, 10^k):
          {}((((({})({})){}{}){})) # Multiply existing (10^k*0.9) by 10 and push twice
          <>                       # On first stack
          (
            ({}<({}())>)           # Increment length of numbers
            {()<({}[({})])>}{}     # Divide length of new set of numbers by this length
          )                        # Add together to get new set of numbers length
        (<>)}  
      {}<>>  
      ({}({})())                   # Add number length to number set length
    )                              # Add number set length to new segment length
  )                                # Add new segment length to total length
>)}                                # End main loop
{}({}<{}{}{}>)                     # Put result on stack by itself
— Nitrodon
स्रोत
3

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

ṁLṁṘNḣḣ

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

व्याख्या

          Implicit input, e.g 4
      ḣ   Range from 1 to n                               [1,2,3,4]
     ḣ    Prefixes                                        [[],[1],[1,2],[1,2,3],[1,2,3,4]]
  ṁ       Map and then concatenate
   ṘN     Repeat each number in each list by its index    [[],[1],[1,2,2],[1,2,2,3,3,3],[1,2,2,3,3,3,4,4,4,4]]
                                                          [1,1,2,2,1,2,2,3,3,3,1,2,2,3,3,3,4,4,4,4]
ṁ         Map and then sum
 L        Length (of number: 10 -> 2)                     26
— H.PWiz
स्रोत
ओह, एक और भूसी समाधान :) मेरा प्रस्तुतिकरण नहीं देखा था जब मेरा पोस्टिंग, एक ही bytecount, लेकिन वे पर्याप्त रूप से अलग हैं, तो मैं यहाँ भी छोड़ दूँगा।
— '12:
3

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

एक और एक जोनाथन फ्रेच को धूल धन्यवाद देता है।

f=lambda n:n and sum(i*len(`i`)for i in range(n+1))+f(n-1)

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

कम नहीं है, लेकिन एह ... क्या बिल्ली।

— totallyhuman
स्रोत
len(`i`)*i for-> i*len(`i`)for।
— जोनाथन फ्रेच
53 बाइट्स , गैर-पुनरावर्ती।
— जोनाथन फ्रीच
3

CJam , 20 बाइट्स

q~),(\{),{_s,*+}*+}%

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

नंबर "इनपुट" फ़ील्ड में पास किया गया है।

असंबद्ध स्पष्टीकरण: (उदाहरण इनपुट = 2)

q~),(\{),{_s,*+}*+}%                                             | Stack:
q                     read input as string                       | "2"
 ~                    eval input (add it to stack as integer)    | 2
  )                   add 1                                      | 3
   ,                  range (convert to array with values 0...N) | [0, 1, 2]
    (                 pop first item of array                    | [1, 2] 0
     \                swap top two values of stack               | 0 [1, 2]
      {           }   for each item in array...                  | 0 1
       )              add 1                                      | 0 2
        ,             range (convert to array with values 0...N) | 0 [0, 1]
         {     }      for every element in the array...          | 0 0
          _           duplicate                                  | 0 0 0
           s          convert to string                          | 0 0 "0"
            ,         get length of string                       | 0 0 1
             *        multiply                                   | 0 0
              +       add                                        | 0 1
                *     fold                                       | 0 1
                 +    add                                        | 1
                   %  repeat                                     | 4

लोल समझाया गया तो यह कठिन लगता है।

— इका नू
स्रोत
2

जे, 24 बाइट्स

[:+/[:+/\[:(*#@":"0)1+i.

डीज़िमा के एपीएल उत्तर के समान उच्च-स्तरीय दृष्टिकोण, जे में अनुवाद किया गया, सिवाय इसके कि हम संख्याओं की लंबाई की गणना लॉग्स लेने के बजाय पहले एक स्ट्रिंग में बदलकर करते हैं, और हमें जे की हुक का उपयोग उस संख्या को गुणा करने के लिए मिलता है: (*#@":"0) :। उसके बाद यह सिर्फ स्कैन राशि का योग है।

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

— जोनाह
स्रोत
1
1(#.]*#\*#\.)1#@":@+i.22 बाइट्स के लिए भी काम करता है
— मील
@ मीलों यह चतुर है - यह पता लगाने के लिए मुझे थोड़ा सा लगा। J में प्रोग्रामिंग कब से हो रही है?
— जोनाह
थोड़ी देर बाद मैं कोड-गोल्फ में शामिल हो गया। मैं वास्तव में किसी भी वास्तविक कार्यक्रम को लिखने के लिए इसका उपयोग नहीं करता हूं क्योंकि मुझे नहीं पता कि इसे पढ़ने में सक्षम होगा, लेकिन मैं इसे अब एक उन्नत डेस्कटॉप कैलकुलेटर के रूप में उपयोग करता हूं, और आमतौर पर हमेशा कुछ की गणना करने के लिए एक खिड़की खुली होती है।
— मील
2

आर , 39 बाइट्स

function(n)sum(nchar(rep(1:n,n:1*1:n)))

सभी परीक्षण मामलों की पुष्टि करें!

सरल एल्गोरिथ्म; मैंने देखा, के रूप में सबसे अधिक था, उस के लिए iमें 1:n, iदोहराया है i*(n-i+1)बार। इसलिए मैं उस वेक्टर को बनाता हूं, प्रत्येक में वर्णों की संख्या गिनता हूं, और उन्हें योग करता हूं।

— ग्यूसेप
स्रोत
1

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

lambda n:sum(~k*(k-n)*len(`k+1`)for k in range(n))
— orlp
स्रोत
@LeakyNun क्यों? मैंने इस उत्तर को स्वयं विकसित किया। मैंने अन्य उत्तरों की जाँच भी नहीं की।
— orlp
1
यह सही उत्तर का उत्पादन भी नहीं करता है, 0 के लिए n = 1, 3 के लिए n = 2 और 14 के लिए n = 3
— Halvard Wil को
@HalvardHummel उफ़, एक संकेत गड़बड़ कर दिया और एक +1 को भूल गए। अभी तय किया है।
— orlp
मैं देख रहा हूँ कि आप आखिरकार पितर समझ गए! क्या आपके कोड को ऑनलाइन परीक्षण करने का एक तरीका है या अन्य पायथन 2 का उत्तर भी इसमें शामिल है?
1

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

अपडेट किया गया: अब मूल रूप से अन्य जवाब क्या कर रहे हैं का एक बंदरगाह।

f=(n,i=1)=>n&&`${n}`.length*n*i+f(n-1,i+1)

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

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

— Arnauld
स्रोत
1

मैथेमेटिका, 66 बाइट्स

Tr[1^(f=Flatten)[IntegerDigits/@f@(a=Array)[a[#~Table~#&,#]&,#]]]&
— J42161217
स्रोत
1

जाप , 12 11 10 9 बाइट्स

õõÈ*sÊÃxx

इसे आज़माएं या 1 से 150 तक सभी नंबरों का परीक्षण करें ।

व्याख्या

पूर्णांक का निहित इनपुट U।

õõ

1 से पूर्णांक की एक सरणी उत्पन्न करें Uऔर फिर 1 से प्रत्येक पूर्णांक तक उप-सरणियाँ बनाएं।

È   Ã

एक फ़ंक्शन के माध्यम से प्रत्येक उप-सरणी के तत्वों को पास करें।

*sÊ

वर्तमान तत्व को स्ट्रिंग में परिवर्तित करें ( s), लंबाई प्राप्त करें ( Ê) और इसे तत्व से गुणा करें।

xx

प्रत्येक उप-सरणी में समान करने के बाद मुख्य सरणी को घटाएं।

— झबरा
स्रोत
1

स्टैक किया गया , 28 बाइट्स

[~>[~>[:rep]"!]"!flat''#`#']

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

कुछ लोग पूछ सकते हैं, "किस बिंदु पर एलियंस अप्राप्य हैं?" यदि यह पास नहीं है, तो आपके पास "पठनीयता" की बहुत उदार परिभाषा है।

व्याख्या

[~>[~>[:rep]"!]"!flat''#`#']    input: N
 ~>[          ]"!               for each number K from 1 to N
    ~>[    ]"!                  for each number J from 1 to K
       :rep                     repeat J J times
                 flat           flatten the resultant array
                     ''#`       join by the empty string
                         #'     get the length of said string
— कोनोर ओ ब्रायन
स्रोत
1

सी # (.NET कोर) , 94 80 74 बाइट्स

n=>{int b=0,a=0,i;while(a++<n)for(i=0;i++<a;)b+=(i+"").Length*i;return b;}

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

मैं एक सीधा समाधान खोजने की उम्मीद कर रहा था जैसे कि क्या @ kamoroso94 का उत्तर शुरू हुआ, लेकिन मैंने इसे छोड़ दिया क्योंकि मैं इस पर बहुत अधिक समय बिता रहा था। शायद ऐसा करने का एक तरीका है, लेकिन सूत्र को हर परिमाण के कदम के लिए समायोजित करने की आवश्यकता है।

स्वीकृतियाँ

14 बाइट्स ने @someone को धन्यवाद दिया

6 बाइट्स ने @Kevin क्रूज़सेन को धन्यवाद दिया

— Ayb4btu
स्रोत
1
n=>{int b=0,a=0,i;for(;a++<n;)for(i=0;i++<a;)b+=i.ToString().Length*i;return b;} इसे ऑनलाइन आज़माएं! 80 बाइट्स और प्रदर्शन के लिए।
— मेरा सर्वनाम 10
1
i.ToString()(i+"")कुछ और बाइट्स बचाने के लिए हो सकता है।
— केविन क्रूज़सेन
1

MATL , 15 बाइट्स

:ttP*Y"10&YlQks

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

स्पष्टीकरण:

:                range 1:input (implicit input)
 tt              duplicate twice
   P             reverse
    *            multiply elementwise
     Y"          runlength decoding
       10&Yl     log10
            Qk   increment and floor
              s  sum (implicit output)
— ग्यूसेप
स्रोत
यह लघुगणक महंगा है :-) आप इसे स्ट्रिंग में परिवर्तित करके, रिक्त स्थान, लंबाई को हटाकर बदल सकते हैं::ttP*Y"VXzn
— लुइस मेंडो
1

पर्ल 6 , 36 बाइट्स

{[+] 1..*Z*($_...1).map:{.chars*$_}}

झसे आज़माओ

विस्तारित:

{  # bare block lambda with implicit parameter ｢$_｣

  [+]               # reduce the following using &infix:«+»

    1 .. *          # Range from 1 to infinity

    Z*              # zip using &infix:«*»

    ( $_ ... 1 )    # sequence from the input down to 1
    .map:           # for each one
    { .chars * $_ } # multiply the number of digits with itself
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
1

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

ＩΣＥ⊕ＮΣＥ⊕ι×λＬＩλ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: Sumमुझे बचाकर 4 बाइट्स का उपयोग करना । स्पष्टीकरण:

  Ｅ⊕Ｎ           Map from 0 to the input (loop variable i)
      Ｅ⊕ι       Map from 0 to i (loop variable l)
            Ｉλ  Cast l to string
           Ｌ    Take the length
         ×λ     Multiply by l
     Σ          Sum the results
 Σ              Sum the results
Ｉ               Cast to string
                Implicitly print
— नील
स्रोत
: | जब स्ट्रिंग तर्क दिए जाते हैं तो सम संख्याओं में योग होता है
— ASCII-only
@ ASCII- केवल यह नहीं था, यह सिर्फ एक प्रिंट कर रहा था Σ...
— नील
@ ASCII- केवल इसके अलावा, सबसे अच्छा मैं Sumअभी भी 18 बाइट्स कर सकता हूं :Print(Cast(Sum(Map(InclusiveRange(1, InputNumber()), Sum(Map(InclusiveRange(1, i), Times(l, Length(Cast(l)))))))));
— नील
— ASCII-only
@ ASCII- केवल मैंने उत्पाद की राशि की कोशिश की, लेकिन वह 17 बाइट्स थी ≔⊕ＮθＩΣＥθ×⁻θι×ιＬＩι:। हालाँकि, शेव के Incrementedबजाय InclusiveRange4 बाइट्स का उपयोग करना मेरी पिछली टिप्पणी है!
— नील
1

[डायलाग एपीएल], 22 20 बाइट्स

{+/≢¨⍕¨↑,/(/⍨¨⍳¨⍳⍵)}

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

स्पष्टीकरण:

{+/≢¨⍕¨↑,/(/⍨¨⍳¨⍳⍵)}
{                  } anonymous function with right argument named ⍵
                ⍳⍵   range 1 to right arg
              ⍳¨     for each, range 1 to it
             ¨       for each
           /⍨          for each item, repeat right arg left arg times
          (       )  take that and
        ,/           join the sub-arrays together
       ↑             convert from a nested array to a simple array (or something like that, I don't quite understand it :p)
     ⍕¨              convert each number to a char-array (aka string version)
   ≢¨                get length of each
 +/                  sum that together
— dzaima
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.