Дозвольте познайомити вас із номерами GAU

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

Цей виклик досить простий!

З огляду на ціле число n> 0, знайдіть кількість цифр GAU (n)

Приклад

Зробимо GAU (4),
зробимо наступні кроки (поки не дістанемося до 4) і з'єднаємо їх

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

ви повинні написати кожне число стільки разів, скільки його значення, але ви повинні рахувати кожен раз від 1

Спробуємо зробити GAU (5),
нам доведеться рахувати від 1 до 1

[1]   

потім від 1 до 2 (але повторення кожного числа стільки разів, скільки його значення )

[122]     

то від 1 до 3

[122333]   

то від 1 до 4

[1223334444]    

і нарешті від 1 до 5 (це останній крок, тому що ми хочемо знайти GAU ( 5 ))

[122333444455555]     

Тепер ми робимо всі ці кроки і об'єднуємо їх,
результат - GAU (5)

11221223331223334444122333444455555     

Нас цікавить кількість цифр цих чисел GAU.

Тестові кейси

Введення⟼Вихід

n   ⟼ Length(GAU(n))

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

Це проблема з кодовим гольфом .
Найкоротший код у байтах виграє.

Якщо у вас все ще є запитання, будь ласка, повідомте мене.
Я дуже хочу, щоб усі тут зрозуміли цю магічно-приховану складну картину

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

Haskell , 45 байт

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

Спробуйте в Інтернеті!

Мозок-Флак , 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

Лушпиння , 5 байт

ṁLΣQḣ

Спробуйте в Інтернеті!

Пояснення

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

Желе , 7 байт

Rx`ƤDFL

Спробуйте в Інтернеті!

05AB1E , 5 байт

LŒJJg

Спробуйте в Інтернеті!

Пояснення

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

Python 2 , 53 байти

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

Спробуйте в Інтернеті!

Лушпиння , 7 байт

Σ∫mS*Lḣ

Спробуйте в Інтернеті!

Безголів / пояснення

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

Лушпиння , 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

JavaScript (ES6), 57 55 байт

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

Спробуйте в Інтернеті!

Python 2 , 59 58 байт

Ще один байт пилу завдяки Джонатану Фреху.

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

Спробуйте в Інтернеті!

Не короткий, але так ... що за чорт.

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

Це здається важким, коли пояснюється лол.

J, 24 байти

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

Подібний високорівнева підхід до APL відповіді dzaima в перекладі на J, за виключення обчислює довжину цього числа, перетворюючи його в рядок першого замість того , щоб колоди, і ми отримуємо використовувати гак J, щоб помножити цю довжину на самому числі: (*#@":"0). Після цього це просто сума сканованої суми.

Спробуйте в Інтернеті!

R , 39 байт

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

Перевірте всі тестові випадки!

Простий алгоритм; Я спостерігав, як і більшість з них, що для iв 1:n, iповторюється i*(n-i+1)раз. Тому я створюю цей вектор, підраховую кількість символів у кожному і підсумовую їх.

Python 2, 51 50 байт

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

JavaScript (ES6), 50 42 байти

Оновлено: зараз в основному порт того, що роблять інші відповіді.

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

Тестові кейси

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

Математика, 66 байт

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

QBIC , 21 байт

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

Власне , 13 байт

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

Спробуйте в Інтернеті!

Пояснення:

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 байт

õõÈ*sÊÃxx

Спробуйте або протестуйте всі числа від 1 до 150 .

Пояснення

Неявне введення цілого числа U.

õõ

Створіть масив цілих чисел від 1 до, Uа потім генеруйте підмасиви від 1 до кожного цілого числа.

È   Ã

Передайте елементи кожного підмасиву через функцію.

*sÊ

Перетворіть поточний елемент у рядок ( s), отримайте його довжину ( Ê) та помножте його на елемент.

xx

Зменшіть основний масив додаванням після того, як спочатку зробите те саме для кожного підмасиву.

Jq 1,5 , 82 49 43 байт

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

Розширено

[   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

Виконання зразків

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

Спробуйте в Інтернеті! також jqplay.org

Складено , 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

Рубі , 41 40 байт

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

Спробуйте в Інтернеті!

C # (.NET Core) , 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 Cruijssen

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)

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

Вугілля , 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

Ом v2 , 7 байт

@@D×JJl

Спробуйте в Інтернеті!

[Діалог APL], 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

Рода , 31 байт

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

Спробуйте в Інтернеті!