Déjame presentarte los números GAU

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

¡Este desafío es bastante simple!

Dado un número entero n> 0, encuentre el número de dígitos de GAU (n)

Ejemplo

Hagamos GAU (4)
, tomamos los siguientes pasos (hasta llegar a 4) y los concatenamos

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

debe escribir cada número tantas veces como sea su valor, pero debe contar cada vez desde 1

Intentemos hacer GAU (5)
tendremos que contar del 1 al 1

[1]   

luego de 1 a 2 (pero repitiendo cada número tantas veces como su valor )

[122]     

luego de 1 a 3

[122333]   

luego de 1 a 4

[1223334444]    

y finalmente del 1 al 5 (este es el último paso porque queremos encontrar GAU ( 5 ))

[122333444455555]     

Ahora tomamos todos estos pasos y los concatenamos,
el resultado es GAU (5)

11221223331223334444122333444455555     

Estamos interesados ​​en la cantidad de dígitos de estos números GAU.

Casos de prueba

Entrada⟼Salida

n   ⟼ Length(GAU(n))

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

Este es un desafío de código de golf .
El código más corto en bytes ganará.

Si todavía tiene alguna pregunta, hágamelo saber.
Realmente quiero que todos aquí comprendan este patrón complejo mágicamente oculto

SOGL V0.12 , 11 10 8 7 5 bytes

∫∫l*+

Pruébalo aquí! - esto espera ser llamado como una función con la entrada en la pila y el cuadro de entrada vacío.
Alternativa de 7 bytes que toma la entrada del cuadro de entrada:

0.∫∫l*+

Pruébalo aquí!

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 bytes

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

Pruébalo en línea!

Brain-Flak , 166 bytes

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

Pruébalo en línea!

Explicación

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

Casco , 5 bytes

ṁLΣQḣ

Pruébalo en línea!

Explicación

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

Jalea , 7 bytes

Rx`ƤDFL

Pruébalo en línea!

05AB1E , 5 bytes

LŒJJg

Pruébalo en línea!

Explicación

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

Python 2 , 53 bytes

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

Pruébalo en línea!

Casco , 7 bytes

Σ∫mS*Lḣ

Pruébalo en línea!

Ungolfed / Explicación

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

Casco , 7 bytes

ṁLṁṘNḣḣ

Pruébalo en línea!

Explicació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

JavaScript (ES6), 57 55 bytes

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

Pruébalo en línea!

Python 2 , 59 58 bytes

Otro bytes el polvo gracias a Jonathan Frech.

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

Pruébalo en línea!

No es corto pero eh ... qué diablos.

CJam , 20 bytes

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

Pruébalo en línea!

El número se pasa en el campo "entrada".

Explicación no reflejada: (entrada de ejemplo = 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

Parece difícil cuando se explica lol.

J, 24 bytes

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

Enfoque de alto nivel similar a la respuesta APL de dzaima, traducido a J, excepto calculamos la longitud de la serie al convertirlo en una cadena primera vez de tomar registros, y se llega a utilizar el gancho de J para multiplicar esa longitud por el número en sí: (*#@":"0). Después de eso es solo la suma de la suma de escaneo.

Pruébalo en línea!

R , 39 bytes

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

¡Verifique todos los casos de prueba!

Algoritmo simple; Observé, como la mayoría lo hizo, que para iadentro 1:n, ise repite i*(n-i+1)veces. Entonces creo ese vector, cuento el número de caracteres en cada uno y los sumo.

Python 2, 51 50 bytes

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

JavaScript (ES6), 50 42 bytes

Actualizado: ahora es básicamente un puerto de lo que están haciendo otras respuestas.

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

Casos de prueba

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 bytes

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

QBIC , 21 bytes

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

En realidad , 13 bytes

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

Pruébalo en línea!

Explicación:

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 bytes

õõÈ*sÊÃxx

Pruébelo o pruebe todos los números del 1 al 150 .

Explicación

Entrada implícita de entero U.

õõ

Genere una matriz de enteros de 1 a Uy luego genere sub-matrices de 1 a cada entero.

È   Ã

Pase los elementos de cada subconjunto a través de una función.

*sÊ

Convierta el elemento actual en una cadena ( s), obtenga su longitud ( Ê) y multiplíquelo por el elemento.

xx

Reduzca la matriz principal mediante la adición después de hacer lo mismo con cada matriz secundaria.

Jq 1.5 , 82 49 43 bytes

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

Expandido

[   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

Ejecución de muestra

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

Pruébalo en línea! también jqplay.org

Apilado , 28 bytes

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

Pruébalo en línea!

Algunos podrían preguntar: "¿En qué punto son ilegibles los alias?" Si esto no está cerca, tiene una definición muy liberal de "legibilidad".

Explicación

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

Ruby , 41 40 bytes

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

Pruébalo en línea!

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

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

Pruébalo en línea!

Esperaba encontrar una solución directa como la respuesta de @ kamoroso94 , pero me di por vencido porque estaba pasando demasiado tiempo en ello. Probablemente haya una forma de hacerlo, pero la fórmula debe ajustarse para cada paso de magnitud.

Expresiones de gratitud

14 bytes guardados gracias a @someone

6 bytes guardados gracias a @Kevin Cruijssen

MATL , 15 bytes

:ttP*Y"10&YlQks

Pruébalo en línea!

Explicación:

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

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

Pruébalo

Expandido:

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

Carbón , 18 14 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: El uso Summe salvó 4 bytes. Explicación:

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

@@D×JJl

Pruébalo en línea!

[Dyalog APL], 22 20 bytes

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

Pruébalo en línea!

Explicación:

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

Pruébalo en línea!