Ninguém sabe números do GAU

22

Deixe-me apresentar-lhe os números do GAU

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

Esse desafio é bem simples!

Dado um número inteiro n> 0, encontre o número de dígitos de GAU (n)

Exemplo

Vamos fazer o GAU (4)
, seguir as etapas a seguir (até chegarmos ao 4) e concatená-las 

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

você deve escrever cada número quantas vezes for seu valor, mas deve contar todas as vezes de 1

Vamos tentar criar o GAU (5)
, teremos que contar de 1 a 1

[1]

de 1 a 2 (mas repetindo cada número quantas vezes for seu valor ) 

[122]

então de 1 a 3 

[122333]

então de 1 a 4 

[1223334444]

e finalmente de 1 a 5 (este é o último passo, porque queremos encontrar o GAU ( 5 )) 

[122333444455555]

Agora, seguimos todas essas etapas e as concatenamos,
o resultado é GAU (5) 

11221223331223334444122333444455555

Estamos interessados ​​no número de dígitos desses números GAU.

Casos de teste

Input⟼Output 

n   ⟼ Length(GAU(n))

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

Este é um desafio do código-golfe .
O código mais curto em bytes vencerá.

Se você ainda tiver alguma dúvida, entre em contato.
Eu realmente quero que todos aqui entendam esse padrão de complexo oculto mágico

code-golf  sequence 
4
GAU de quê?
— gotejante Nun
21
G é para o GAU, A e U estão lá apenas para nenhuma razão
2
Até n = 9, os comprimentos são números tetraédricos, mas para além disso os números de dígitos múltiplos ficar no caminho de uma forma fechada simples
— Miff
Para sua informação, seu caso de teste diz n ⟼ Length(GUA(n)), não GAU (n).
— Numbermaniac #
2
@numbermaniac obrigado por detectar isso. Os números da GUA são totalmente diferentes. Eles ainda não foram inventados!

Respostas:

14

SOGL V0.12 , 11 10 8 7 5 bytes

∫∫l*+

Experimente aqui! - espera ser chamado como uma função com a entrada na pilha e a caixa de entrada vazia.
Alternativa de 7 bytes, tomando a entrada da caixa de entrada:

0.∫∫l*+

Experimente aqui!

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
fonte
push that numbers length without popping the numberagradável
— Erik o Outgolfer
7

Flacidez Cerebral , 166 bytes

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

Experimente online!

Explicação

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

Casca , 7 bytes

Σ∫mS*Lḣ

Experimente online!

Ungolfed / Explicação

         -- 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
— ბიმო
fonte
3

Casca , 7 bytes

ṁLṁṘNḣḣ

Experimente online!

Explicação

          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
fonte
Ah, outra solução Husk :) Não vi sua submissão ao publicar a minha, o mesmo número anterior, mas são suficientemente diferentes, então deixarei a minha aqui também.
— ბიმო
3

CJam , 20 bytes

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

Experimente online!

O número é passado no campo "entrada".

