Estamos acostumbrados al término "cuadrar" n para significar calcular n ² . También estamos acostumbrados al término "cubicación" n que significa n ³ . Dicho esto, ¿por qué no podríamos también triangular un número?

¿Cómo hacer un triángulo con un número?

• En primer lugar, escojamos un número 53716,.

• Colóquelo en un paralelogramo, cuya longitud lateral sea igual al número de dígitos del número, y tenga dos lados colocados en diagonal, como se muestra a continuación.

      53716
     53716
    53716
   53716
  53716
  

• Ahora, queremos ∆ eso, ¿verdad? Para hacerlo, recorte los lados que no encajan en un triángulo rectángulo:

      5 5
     53
    537
   5371
  53716
  

• Tome las sumas de cada fila, para este ejemplo resulta en [5, 8, 15, 16, 22]:

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

• Suma la lista [5, 8, 15, 16, 22], resultando en 66. Este es el triángulo de este número!

Especificaciones y Reglas

• La entrada será un número entero no negativo n ( n ≥ 0, n ∈ Z ).

• Puede tomar entrada y proporcionar salida por cualquier medio permitido .

• La entrada puede formatearse como un entero, una representación de cadena del entero o una lista de dígitos.

• Lagunas predeterminadas no permitidas.

• Este es el código de golf , por lo que gana el código más corto en bytes.

Más casos de prueba

Entrada -> Salida

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

Inspiración. ¡Se alientan las explicaciones!

Haskell , 13 bytes

sum.scanl1(+)

Pruébalo en línea!

Toma la entrada como una lista de dígitos. Calcula las sumas acumulativas y luego las suma.

De cáscara , 4 2 bytes

Gracias @ H.PWiz por -2bytes!

Σ∫

Pruébalo en línea!

"Ungolfed" / Explicado

Σ    -- sum all
 ∫   -- prefix sums

Brain-Flak , 65, 50, 36 bytes

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

Pruébalo en línea!

Después de muchas revisiones, ahora estoy muy orgulloso de esta respuesta. Me gusta el algoritmo y lo bien que se puede expresar en cerebro-flak.

La mayor parte del recuento de bytes proviene del manejo de 0 en la entrada. De hecho, si pudiéramos suponer que no hubo 0 en la entrada, sería una respuesta maravillosamente corta de 20 bytes:

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

Pruébalo en línea!

Pero desafortunadamente, el ataque cerebral es notorio por el mal manejo de los casos extremos.

Explicación

Primero, una observación mía:

Si la entrada tiene n dígitos, el primer dígito aparecerá en el triángulo n veces, el segundo dígito aparecerá n-1 veces, y así sucesivamente en el último dígito, que aparecerá una vez. Podemos aprovechar esto, ya que es realmente fácil calcular cuántos dígitos de entrada quedan en el cerebro-flak, a saber

[]

Así es como funciona el código.

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

Pyth - 6 4 bytes

ss._

Pruébelo en línea aquí .

Bonito 6 byte uno que no usa prefijo incorporado:

s*V_Sl

MATL , 3 bytes

Yss

Pruébalo en línea!

Toma la entrada como una lista de dígitos.

Jalea , 3 bytes

+\S

Pruébalo en línea! Utiliza la misma técnica que mi respuesta de Japt: suma acumulativa, luego suma.

Haskell , 25 bytes

Toma entrada como lista de dígitos

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

Pruébalo en línea!

Haskell , 41 bytes

Toma entrada como representación de cadena

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

Pruébalo en línea!

Japt , 7 6 4 bytes

å+ x

Pruébalo en línea!

Explicación

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

Vieja solución:

å+ ¬¬x

Pruébalo en línea!

Explicación

å+ ¬¬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

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

Pruébalo en línea!

14 bytes si no necesitamos admitir ceros (lo que hacemos)

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

Pruébalo en línea!

DJMcMayhem tiene una respuesta genial aquí que deberías consultar. Desafortunadamente para él, no estaba dispuesto a dejarlo ganar en su propio idioma: P

¿Como funciona?

Comencemos con la versión simple.

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

La acción principal aquí es ({}<>{})<>, que toma la parte superior de la pila izquierda y se agrega a la parte superior de la pila derecha. Al repetir esta operación, resumimos la pila actual (hasta que llega a cero) colocando la suma en la pila desactivada. Eso es bastante mundano, lo interesante es que resumimos los resultados de todas estas ejecuciones como nuestro resultado. Esto calculará el valor deseado. ¿Por qué? Bueno, echemos un vistazo a un ejemplo 123,. En la primera toma, solo obtenemos 1, por lo que nuestro valor es 1

1

En el siguiente agarre devolvemos 1 más el 2

1
1+2

En la última carrera tenemos los tres juntos

1
1+2
1+2+3

¿Ves el triángulo? La suma de todas las ejecuciones es el "triángulo" de la lista.

