Siamo abituati al termine "quadratura" n per indicare il calcolo di n ² . Siamo anche abituati al termine "cubing" n per indicare n ³ . Detto questo, perché non potremmo anche triangolare un numero?

Come triangolare un numero?

• Prima di tutto, cerchiamo di scegliere un numero, 53716.

• Posizionalo in un parallelogramma, la cui lunghezza laterale è uguale al numero di cifre del numero e ha due lati posizionati in diagonale, come mostrato di seguito.

      53716
     53716
    53716
   53716
  53716
  

• Ora, vogliamo farlo, giusto? Per fare ciò, ritaglia i lati che non si adattano a un triangolo rettangolo:

      5
     53
    537
   5371
  53716
  

• Prendi le somme di ogni riga, per questo esempio risultante in [5, 8, 15, 16, 22]:

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

• Somma l'elenco [5, 8, 15, 16, 22], risultante 66. Questo è il triangolo di questo numero!

Specifiche e regole

• L'ingresso sarà un numero intero non negativo n ( n ≥ 0, n ∈ Z ).

• È possibile accettare input e fornire output con qualsiasi mezzo consentito .

• L'input può essere formattato come un numero intero, una rappresentazione in formato stringa dell'intero o un elenco di cifre.

• Scappatoie predefinite non consentite.

• Questo è code-golf , quindi vince il codice più corto in byte!

Altri casi di test

Ingresso -> Uscita

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

Ispirazione. Le spiegazioni sono incoraggiate!

Haskell , 13 byte

sum.scanl1(+)

Provalo online!

Accetta input come elenco di cifre. Calcola le somme cumulative, quindi le somma.

Buccia , 4̷ 2 byte

Grazie @ H.PWiz per i -2byte!

Σ∫

Provalo online!

"Ungolfed" / Spiegato

Σ    -- sum all
 ∫   -- prefix sums

Brain-Flak , 65, 50, 36 byte

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

Provalo online!

Dopo molte modifiche, ora sono molto orgoglioso di questa risposta. Mi piace l'algoritmo e quanto bene può essere espresso in scaglie di cervello.

Gran parte del conteggio dei byte deriva dalla gestione di 0 nell'input. In effetti, se potessimo presumere che non ci fossero 0 nell'input, sarebbe una risposta meravigliosamente breve di 20 byte:

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

Provalo online!

Ma sfortunatamente, il brain-flak è noto per la cattiva gestione dei casi limite.

Spiegazione

Innanzitutto, una mia osservazione:

Se l'input è lungo n cifre, la prima cifra apparirà nel triangolo n volte, la seconda cifra apparirà n-1 volte e così via sull'ultima cifra, che apparirà una volta. Possiamo trarne vantaggio, dal momento che è davvero facile calcolare quante cifre di input sono rimaste nel cervello, ovvero

[]

Quindi ecco come funziona il codice.

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

ss._

Provalo online qui .

Nice 6 byte one che non utilizza il prefisso incorporato:

s*V_Sl

MATL , 3 byte

Yss

Provalo online!

Prende l'input come un elenco di cifre.

Gelatina , 3 byte

+\S

Provalo online! Utilizza la stessa tecnica della mia risposta Japt: addizione cumulativa, quindi somma.

Haskell , 25 byte

Accetta input come elenco di cifre

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

Provalo online!

Haskell , 41 byte

Accetta input come rappresentazione di stringhe

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

Provalo online!

Japt , 7 6 4 byte

å+ x

Provalo online!

Spiegazione

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

Vecchia soluzione:

å+ ¬¬x

Provalo online!

Spiegazione

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

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

Provalo online!

14 byte se non abbiamo bisogno di supportare zeri (cosa che facciamo)

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

Provalo online!

DJMcMayhem ha una bella risposta qui che dovresti dare un'occhiata. Sfortunatamente per lui non avevo intenzione di lasciarlo vincere nella sua lingua: P

Come funziona?

Cominciamo con la versione semplice.

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

L'azione principale qui è ({}<>{})<>, che prende la parte superiore della pila a sinistra e si aggiunge alla parte superiore della pila a destra. Effettuando il ciclo di questa operazione sommiamo lo stack corrente (fino a quando non raggiunge uno zero) posizionando la somma sullo stack off. È piuttosto banale, la parte interessante è che riassumiamo i risultati di tutte queste piste come risultato. Questo calcolerà il valore desiderato. Perché? Bene, diamo un'occhiata a un esempio 123,. Al primo grab prendiamo solo 1, quindi il nostro valore è 1

1

Alla prossima presa restituiamo 1 più il 2

1
1+2

Nell'ultima corsa abbiamo tutti e tre insieme

1
1+2
1+2+3

Vedi il triangolo? La somma di tutte le corse è il "triangolo" dell'elenco.

Ok ma ora ne abbiamo bisogno per funzionare con gli zeri, qui ho usato lo stesso trucco di DJMcMayhem, oltre ad alcuni fantasiosi footwork. Invece di eseguire il looping fino a raggiungere uno zero, eseguiamo il looping fino a quando lo stack non è vuoto.

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

