Nous sommes habitués au terme "quadrature" n pour désigner le calcul de n ² . Nous sommes également habitués au terme "cubing" n pour signifier n ³ . Cela étant dit, pourquoi ne pourrions-nous pas également trianguler un nombre?

Comment trianguler un nombre?

• Tout d'abord, choisissons un nombre 53716,.

• Placez-le dans un parallélogramme, dont la longueur du côté est égale au nombre de chiffres du nombre, et a deux côtés positionnés en diagonale, comme indiqué ci-dessous.

      53716
     53716
    53716
   53716
  53716
  

• Maintenant, nous voulons le faire, non? Pour ce faire, recadrez les côtés qui ne rentrent pas dans un triangle rectangle:

      5
     53
    537
   5371
  53716
  

• Prenez les sommes de chaque ligne, pour cet exemple résultant en [5, 8, 15, 16, 22]:

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

• Additionnez la liste [5, 8, 15, 16, 22], résultant en 66. Ceci est le triangle de ce nombre!

Spécifications et règles

• L'entrée sera un entier non négatif n ( n ≥ 0, n ∈ Z ).

• Vous pouvez prendre des entrées et fournir des sorties par tout moyen autorisé .

• L'entrée peut être formatée sous la forme d'un entier, d'une représentation sous forme de chaîne de l'entier ou d'une liste de chiffres.

• Les failles par défaut ne sont pas autorisées.

• C'est le code-golf , donc le code le plus court en octets gagne!

Plus de cas de test

Entrée -> Sortie

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

Inspiration. Les explications sont encouragées!

Haskell , 13 octets

sum.scanl1(+)

Essayez-le en ligne!

Prend la saisie sous forme de liste de chiffres. Calcule les sommes cumulées puis les additionne.

Husk , 4̷ 2 octets

Merci @ H.PWiz pour les -2octets!

Σ∫

Essayez-le en ligne!

"Ungolfed" / Expliqué

Σ    -- sum all
 ∫   -- prefix sums

Brain-Flak , 65, 50, 36 octets

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

Essayez-le en ligne!

Après de nombreuses révisions, je suis maintenant très fier de cette réponse. J'aime l'algorithme, et à quel point il peut être exprimé en brain-flak.

La plupart du nombre d'octets provient de la gestion des 0 en entrée. En fait, si nous pouvions supposer qu'il n'y avait pas de 0 dans l'entrée, ce serait une réponse magnifiquement courte de 20 octets:

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

Essayez-le en ligne!

Mais malheureusement, brain-flak est connu pour une mauvaise gestion des cas marginaux.

Explication

Tout d'abord, une de mes observations:

Si l'entrée comporte n chiffres, le premier chiffre apparaîtra dans le triangle n fois, le deuxième chiffre n-1 fois, et ainsi de suite sur le dernier chiffre, qui apparaîtra une fois. Nous pouvons en profiter, car il est très facile de calculer combien de chiffres d'entrée sont laissés dans brain-flak, à savoir

[]

Voici donc comment fonctionne le code.

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

ss._

Essayez-le en ligne ici .

Un joli 6 octets qui n'utilise pas de préfixe intégré:

s*V_Sl

MATL , 3 octets

Yss

Essayez-le en ligne!

Prend l'entrée comme une liste de chiffres.

Gelée , 3 octets

+\S

Essayez-le en ligne! Utilise la même technique que ma réponse Japt: addition cumulative, puis somme.

Haskell , 25 octets

Prend la saisie sous forme de liste de chiffres

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

Essayez-le en ligne!

Haskell , 41 octets

Prend l'entrée comme représentation de chaîne

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

Essayez-le en ligne!

Japt , 7 6 4 octets

å+ x

Essayez-le en ligne!

Explication

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

Ancienne solution:

å+ ¬¬x

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

14 octets si nous n'avons pas besoin de prendre en charge les zéros (ce que nous faisons)

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

Essayez-le en ligne!

DJMcMayhem a une réponse intéressante ici, vous devriez vérifier. Malheureusement pour lui, je n'allais pas le laisser gagner dans sa propre langue: P

Comment ça marche?

Commençons par la version simple.

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

L'action principale ici est ({}<>{})<>, qui prend le haut de la pile de gauche et s'ajoute au haut de la pile de droite. En bouclant cette opération, nous résumons la pile actuelle (jusqu'à ce qu'elle atteigne un zéro) en plaçant la somme sur la pile désactivée. C'est assez banal, la partie intéressante est que nous résumons les résultats de toutes ces courses comme notre résultat. Cela calculera la valeur souhaitée. Pourquoi? Jetons un coup d'œil à un exemple 123,. Lors de la première prise, nous obtenons juste 1, donc notre valeur est 1

1

Lors de la prochaine prise, nous retournons 1 plus le 2

1
1+2

Lors de la dernière manche, nous avons tous les trois ensemble

1
1+2
1+2+3

Voyez-vous le triangle? La somme de toutes les courses est le "triangle" de la liste.

Ok mais maintenant nous en avons besoin pour travailler avec des zéros, ici j'ai utilisé la même astuce que DJMcMayhem, plus quelques jeux de jambes fantaisistes. Au lieu de boucler jusqu'à ce que nous atteignions un zéro, nous bouclons jusqu'à ce que la pile soit vide.

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

