Lascia che ti presenti i numeri GAU

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

Questa sfida è piuttosto semplice!

Dato un numero intero n> 0, trova il numero di cifre di GAU (n)

Esempio

Facciamo GAU (4),
seguiamo i seguenti passi (fino a quando arriviamo a 4) e li concateniamo

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

devi scrivere ogni numero quante volte il suo valore, ma devi contare ogni volta da 1

Proviamo a fare GAU (5)
dovremo contare da 1 a 1

[1]   

quindi da 1 a 2 (ma ripetendo ogni numero tante volte quanto il suo valore )

[122]     

quindi da 1 a 3

[122333]   

quindi da 1 a 4

[1223334444]    

e infine da 1 a 5 (questo è l' ultimo passo perché vogliamo trovare GAU ( 5 ))

[122333444455555]     

Ora prendiamo tutti questi passaggi e li concateniamo,
il risultato è GAU (5)

11221223331223334444122333444455555     

Siamo interessati al numero di cifre di questi numeri GAU.

Casi test

Input⟼Output

n   ⟼ Length(GAU(n))

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

Questa è una sfida di code-golf .
Vincerà il codice più breve in byte.

Se hai ancora domande, faccelo sapere.
Voglio davvero che tutti qui comprendano questo schema complesso e nascosto dalla magia

SOGL V0.12 , 11 10 8 7 5 byte

∫∫l*+

Provalo qui! - questo si aspetta di essere chiamato come una funzione con l'input nello stack e la casella di input vuota.
Alternativa a 7 byte prendendo l'input dalla casella di input:

0.∫∫l*+

Provalo qui!

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

Haskell , 45 byte

f n=sum[j*length(show j)|i<-[1..n],j<-[1..i]]

Provalo online!

Brain-Flak , 166 byte

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

Provalo online!

Spiegazione

<>(((()()())({}){})())<>           # 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

buccia , 5 byte

ṁLΣQḣ

Provalo online!

Spiegazione

ṁ  map over
 L  length
  Σ  sum list
   Q  all sublists
    ḣ  range 1 .. N

Gelatina , 7 byte

Rx`ƤDFL

Provalo online!

05AB1E , 5 byte

LŒJJg

Provalo online!

Spiegazione

L      # push [1 .. a]
 Π    # all substrings (a)
  J    # numbers to strings (inner)
   J   # numbers to strings (outer)
    g  # length

Python 2 , 53 byte

lambda x:sum(len(`i`)*i*(x-i+1)for i in range(1,x+1))

Provalo online!

Buccia , 7 byte

Σ∫mS*Lḣ

Provalo online!

Ungolfed / Spiegazione

         -- implicit input N                        | 10
  m   ḣ  -- map the following function over [1..N]  | [1,2,3,4]
   S*L   --   multiply length of number by itself   | [1,2,3,4] (only important for numbers ≥ 10)
 ∫       -- prefix sums                             | [0,1,3,6,10]
Σ        -- sum                                     | 20

Buccia , 7 byte

ṁLṁṘNḣḣ

Provalo online!

Spiegazione

          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

JavaScript (ES6), 57 55 byte

n=>[...Array(n)].reduce(x=>x+(++y+"").length*y*n--,y=0)

Provalo online!

Python 2 , 59 58 byte

Un altro bytes la polvere grazie a Jonathan Frech.

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

Provalo online!

Non breve ma eh ... che diamine.

CJam , 20 byte

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

Provalo online!

Il numero viene passato nel campo "input".

Spiegazione non golfata (esempio input = 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

Sembra difficile quando spiegato lol.

J, 24 byte

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

Approccio di alto livello simile alla risposta APL di dzaima, tradotto in J, tranne per il fatto che calcoliamo la lunghezza del numero trasformandolo prima in una stringa invece di prendere i log, e possiamo usare l'hook di J per moltiplicare quella lunghezza per il numero stesso: (*#@":"0) . Dopodiché è solo la somma della somma di scansione.

Provalo online!

R , 39 byte

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

Verifica tutti i casi di test!

Algoritmo semplice; Ho osservato, come molti altri, che per iin 1:n, isi ripetono i*(n-i+1)volte. Quindi creo quel vettore, conto il numero di caratteri in ciascuno e li somma.

Python 2, 51 50 byte

lambda n:sum(~k*(k-n)*len(`k+1`)for k in range(n))

JavaScript (ES6), 50 42 byte

Aggiornato: ora sostanzialmente una porta di ciò che stanno facendo le altre risposte.

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

Casi test

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

console.log(f(1))   // 1
console.log(f(2))   // 4
console.log(f(3))   // 10
console.log(f(10))  // 230
console.log(f(50))  // 42190
console.log(f(100)) // 339240
console.log(f(150)) // 1295790

Mathematica, 66 byte

Tr[1^(f=Flatten)[IntegerDigits/@f@(a=Array)[a[#~Table~#&,#]&,#]]]&

QBIC , 21 byte

[:|[a|[c|A=A+!c$}?_lA

In realtà , 13 byte

R♂R♂i⌠;n⌡Mεjl

Provalo online!

Spiegazione:

R♂R♂i⌠;n⌡Mεjl
R              range(1, n+1)
 ♂R            range(1, x+1) for x in previous
   ♂i          flatten into 1D list
     ⌠;n⌡M     for x in list:
      ;n       repeat x x times
          εj   concatenate to string
            l  length

Japt , 12 11 10 9 byte

õõÈ*sÊÃxx

Provalo o prova tutti i numeri da 1 a 150 .

Spiegazione

Input implicito di numero intero U.

õõ

Generare un array di numeri interi da 1 a, Uquindi generare sotto-array da 1 a ciascun numero intero.

È   Ã

Passa gli elementi di ciascun sotto-array attraverso una funzione.

*sÊ

Converti l'elemento corrente in una stringa ( s), ottieni la sua lunghezza ( Ê) e moltiplicalo per l'elemento.

xx

Ridurre l'array principale mediante l'aggiunta dopo aver fatto lo stesso per ciascun sub-array.

Jq 1,5 , 82 49 43 byte

[range(.)+1|range(.)+1|"\(.)"*.|length]|add

allargato

[   range(.)+1        # for i=1 to N
  | range(.)+1        # for j=1 to i
  | "\(.)"*.          # "j" copied j times
  | length            # convert to length
] | add               # add lengths

Esecuzione del campione

$ jq -Mr '[range(.)+1|range(.)+1|"\(.)"*.|length]|add' <<< "150"
1295790

Provalo online! anche jqplay.org

Impilato , 28 byte

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

Provalo online!

Alcuni potrebbero chiedere: "A che punto gli alias sono illeggibili?" Se questo non è vicino, hai una definizione molto liberale di "leggibilità".

Spiegazione

[~>[~>[: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

Rubino , 41 40 byte

->n{(1..n).map{|x|[x]*x*=-x-~n}*''=~/$/}

Provalo online!

C # (.NET Core) , 94 80 74 byte

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

Provalo online!

Speravo di trovare una soluzione diretta come la risposta di @ kamoroso94 , ma ho rinunciato perché ci troppo tempo. Probabilmente esiste un modo per farlo, ma la formula deve essere regolata per ogni passo di grandezza.

Ringraziamenti

14 byte salvati grazie a @someone

6 byte salvati grazie a @Kevin Cruijssen

MATL , 15 byte

:ttP*Y"10&YlQks

Provalo online!

Spiegazione:

:                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)

Perl 6 , 36 byte

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

Provalo

Allargato:

{  # 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
}

Carbone , 18 14 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Modifica: usando Summe salvato 4 byte. Spiegazione:

  Ｅ⊕Ｎ           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

Ohm v2 , 7 byte

@@D×JJl

Provalo online!

[Dyalog APL], 22 20 byte

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

Provalo online!

Spiegazione:

{+/≢¨⍕¨↑,/(/⍨¨⍳¨⍳⍵)}
{                  } 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

Röda, 31 bytes

{f={seq 1,_}f|f|[#`$_`*_1]|sum}

Try it online!