Explicação ungolfed: (exemplo 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

Parece difícil quando explicado lol.

— Iaka Noe
fonte
2

J, 24 bytes

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

Abordagem de alto nível semelhante à resposta APL do dzaima, traduzida em J, exceto que calculamos o comprimento do número, transformando-o em uma string primeiro em vez de obter logs, e usamos o gancho de J para multiplicar esse comprimento pelo próprio número: (*#@":"0) . Depois disso, é apenas a soma da soma da varredura.

Experimente online!

— Jonah
fonte
1
1(#.]*#\*#\.)1#@":@+i.também funciona para 22 bytes
— milhas
@miles Isso é inteligente - demorei um pouco para descobrir. Há quanto tempo programa em J?
— Jonah
Um pouco depois que entrei no code-golf. Na verdade, eu não o uso para escrever programas reais, pois não, eu sei que seria capaz de lê-lo, mas eu o uso como uma calculadora de mesa avançada agora, e geralmente sempre tenho uma janela aberta para calcular alguma coisa.
— milhas
2

R , 39 bytes

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

Verifique todos os casos de teste!

Algoritmo simples; Eu observei, como a maioria, que por iin 1:n, ié repetida i*(n-i+1)vezes. Então, eu crio esse vetor, conto o número de caracteres em cada um e os soma.

— Giuseppe
fonte
1

Python 2, 51 50 bytes

lambda n:sum(~k*(k-n)*len(`k+1`)for k in range(n))
— orlp
fonte
@LeakyNun Why? Eu mesmo desenvolvi essa resposta. Eu nem chequei as outras respostas.
— orlp
1
Isto nem sequer saída da resposta à direita, dá 0 para n = 1, 3 para n = 2 e 14 para n = 3
— Halvard Hummel
@HalvardHummel Ops, estragou um sinal e esqueceu um +1. Corrigido agora.
— orlp
Vejo que você finalmente entendeu o padrão! Existe uma maneira de testar seu código on-line ou a outra resposta do Python 2 também cobre isso?
1

JavaScript (ES6), 50 42 bytes

Atualizado: agora basicamente uma porta do que outras respostas estão fazendo.

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

Casos de teste

Mostrar snippet de código

— Arnauld
fonte
1

Mathematica, 66 bytes

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

Na verdade , 13 bytes

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

Experimente online!

Explicação:

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
— Mego
fonte
1

Japonês , 12 11 10 9 bytes

õõÈ*sÊÃxx

Experimente ou teste todos os números de 1 a 150 .

Explicação

Entrada implícita de número inteiro U.

õõ

Gere uma matriz de números inteiros de 1 a Ue, em seguida, gere sub-matrizes de 1 a cada número inteiro.

È   Ã

Passe os elementos de cada sub-matriz através de uma função.

*sÊ

Converta o elemento atual em uma string ( s), obtenha o comprimento ( Ê) e multiplique pelo elemento.

xx

Reduza a matriz principal adicionando depois de fazer o mesmo com cada sub-matriz.

— Shaggy
fonte
1

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

Execução de amostra

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

Experimente online! também jqplay.org

— jq170727
fonte
1

Empilhados , 28 bytes

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

Experimente online!

Alguns podem perguntar: "Em que ponto os apelidos são ilegíveis?" Se isso não estiver próximo, você tem uma definição muito liberal de "legibilidade".

Explicação

[~>[~>[: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
— Conor O'Brien
fonte
1

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

Experimente online!

Eu esperava encontrar uma solução direta, como a resposta de @ kamoroso94 , mas desisti, pois estava gastando muito tempo com isso. Provavelmente existe uma maneira de fazer isso, mas a fórmula precisa se ajustar a cada passo de magnitude.

Agradecimentos

14 bytes salvos graças a @someone

6 bytes salvos graças a @Kevin Cruijssen

— Ayb4btu
fonte
1
n=>{int b=0,a=0,i;for(;a++<n;)for(i=0;i++<a;)b+=i.ToString().Length*i;return b;} Experimente online! para 80 bytes e desempenho.
— meu pronome é monicareinstate
1
i.ToString()pode ser (i+"")para salvar mais alguns bytes.
— Kevin Cruijssen
1

MATL , 15 bytes

:ttP*Y"10&YlQks

Experimente online!

Explicação:

:                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)
— Giuseppe
fonte
Esse logaritmo é caro :-) Você pode substituí-lo convertendo-o em string, removendo espaços, comprimento::ttP*Y"VXzn
— Luis Mendo
1

Perl 6 , 36 bytes

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

Teste-o

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
}
— Brad Gilbert b2gills
fonte
1

Carvão , 18 14 bytes

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

Experimente online! Link é a versão detalhada do código. Edit: Usando Summe salvou 4 bytes. Explicação:

  Ｅ⊕Ｎ           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
— Neil
fonte
: | Soma soma números nas cadeias quando dados argumentos de cadeia
— somente ASCII
@ ASCII-only Não era isso, estava apenas imprimindo um Σ...
— Neil
@ Somente ASCII Além disso, o melhor que posso fazer Sumainda tem 18 bytes:Print(Cast(Sum(Map(InclusiveRange(1, InputNumber()), Sum(Map(InclusiveRange(1, i), Times(l, Length(Cast(l)))))))));
— Neil
— somente ASCII
@ ASCII-only Tentei soma de produto, mas que tinha 17 bytes: ≔⊕ＮθＩΣＥθ×⁻θι×ιＬＩι. No entanto, usar em Incrementedvez de InclusiveRangeraspar 4 bytes do meu comentário anterior!
— Neil
1

[Dyalog APL], 22 20 bytes

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

Experimente online!

Explicação:

{+/≢¨⍕¨↑,/(/⍨¨⍳¨⍳⍵)}
{                  } 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
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.