J'ai ensuite utilisé cette astuce , écrite par nul autre que le vôtre, pour jouer au golf sur 2 autres octets.

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

Et nous l'avons. Je serais surpris s'il y avait une solution plus courte, mais là encore, des choses plus étranges se sont produites.

JavaScript (ES6), 28 octets

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

Prend la saisie sous forme de liste de chiffres.

Python 3 , 37 octets

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

Essayez-le en ligne!

C # (.NET Core) , 59 octets

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

Essayez-le en ligne!

Substantiellement différent des autres réponses C #. L'entrée est une liste de chiffres. Tous les cas de test inclus dans le lien TIO.

Pourrait enregistrer un tas d'octets s'il était autorisé à prendre l'entrée comme une liste de chiffres en arrière avec 0 en tête.

Python 3 , 35 octets

Je viens de remarquer que ce n'est vraiment qu'un léger golf de la réponse de Business Cat à la fin!

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

Essayez-le en ligne!

J , 7 octets

[:+/+/\

Essayez-le en ligne! Prend une liste de chiffres, tels que f 6 5 4 3 2 1.

Explication

[:+/+/\    (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 peu plus fidèle au problème d'origine serait [:+/@,]/, qui est "somme" ( +/) les ,préfixes aplatis ( ) de l'entrée ( ]\).

Vim , 60 59 32 touches

Merci beaucoup @CowsQuack pour l'astuce avec la macro récursive et l' hastuce, cela m'a fait gagner 27 octets!

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

Essayez-le en ligne!

Non golfé / expliqué

Cela va construire le triangle comme décrit (seulement qu'il le maintient aligné à gauche):

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

Le tampon ressemble maintenant à ceci:

53716
5371
537
53
5

Joignez toutes les lignes en une et créez une expression évaluable à partir de celle-ci:

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

Le "registre contient maintenant la chaîne suivante (note 0 manquante):

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

Il nous suffit donc d'ajouter un zéro et de l'évaluer:

 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 octets

-4 octets grâce à M. Xcoder.

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

Essayez-le en ligne!

Prend la saisie sous forme de liste de chiffres.

Utilitaires Bash + GNU, 32 24

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

Entrée lue depuis STDIN.

Mise à jour: je vois que l'entrée peut être donnée sous la forme d'une liste de chiffres. Ma liste d'entrées est délimitée par des sauts de ligne.

Essayez-le en ligne .

Explication

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 octets

+/+\

Cela prend l'entrée comme une liste de chiffres, par exemple:

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

Explication

+/    sum of
  +\  partial sums of input

Taxi , 1478 octets

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.

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Comment?

$ \ contient le total cumulé, $ p contient le total des chiffres de la ligne courante. Chaque ligne du parallélogramme est simplement la ligne précédente avec le chiffre suivant du numéro ajouté. C'est donc la somme de la ligne précédente plus le nouveau chiffre. Cela itère sur tous les chiffres, calculant les sommes au fur et à mesure. La substitution réelle n'est pas pertinente; c'est juste un moyen de parcourir les chiffres sans créer de boucle réelle. À la fin, $ \ est imprimé implicitement par le-p option.

Python 2 , 56 octets

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

Essayez-le en ligne!

Gelée ,  5  4 octets

Ṛæ.J

Un lien monadique prenant une liste de chiffres décimaux et renvoyant le triangle du nombre que cette liste représente.

Essayez-le en ligne!

Comment?

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

Rétine , 13 octets

.
$`$&
.
$*
1

Essayez-le en ligne! Le lien inclut des cas de test. Explication: la première étape génère tous les préfixes du numéro d'origine, la deuxième étape convertit chaque chiffre en unaire et la troisième étape prend le total.

Mathematica, 49 octets

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

Neim , 3 octets

𝐗𝐂𝐬

Explication:

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

Essayez-le en ligne!

Réponse alternative:

𝐗𝐣𝐬

Explication:

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

Essayez-le en ligne!

Java 8, 53 octets

J'ai implémenté un lambda pour chaque type d'entrée acceptable. Ils parcourent chacun les chiffres du nombre, ajoutant le multiple approprié de chacun à un accumulateur.

Entier en entrée (53 octets)

Lambda de Integerà Integer:

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

Représentation de chaîne en entrée (72 octets)

Lambda de Stringà Integer:

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

Tableau de chiffres en entrée (54 octets)

Lambda de int[](des chiffres, la plus grande valeur de position en premier) à Integer:

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

• -7 octets grâce à Olivier Grégoire

Pyt , 9 6 octets

ąĐŁř↔·

Explication:

                 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 octets

Merci à M. Xcoder de m'avoir aidé à économiser pas mal d'octets!

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

Essayez-le en ligne!

Prend l'entrée sous forme de chaîne. Il multiplie simplement chaque chiffre par le nombre de fois qu'il doit être ajouté et renvoie leur somme.

SNOBOL4 (CSNOBOL4) , 79 octets

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

Essayez-le en ligne!

Entrée depuis stdin, sortie vers stdout.

Lisp commun, 53 52 octets

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

Saisie sous forme de liste de chiffres.

Essayez-le en ligne!

-1 octet grâce à @ceilingcat.