Ok, pero ahora necesitamos que funcione para ceros, aquí usé el mismo truco que DJMcMayhem, además de un juego de pies elegante. En lugar de repetir hasta que lleguemos a cero, repetimos hasta que la pila esté vacía.

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

Luego utilicé este consejo , escrito por nada menos que el suyo, para jugar otros 2 bytes.

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

Y ahí lo tenemos. Me sorprendería si hubiera una solución más corta, pero de nuevo han sucedido cosas más extrañas.

JavaScript (ES6), 28 bytes

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

Toma la entrada como una lista de dígitos.

Python 3 , 37 bytes

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

Pruébalo en línea!

C # (.NET Core) , 59 bytes

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

Pruébalo en línea!

Sustancialmente diferente de las otras respuestas de C #. La entrada es una lista de dígitos. Todos los casos de prueba incluidos en el enlace TIO.

Podría guardar un montón de bytes si se le permite tomar la entrada como una lista de dígitos hacia atrás con un 0 inicial.

Python 3 , 35 bytes

¡Sin embargo, acabo de darme cuenta de que esto es solo un pequeño golf de la respuesta de Business Cat al final!

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

Pruébalo en línea!

J , 7 bytes

[:+/+/\

Pruébalo en línea! Toma una lista de dígitos, como f 6 5 4 3 2 1.

Explicación

[:+/+/\    (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

Un poco más fiel al problema original sería [:+/@,]/, que es "sum" ( +/) los ,prefijos aplanados ( ) de input ( ]\).

Vim , 60 59 32 pulsaciones de teclas

Muchas gracias @CowsQuack por el consejo con la macro recursiva y el htruco, ¡esto me ahorró 27 bytes!

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

Pruébalo en línea!

Sin golf / Explicado

Esto construirá el triángulo como se describe (solo que lo mantiene alineado a la izquierda):

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

El buffer ahora se ve así:

53716
5371
537
53
5

Une todas las líneas en una y crea una expresión evaluable a partir de ella:

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

El "registro ahora contiene la siguiente cadena (nota falta 0):

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

Entonces, todo lo que tenemos que hacer es agregar un cero y evaluarlo:

 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 gracias al Sr. Xcoder.

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

Pruébalo en línea!

Toma la entrada como una lista de dígitos.

Bash + GNU utilidades, 32 24

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

Entrada leída desde STDIN.

Actualización: veo que la entrada puede darse como una lista de dígitos. Mi lista de entrada está delimitada por nueva línea.

Pruébalo en línea .

Explicación

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

+/+\

Esto toma la entrada como una lista de dígitos, por ejemplo:

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

Explicación

+/    sum of
  +\  partial sums of input

Taxi , 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.

Pruébalo en línea!

Sin golf:

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

Pruébalo en línea!

¿Cómo?

$ \ contiene el total acumulado, $ p contiene el total de los dígitos en la línea actual. Cada línea del paralelogramo es simplemente la línea anterior con el siguiente dígito del número agregado. Por lo tanto, es la suma de la línea anterior más el nuevo dígito. Esto itera sobre todos los dígitos, calculando las sumas a medida que avanza. La sustitución real es irrelevante; es solo un medio para iterar sobre los dígitos sin crear un bucle real. Al final, $ \ se imprime implícitamente por la -popción.

Python 2 , 56 bytes

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

Pruébalo en línea!

Jalea ,  5  4 bytes

Ṛæ.J

Un enlace monádico que toma una lista de dígitos decimales y devuelve el triángulo del número que esa lista representa.

Pruébalo en línea!

¿Cómo?

Ṛæ.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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación: La primera etapa genera todos los prefijos del número original, la segunda etapa convierte cada dígito en unario y la tercera etapa toma el total.

Mathematica, 49 bytes

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

Neim , 3 bytes

𝐗𝐂𝐬

Explicación:

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

Pruébalo en línea!

Respuesta alternativa:

𝐗𝐣𝐬

Explicación:

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

Pruébalo en línea!

Java 8, 53 bytes

Implementé una lambda para cada tipo de entrada aceptable. Cada uno itera a través de los dígitos del número, agregando el múltiplo apropiado de cada uno a un acumulador.

Entero como entrada (53 bytes)

Lambda de Integera Integer:

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

Representación de cadena como entrada (72 bytes)

Lambda de Stringa 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, el valor posicional más grande primero) a Integer:

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

• -7 bytes gracias a Olivier Grégoire

Pyt , 9 6 bytes

ąĐŁř↔·

Explicación:

                 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

¡Gracias al Sr. Xcoder por ayudarme a ahorrar algunos bytes!

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

¡Pruébelo en línea!

Toma la entrada como una cadena. Simplemente multiplica cada dígito por la cantidad de veces que necesita agregarse y devuelve su suma.

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

Pruébalo en línea!

Entrada de stdin, salida a stdout.

Lisp común, 53 52 bytes

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

Entrada como lista de dígitos.

Pruébalo en línea!

-1 byte gracias a @ceilingcat.