Estamos acostumados ao termo "quadrado" n para significar o cálculo de n ² . Também estamos acostumados ao termo "cubing" n para significar n ³ . Dito isto, por que não podemos também triangular um número?

Como triângulo um número?

• Primeiro, vamos escolher um número 53716.

• Posicione-o em um paralelogramo, cujo comprimento lateral seja igual ao número de dígitos do número e tenha dois lados posicionados na diagonal, conforme mostrado abaixo.

      53716
     53716
    53716
   53716
  53716
  

• Agora, nós queremos, certo? Para fazer isso, corte os lados que não se encaixam em um triângulo retângulo:

      5
     53
    537
   5371
  53716
  

• Pegue as somas de cada linha, para este exemplo, resultando em [5, 8, 15, 16, 22]:

      5 -> 5
     53 -> 8
    537 -> 15
   5371 -> 16
  53716 -> 22
  

• Soma a lista [5, 8, 15, 16, 22], resultando em 66. Este é o triângulo deste número!

Especificações e regras

• A entrada será um número inteiro não negativo n ( n ≥ 0, n ∈ Z ).

• Você pode receber e fornecer saída por qualquer meio permitido .

• A entrada pode ser formatada como um número inteiro, uma representação em seqüência do número inteiro ou uma lista de dígitos.

• Lacunas padrão não permitidas.

• Isso é código-golfe , então o código mais curto em bytes vence!

Mais casos de teste

Entrada -> Saída

0 -> 0
1 -> 1
12 -> 4
123 -> 10
999 -> 54 
100000 -> 6
654321 -> 91

Inspiração. As explicações são incentivadas!

Haskell , 13 bytes

sum.scanl1(+)

Experimente online!

Recebe a entrada como lista de dígitos. Calcula as somas acumuladas e depois as soma.

Husk , 4 2 bytes

Obrigado @ H.PWiz por -2bytes!

Σ∫

Experimente online!

"Ungolfed" / Explained

Σ    -- sum all
 ∫   -- prefix sums

Flacidez cerebral , 65, 50, 36 bytes

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

Experimente online!

Depois de muita revisão, agora estou muito orgulhoso dessa resposta. Eu gosto do algoritmo, e quão bem ele pode ser expresso no cérebro.

A maior parte da contagem de bytes vem do tratamento de 0 na entrada. De fato, se pudéssemos assumir que não havia zeros na entrada, seria uma resposta belamente curta de 20 bytes:

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

Experimente online!

Infelizmente, porém, o cérebro é notório pelo mau manuseio de casos extremos.

Explicação

Primeiro, uma observação minha:

Se a entrada tiver n dígitos, o primeiro dígito aparecerá no triângulo n vezes, o segundo dígito aparecerá n-1 vezes e assim por diante no último dígito, que aparecerá uma vez. Podemos tirar proveito disso, pois é realmente fácil calcular quantos dígitos de entrada restam no cérebro,

[]

Então, aqui está como o código funciona.

# Push the size of the input (to account for 0's)
([])

# Push...
(

    # While True
    {

        # Pop the stack height (evaluates to 0)
        <{}>

        # For each digit *D*...

        # While true
        {

            # Decrement the counter (the current digit we're evaluating), 
            # but evaluate to 0
            <({}[()])>

            # Evaluate the number of digits left in the input
            []

        # Endwhile
        }

        # This whole block evaluates to D * len(remaining_digits), but 
        # without affecting the stack

        # Since we looped D times, D is now 0 and there is one less digit.
        # Pop D (now 0)
        {}

        # Push the stack height (again, evaluating it as 0)
        <([])>

    # End while
    }

    # Pop a 0 off (handles edge case of 0)
    {}

# end push
)

Pitão - 6 4 bytes

ss._

Experimente online aqui .

Bom 6 bytes que não usa o prefixo incorporado:

s*V_Sl

MATL , 3 bytes

Yss

Experimente online!

Toma a entrada como uma lista de dígitos.

Gelatina , 3 bytes

+\S

Experimente online! Utiliza a mesma técnica da minha resposta em japonês: adição cumulativa e soma.

Haskell , 25 bytes

Recebe entrada como lista de dígitos

f[]=0
f x=sum x+f(init x)

Experimente online!

Haskell , 41 bytes

Recebe entrada como representação de sequência

f[]=0
f x=sum(map(read.(:[]))x)+f(init x)

Experimente online!

Japonês , 7 6 4 bytes

å+ x

Experimente online!

Explicação

å+ x    Implicit: input = digit list
å+      Cumulative reduce by addition. Gives the sum of each prefix.
   x    Sum.

