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부터 세어야합니다.

우리가 1에서 1까지 세어야 할 GAU (5) 를 만들어 봅시다.

[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

하스켈 , 45 바이트

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

온라인으로 사용해보십시오!

Brain-Flak , 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

파이썬 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

자바 스크립트 (ES6), 57 55 바이트

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

온라인으로 사용해보십시오!

파이썬 2 , 59 58 바이트

Jonathan Frech 덕분에 또 하나의 먼지가 먼지입니다.

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

온라인으로 사용해보십시오!

짧지는 않지만 어 .. 도대체.

CJam , 20 바이트

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

온라인으로 사용해보십시오!

이 번호는 "입력"필드에 전달됩니다.

Ungolfed description : (예제 입력 = 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

lol 설명하면 힘들 것 같습니다.

J, 24 바이트

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

dzaima의 APL 답변에 대한 유사한 높은 수준의 접근 방식은 J로 변환됩니다. 단, 로그를 가져 오는 대신 문자열로 먼저 숫자를 돌려 숫자의 길이를 계산하고 J의 후크를 사용하여 해당 길이에 숫자 자체를 곱합니다 (*#@":"0). 그 후에는 스캔 합계의 합계입니다.

온라인으로 사용해보십시오!

R , 39 바이트

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

모든 테스트 사례를 확인하십시오!

간단한 알고리즘; 에서와 마찬가지로 iin 1:n에서 i반복되는 i*(n-i+1)횟수 가 관찰 되었습니다. 그래서 그 벡터를 만들고 각각의 문자 수를 세고 합산합니다.

파이썬 2, 51 50 바이트

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

자바 스크립트 (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에서 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 코어) , 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의 답변 과 같은 직접 솔루션을 찾고 싶었습니다. 시작된 있었지만 너무 많은 시간을 보내면서 포기했습니다. 아마도 그것을하는 방법이있을 수 있지만 수식은 모든 규모 단계에 맞게 조정해야합니다.

감사의 말

@someone 덕분에 14 바이트 절약

@Kevin Cruijssen 덕분에 6 바이트 절약

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)

펄 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 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 편집 : 사용하면 Sum4 바이트가 저장되었습니다. 설명:

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

온라인으로 사용해보십시오!

[Dyalog 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}

온라인으로 사용해보십시오!