Ho quindi usato questo suggerimento , scritto nientemeno che dal tuo, per giocare a golf con altri 2 byte.

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

E lì ce l'abbiamo. Sarei sorpreso se ci fosse una soluzione più breve, ma poi sono successe cose più strane.

JavaScript (ES6), 28 byte

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

Accetta input come un elenco di cifre.

Python 3 , 37 byte

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

Provalo online!

C # (.NET Core) , 59 byte

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

Provalo online!

Sostanzialmente diverso dalle altre risposte C #. L'input è un elenco di cifre. Tutti i casi di test inclusi nel collegamento TIO.

Potrebbe salvare un mucchio di byte se fosse consentito accettare input come un elenco di cifre all'indietro con 0 iniziale.

Python 3 , 35 byte

Ho appena notato che alla fine questo è solo un leggero golf della risposta di Business Cat !

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

Provalo online!

J , 7 byte

[:+/+/\

Provalo online! Prende un elenco di cifre, ad esempio f 6 5 4 3 2 1.

Spiegazione

[:+/+/\    (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 po 'più fedele al problema originale sarebbe [:+/@,]/, che è "sum" ( +/) i ,prefissi flattened ( ) dell'input ( ]\).

Vim , 60 59 32 sequenze di tasti

Grazie mille @CowsQuack per il suggerimento con la macro ricorsiva e il htrucco, questo mi ha salvato 27 byte!

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

Provalo online!

Ungolfed / Spiegato

Questo costruirà il triangolo come descritto (solo che lo mantiene allineato a sinistra):

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

Il buffer ora ha questo aspetto:

53716
5371
537
53
5

Unisci tutte le linee in una e costruisci un'espressione valutabile da essa:

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

Il "registro ora contiene la seguente stringa (nota mancante 0):

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

Quindi tutto ciò che dobbiamo fare è aggiungere uno zero e valutarlo:

 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 byte

-4 byte grazie a Mr. Xcoder.

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

Provalo online!

Accetta input come un elenco di cifre.

Utilità Bash + GNU, 32 24

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

Ingresso letto da STDIN.

Aggiornamento: vedo che l'input può essere dato come un elenco di cifre. La mia lista di input è delimitata da newline.

Provalo online .

Spiegazione

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 byte

+/+\

Questo prende l'input come un elenco di cifre, ad esempio:

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

Spiegazione

+/    sum of
  +\  partial sums of input

Taxi , 1478 byte

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.

Provalo online!

Un-giocato a 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 byte

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

Provalo online!

Come?

$ \ contiene il totale cumulativo, $ p contiene il totale delle cifre sulla riga corrente. Ogni riga del parallelogramma è semplicemente la riga precedente con la cifra successiva del numero aggiunto. Pertanto, è la somma della riga precedente più la nuova cifra. Questo scorre su tutte le cifre, calcolando le somme mentre procede. La sostituzione effettiva è irrilevante; è solo un mezzo per scorrere le cifre senza creare un ciclo reale. Alla fine, $ \ viene stampato implicitamente -pdall'opzione.

Python 2 , 56 byte

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

Provalo online!

Gelatina ,  5  4 byte

Ṛæ.J

Un collegamento monadico che prende un elenco di cifre decimali e restituisce il triangolo del numero rappresentato dall'elenco.

Provalo online!

Come?

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

.
$`$&
.
$*
1

Provalo online! Il link include casi di test. Spiegazione: Il primo stadio genera tutti i prefissi del numero originale, il secondo stadio converte ogni cifra in unaria e il terzo stadio prende il totale.

Mathematica, 49 byte

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

Neim , 3 byte

𝐗𝐂𝐬

Spiegazione:

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

Provalo online!

Risposta alternativa:

𝐗𝐣𝐬

Spiegazione:

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

Provalo online!

Java 8, 53 byte

Ho implementato un lambda per ogni tipo di input accettabile. Ognuno scorre attraverso le cifre del numero, aggiungendo il multiplo corretto di ciascuno a un accumulatore.

Numero intero come input (53 byte)

Lambda da Integera Integer:

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

Rappresentazione di stringhe come input (72 byte)

Lambda da Stringa Integer:

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

Cifra array come input (54 byte)

Lambda da int[](di cifre, prima il più grande valore del luogo) a Integer:

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

• -7 byte grazie a Olivier Grégoire

Pyt , 9 6 byte

ąĐŁř↔·

Spiegazione:

                 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 byte

Grazie a Mr. Xcoder per avermi aiutato a salvare un bel po 'di byte!

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

Provalo online!

Accetta l'input come stringa. Moltiplica semplicemente ogni cifra per il numero di volte che deve essere aggiunta e restituisce la loro somma.

SNOBOL4 (CSNOBOL4) , 79 byte

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

Provalo online!

Input da stdin, output a stdout.

Lisp comune, 53 52 byte

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

Immettere come elenco di cifre.

Provalo online!

-1 byte grazie a @ceilingcat.