Solução antiga:

å+ ¬¬x

Experimente online!

Explicação

å+ ¬¬x   Implicit: input = string
å+       Cumulative reduce by concatenation. Gives the list of prefixes.
   ¬     Join into a single string of digits.
    ¬    Split back into digits.
     x   Sum.
         Implicit: output result of last expression

Brain-Flak , 28 bytes

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

Experimente online!

14 bytes se não precisarmos suportar zeros (o que fazemos)

({({}<>{})<>})

Experimente online!

DJMcMayhem tem uma resposta legal aqui, você deve conferir. Infelizmente para ele não estava disposto a deixá-lo vencer em seu próprio idioma: P

Como funciona?

Vamos começar com a versão simples.

({({}<>{})<>})

A ação principal aqui é ({}<>{})<>, que pega o topo da pilha esquerda e adiciona ao topo da pilha direita. Ao fazer o loop desta operação, somamos a pilha atual (até atingir zero) colocando a soma na pilha desativada. Isso é bastante mundano, a parte interessante é que resumimos os resultados de todas essas execuções como resultado. Isso calculará o valor desejado. Por quê? Bem, vamos dar uma olhada em um exemplo 123,. Na primeira tentativa, obtemos apenas 1, então nosso valor é 1

1

Na próxima captura, retornamos 1 mais 2

1
1+2

Na última corrida, temos todos os três juntos

1
1+2
1+2+3

Você vê o triângulo? A soma de todas as execuções é o "triângulo" da lista.

Ok, mas agora precisamos trabalhar com zeros, aqui eu usei o mesmo truque do DJMcMayhem, além de alguns truques de pés. Em vez de fazer um loop até atingirmos um zero, fazemos um loop até que a pilha esteja vazia.

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

Eu então usei essa dica , escrita por ninguém menos que a sua, para jogar fora outros 2 bytes.

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

E aí temos que. Eu ficaria surpreso se houvesse uma solução mais curta, mas, novamente, coisas mais estranhas aconteceram.

JavaScript (ES6), 28 bytes

a=>a.map(d=>t+=c+=d,t=c=0)|t

Recebe a entrada como uma lista de dígitos.

Python 3 , 37 bytes

f=lambda n:len(n)and sum(n)+f(n[:-1])

Experimente online!

C # (.NET Core) , 59 bytes

using System.Linq;N=>N.Reverse().Select((d,i)=>i*d+d).Sum()

Experimente online!

Substancialmente diferente das outras respostas C #. Entrada é uma lista de dígitos. Todos os casos de teste incluídos no link do TIO.

Pode salvar um monte de bytes se for permitido receber a entrada como uma lista de dígitos para trás com 0 inicial.

Python 3 , 35 bytes

Acabei de notar que, no final, isso é apenas um pouco da resposta da Business Cat !

f=lambda a:a>[]and sum(a)+f(a[:-1])

Experimente online!

J , 7 bytes

[:+/+/\

Experimente online! Leva uma lista de dígitos, como f 6 5 4 3 2 1.

Explicação

[:+/+/\    (for explanation, input = 6 5 4 3 2 1)
      \    over the prefixes of the input:
     /         reduce:
    +              addition (summation)
           this gives is the cumulative sum of the input:  6 11 15 18 20 21
[:         apply to the result:
  +/           summation
           this gives the desired result:   90

Um pouco mais fiel ao problema original seria [:+/@,]/"sum" ( +/) os ,prefixos achatados ( ) da entrada ( ]\).

Vim , 60 59 32 pressionamentos de tecla

Muito obrigado ao @CowsQuack pela dica com a macro recursiva e o htruque, isso me salvou 27 bytes!

qqYp$xh@qq@qVHJ:s/./&+/g⏎
C<C-r>=<C-r>"0⏎

Experimente online!

Ungolfed / Explained

Isso criará o triângulo como descrito (apenas para mantê-lo alinhado à esquerda):

qq       q    " record the macro q:
  Yp          "   duplicate the line
    $x        "   remove last character
      h       "   move to the left (this is solely that the recursive macro calls stop)
       @q     "   run the macro recursively
          @q  " run the macro

O buffer está agora assim:

53716
5371
537
53
5

Junte todas as linhas em uma e construa uma expressão avaliável a partir dela:

VH             " mark everything
  J            " join into one line
   :s/./&+/g⏎  " insert a + between all the characters

o " registro agora contém a seguinte string (observe falta 0):

5+3+7+1+6+ +5+3+7+1+ +5+3+7+ +5+3+ +5+ +

Então, tudo o que precisamos fazer é acrescentar um zero e avaliá-lo:

 C                " delete line and store in " register
  <C-r>=       ⏎  " insert the evaluated expression from
        <C-r>"    " register "
              0   " append the missing 0

Python 2 , 49 45 bytes

-4 bytes graças ao Sr. Xcoder.

lambda n:sum(-~i*n[~i]for i in range(len(n)))

Experimente online!

Recebe a entrada como uma lista de dígitos.

Utilitários Bash + GNU, 32 24

tac|nl -s*|paste -sd+|bc

Entrada lida de STDIN.

Atualização: Vejo que a entrada pode ser fornecida como uma lista de dígitos. Minha lista de entrada é delimitada por nova linha.

Experimente online .

Explicação

tac                       # reverse digit list
   |nl -s*                # prefix line numbers; separate with "*" operator
          |paste -sd+     # join lines onto one line, separated with "+" operator
                     |bc  # arithmetically evaluate

APL, 4 bytes

+/+\

Isso leva a entrada como uma lista de dígitos, por exemplo:

      (+/+\) 5 3 7 1 6
66

Explicação

+/    sum of
  +\  partial sums of input

Táxi , 1478 bytes

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Chop Suey.Go to Chop Suey:n 1 r 1 l 4 r 1 l.[a]Switch to plan "b" if no one is waiting.Pickup a passenger going to The Babelfishery.Go to Zoom Zoom:n 1 l 3 r.1 is waiting at Starchild Numerology.Go to Starchild Numerology:w 4 l 2 r.Pickup a passenger going to Addition Alley.Go to Addition Alley:w 1 r 3 r 1 r 1 r.Pickup a passenger going to Addition Alley.Go to The Babelfishery:n 1 r 1 r.Go to Chop Suey:n 6 r 1 l.Switch to plan "a".[b]Go to Addition Alley:n 1 l 2 l.Pickup a passenger going to Cyclone.[c]Go to Zoom Zoom:n 1 l 1 r.Go to Cyclone:w.Pickup a passenger going to The Underground.Pickup a passenger going to Multiplication Station.Go to The Babelfishery:s 1 l 2 r 1 r.Pickup a passenger going to Multiplication Station.Go to Multiplication Station:n 1 r 2 l.Pickup a passenger going to Addition Alley.Go to The Underground:n 2 l 1 r.Switch to plan "d" if no one is waiting.Pickup a passenger going to Cyclone.Go to Addition Alley:n 3 l 1 l.Switch to plan "c".[d]Go to Addition Alley:n 3 l 1 l.[e]Pickup a passenger going to Addition Alley.Go to Zoom Zoom:n 1 l 1 r.Go to Addition Alley:w 1 l 1 r.Pickup a passenger going to Addition Alley.Switch to plan "f" if no one is waiting.Switch to plan "e".[f]Go to Zoom Zoom:n 1 l 1 r.Go to Addition Alley:w 1 l 1 r.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:n 1 r 1 r.Pickup a passenger going to Post Office.Go to Post Office:n 1 l 1 r.

Experimente online!

Sem golfe:

[ Pickup stdin and split into digits ]
Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to Chop Suey.
Go to Chop Suey: north 1st right 1st left 4th right 1st left.
[a]
[ Count the digits ]
Switch to plan "b" if no one is waiting.
Pickup a passenger going to The Babelfishery.
Go to Zoom Zoom: north 1st left 3rd right.
1 is waiting at Starchild Numerology.
Go to Starchild Numerology: west 4th left 2nd right.
Pickup a passenger going to Addition Alley.
Go to Addition Alley: west 1st right 3rd right 1st right 1st right.
Pickup a passenger going to Addition Alley.
Go to The Babelfishery: north 1st right 1st right.
Go to Chop Suey: north 6th right 1st left.
Switch to plan "a".
[b]
Go to Addition Alley: north 1st left 2nd left.
Pickup a passenger going to Cyclone.
[c]
[ Multiply each digits by Len(stdin)-Position(digit) ]
Go to Zoom Zoom: north 1st left 1st right.
Go to Cyclone: west.
Pickup a passenger going to The Underground.
Pickup a passenger going to Multiplication Station.
Go to The Babelfishery: south 1st left 2nd right 1st right.
Pickup a passenger going to Multiplication Station.
Go to Multiplication Station: north 1st right 2nd left.
Pickup a passenger going to Addition Alley.
Go to The Underground: north 2nd left 1st right.
Switch to plan "d" if no one is waiting.
Pickup a passenger going to Cyclone.
Go to Addition Alley: north 3rd left 1st left.
Switch to plan "c".
[d]
Go to Addition Alley: north 3rd left 1st left.
[e]
[ Sum all the products ]
Pickup a passenger going to Addition Alley.
Go to Zoom Zoom: north 1st left 1st right.
Go to Addition Alley: west 1st left 1st right.
Pickup a passenger going to Addition Alley.
Switch to plan "f" if no one is waiting.
Switch to plan "e".
[f]
[ Output the results ]
Go to Zoom Zoom: north 1st left 1st right.
Go to Addition Alley: west 1st left 1st right.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: north 1st right 1st right.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st left 1st right.

Perl 5 , 19 + 1 ( -p) = 20 bytes

s/./$\+=$p+=$&/ge}{

Experimente online!

Quão?

$ \ mantém o total acumulado, $ p mantém o total de dígitos na linha atual. Cada linha do paralelogramo é simplesmente a linha anterior com o próximo dígito do número anexado. Portanto, é a soma da linha anterior mais o novo dígito. Isso itera sobre todos os dígitos, calculando as somas à medida que avançam. A substituição real é irrelevante; é apenas um meio de iterar sobre os dígitos sem criar um loop real. No final, $ \ é impresso implicitamente pela -popção.

Python 2 , 56 bytes

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

Experimente online!

Geléia ,  5  4 bytes

Ṛæ.J

Um link monádico que obtém uma lista de dígitos decimais e retorna o triângulo do número que a lista representa.

Experimente online!

Quão?

Ṛæ.J - Link: list of numbers (the decimal digits), d   e.g. [9,4,5,0]
Ṛ    - reverse d                                            [0,5,4,9]
   J - range(length(d))                                     [1,2,3,4]
 æ.  - dot-product            (0*1 + 5*2 + 4*3 + 9*4 = 58)  58

Retina , 13 bytes

.
$`$&
.
$*
1

Experimente online! O link inclui casos de teste. Explicação: O primeiro estágio gera todos os prefixos do número original, o segundo estágio converte cada dígito em unário e o terceiro estágio obtém o total.

Mathematica, 49 bytes

Tr@Array[Tr@s[[;;#]]&,Length[s=IntegerDigits@#]]&

Neim , 3 bytes

𝐗𝐂𝐬

Explicação:

𝐗        Get prefixes of input, including itself
 𝐂       Implicitly join elements together, and create an array with all the digits
  𝐬      Sum

Experimente online!

Resposta alternativa:

𝐗𝐣𝐬

Explicação:

𝐗       Get prefixes of input, including itself
 𝐣       Join
  𝐬      Implicitly convert to a digit array, and sum

Experimente online!

Java 8, 53 bytes

Eu implementei um lambda para cada tipo de entrada aceitável. Cada um deles percorre os dígitos do número, adicionando o múltiplo adequado de cada um a um acumulador.

Inteiro como entrada (53 bytes)

Lambda de Integeraté Integer:

n->{int s=0,i=1;for(;n>0;n/=10)s+=n%10*i++;return s;}

Representação de string como entrada (72 bytes)

Lambda de Stringaté Integer:

s->{int l=s.length(),n=0;for(int b:s.getBytes())n+=(b-48)*l--;return n;}

Matriz de dígitos como entrada (54 bytes)

Lambda de int[](de dígitos, maior valor do local primeiro) a Integer:

a->{int l=a.length,s=0;for(int n:a)s+=n*l--;return s;}

• -7 bytes graças a Olivier Grégoire

Pyt , 9 6 bytes

ąĐŁř↔·

Explicação:

                 Implicit input
ą                Convert to array of digits
 Đ               Duplicate digit array
   Łř↔           Create a new array [len(array),len(array)-1,...,1]
      ·          Dot product with digit array
                 Implicit output

Python 3, 94 58 54 bytes

Agradeço ao Sr. Xcoder por me ajudar a economizar alguns bytes!

lambda n:sum(int(v)*(len(n)-i)for i,v in enumerate(n))

Experimente Online!

Recebe a entrada como uma sequência. Simplesmente multiplica cada dígito pelo número de vezes que precisa ser adicionado e retorna sua soma.

SNOBOL4 (CSNOBOL4) , 79 bytes

	N =INPUT
D	N LEN(1) . D REM . N	:F(O)
	X =X + D
	Y =Y + X	:(D)
O	OUTPUT =Y
END

Experimente online!

Entrada de stdin, saída para stdout.

Lisp comum, 53 52 bytes

(loop as(x . y)on(reverse(read))sum(+(reduce'+ y)x))

Insira como lista de dígitos.

Experimente online!

-1 byte graças a @ceilingcat.