Considera il seguente triangolo.

1
23
456
7891
01112
131415
1617181
92021222
324252627
2829303132
33343536373
839404142434
4454647484950
51525354555657
585960616263646
5666768697071727
37475767778798081

Come probabilmente avrai notato, la prima riga è di lunghezza 1, e ogni riga successiva è di 1 cifra più lunga rispetto alla precedente e contiene le cifre degli interi positivi concatenati.

Ti verrà dato un intero N . Il tuo compito è di trovare la somma delle cifre che si trovano sulla N fila del triangolo sopra.

Regole

• Puoi scegliere 0 o 1 indicizzazione. Si prega di specificarlo nella risposta.

• Si applicano scappatoie predefinite .

• Puoi prendere input e fornire output con qualsiasi media standard e in qualsiasi formato ragionevole.

• Questo è OEIS A066548 e questa sequenza è il triangolo stesso (tranne per il fatto che non rimuoviamo gli zeri iniziali).

• Questo è code-golf , quindi vince il codice più breve in byte (in ogni lingua). Divertiti a giocare a golf!

Casi test

Input  |  Output

0  |  1
1  |  5
2  |  15
3  |  25
4  |  5
5  |  15
6  |  25
7  |  20
8  |  33
9  |  33
10 |  43
11 |  46
12 |  64

Si noti che quanto sopra è indicizzato 0. Se stai cercando casi di test con 1 indice, incrementa l'input di 1.

_{Su una nota abbastanza indipendente, di recente ho cambiato la mia foto del profilo e questo mi ha ispirato a scrivere questa sfida.}

Buccia , 7 byte

1-indicizzato

Σ!CNṁdN

Provalo online!

Spiegazione

    ṁ     Map then concatenate
     d    Integer digits
      N   Over the natural numbers
  CN      Cut into lists of lengths corresponding to the natural numbers
 !        Index it
Σ         Sum

Python 2 , 69 byte

Questo potrebbe probabilmente essere un po 'più breve.

1-indicizzato

Modifica: -7 byte grazie a @ Mr.Xcoder

lambda n:sum(map(int,"".join(map(str,range(1,n*n+1)))[~-n*n/2:][:n]))

Provalo online!

Haskell , 57 byte

f n=sum[read[d]|d<-take n$drop(div(n*n-n)2)$show=<<[1..]]

Provalo online!

05AB1E , 8 byte

nLS¹L£θO

Provalo online!

-1 grazie a Emigna .

1-indicizzazione.

Perl 6 , 47 45 42 byte

{[~](1..$_²).substr(:1[^$_],$_).comb.sum}

Provalo online!

1-indicizzato

Mathematica, 96 byte

(d=Flatten[IntegerDigits/@Range[#^2]];Last@Table[Tr@Take[d,{i(i+1)/2+1,(i+1)(i+2)/2}],{i,0,#}])&  

Provalo online! (per lavorare sulla matematica "Tr" deve essere sostituito con "Totale")

Gelatina , 11 byte

²RDFṁRS$ṫCS

Provalo online!

Utilizza l'indicizzazione basata su 1.

Spiegazione

²RDFṁRS$ṫCS  Input: n
²            Square
 R           Range, [1, n^2]
  D          Decimal digits
   F         Flatten
    ṁ        Reshape to
       $     Monadic chain
     R         Range, [1, n]
      S        Sum
        ṫ    Tail
         C   Complement, 1-n
          S  Sum

Haskell, 69 64 byte

n%x=sum[read[d]|d<-take n x]:(n+1)%drop n x
f=(1%(show=<<[1..])!!)

Provalo online.

5 byte salvati grazie a Laikoni !

Ecco la versione meno giocata:

-- continuous stream of digits representing
-- the concatenation of positive integers in
-- order: 1234567891011...
digitstream = show=<<[1..]

-- sequence that yields the rows of the triangle
triangle n xs |(a,b)<-splitAt n xs=a:triangle(n+1)b

digitSum xs = sum[read[d]|d<-xs]

-- sequence that sums up the digits in each row
rowSumSequence = map digitSum (triangle 1 digitstream)

-- the final function that just shows the value 
-- at a given index
g=(rowSumSequence!!)

R, 119 109 108 93 88 byte

iniziando a golf .... 1-indicizzato

function(n){for(i in 1:n+n*(n-1)/2){F=F+strtoi(substr(paste(1:n^2,collapse=""),i,i))};F}

grazie @Zachary. la tua presunzione è corretta :) rasato 1 byte tnx su @Andrius e altri 15 tnx su @ user2390246

@Giuseppe - tnx per lo strtoi. nuovo per me. 5 byte in giù :)

Emojicode , 182 byte

🐖©a🚂➡🚂🍇🍦l➗✖a➕a 1 2🍮t🔤🔤🍮i 0🔁▶l🐔t🍇🍮➕i 1🍮t🍪t🔡i 10🍪🍉🍮s 0🔂g🔪t➖l a a🍇🍮➕s 🍺🚂🔡g 10🍉🍎s🍉

Definisce un metodo chiamato © che accetta 🚂 e restituisce 🚂. 1-indicizzati.

Provalo online!

Spiegazione:

Nota: molta scelta delle emoji non ha molto senso in Emojicode 0.5. È 0.x, dopo tutto. 0.6 risolverà questo, quindi se vuoi imparare questo (perché chi non vorrebbe), ti consiglio di aspettare un momento.

Emojicode è un linguaggio di programmazione orientato agli oggetti con generici, protocolli, optionals e chiusure, ma questo programma non utilizza chiusure e tutti i generici e protocolli possono essere considerati impliciti.

Il programma funziona solo su alcuni tipi: 🚂 è il tipo intero e 🔡 è il tipo di stringa. Inoltre, appaiono in condizioni, che possono assumere un valore di 👍 (vero) o 👎 (falso).

Attualmente non ci sono operatori in Emojicode, quindi addizioni, comparazioni e altre operazioni che normalmente sono operatori vengono implementate come funzioni, facendo sì che le espressioni utilizzino la notazione con prefisso . Gli operatori sono inoltre previsti in 0.6.

🐖©a🚂➡🚂🍇

© prende un 🚂 chiamato ae restituisce un 🚂.

 🍦l➗✖a➕a 1 2

Dichiarare un congelato ("costante") luguale all'a-esimo numero triangolare (formula nella notazione del prefisso). Ciò rappresenta la lunghezza della stringa di numeri che dobbiamo generare.

 🍮t🔤🔤

Assegna una stringa vuota alla variabile t.

 🍮i 0

Assegna i = 0.

 🔁▶l🐔t🍇

Mentre il lè maggiore della lunghezza dit

  🍮➕i 1

i += 1

  🍮t🍪t🔡i 10🍪

Aggiungi la rappresentazione testuale di iin base 10 a t.

 🍉

End loop

 🍮s 0

Assegnare s = 0

 🔂g🔪t➖l a a🍇

Prendi una sottostringa che tparte da l - a( a - 1th numero triangolare) di lunghezza a, ripeti su tutti i caratteri

  🍮➕s 🍺🚂🔡g 10

Converti il ​​carattere in stringa, analizza il numero intero in base-10, scartare il facoltativo (viene restituito il nulla se la stringa non è un numero) e aggiungi alla svariabile.

 🍉

End loop

 🍎s

Ritorna

🍉

Metodo finale

PHP, 66 + 1 byte

for($p=($n=$argn)*-~$n/2;$n--;)$r+=join(range(1,$p))[--$p];echo$r;

Esegui come pipe -nRo provalo online .

richiede PHP 5.4 o successivo per indicizzare l'espressione.

Pyth, 24 byte

u+GsH<>jkS+*QQ2/*QhQ2hQ0

Provalo qui: http://pyth.herokuapp.com/

APL, 28 26 25 byte

{+/⍎¨⍵↑⌽(+/⍳⍵)↑∊,/⍕¨⍳⍵×⍵}

Utilizza l'indicizzazione basata su 1

Provalo online!

Come?

• ⍳⍵×⍵, 1 attraverso l'ingresso al quadrato
• ⍕¨, trasforma ogni elemento in una stringa
• ∊,/, concatenali insieme
• (+/⍳⍵)↑, prendi le righe fino all'input
• ⍵↑⌽, prendi la riga desiderata
• ⍎¨, trasforma ogni elemento in un numero
• +/, somma

Clojure v1.8, 154 byte

1-indicizzato

(fn[n](loop[i 1 s(clojure.string/join""(take(* n n)(iterate inc 1)))](if(= i n)(apply +(map #(Character/digit % 10)(take n s)))(recur(inc i)(subs s i)))))

Provalo online!

Spiegazione

(take(* n n)(iterate inc 1))  Take the first N*N numbers
(clojure.string/join""...)    Combine them into a string
(loop[i 1 ...](if(= i n)...)  Loop N times
(apply +(map #(Character/digit % 10)(take n s)))  Take N characters from the string, convert to integers and add them
(recur(inc i)(subs s i))      Increment iterator, remove i characters from string

Java 8, 116 98 byte

n->{String t="";int r=0,i=0;for(;i++<n*n;t+=i);for(i=0;i<n;r+=t.charAt(i+++~-n*n/2)-48);return r;}

1-indicizzato

-18 byte grazie a @Nevay

Spiegazione:

Provalo qui.

n->{                             // Method with integer as both parameter and return-type
  String t="";                   //  Triangle-String
  int r=0,                       //  Result-integer
      i=0;                       //  Index-integer
  for(;i++<n*n;                  //  Loop (1) from 0 to `n^2` (exclusive)
    t+=i                         //   And append String `t` with all the numbers
  );                             //  End of loop (1)
  for(i=0;i<n;                   //  Loop (2) from 0 to `n` (exclusive)
    r+=t.charAt(i+++~-n*n/2)-48  //   And raise the sum `r` by the digits
  );                             //  End of loop (2)
  return r;                      //  Return the resulting sum of digits
}                                // End of method

R, 99 , 105 , 97 byte

a=diag(N<-scan());a[upper.tri(a,T)]=strtoi(strsplit(paste(1:N^2,collapse=""),"")[[1]]);sum(a[,N])

1-indicizzato

versione non golfata

a <- diag(N<-scan())
a[upper.tri(a, diag=TRUE)] <- strtoi(strsplit(paste(1:N^2, 
                                                  collapse=""),
                                            "")[[1]])
sum(a[,N])

Provalo qui!

grazie a @Giuseppe per aver salvato 8 byte

Perl 6 , 44 byte

{[+] (1..*).flatmap(*.comb).rotor(1..*)[$_]}

Provalo

Allargato:

{
  [+]        # reduce the result of the following using &infix«+»

  ( 1 .. * ) # infinite range starting at 1

  .flatmap(  # map, then flatten
    *.comb   # split into digits (100 ⇒ 1,0,0)
  )

  .rotor(    # break the sequence into pieces
    1 .. *   # start with 1 value, then 2 values, then 3, etc.
  )\

  [$_]       # index into that infinite sequence
}

Gelatina , 16 byte

Ṭ€Ẏ0;œṗ²D€Ẏ$$⁸ịS

Provalo online!

1-indicizzati.

SOGL V0.12 , 15 13 byte

²Δr∑.δ∑⌡kmčr∑

Provalo qui!
1-indicizzati.

Mentre lavoravo su questo, ho risolto un bug che ∑non funzionava su array di numeri e che mprendeva erroneamente input impliciti.

Spiegazione:

²              square the input
 Δ             get a range from 1 to that
  r∑           join as a string
    .δ         create a range 0 - input-1
      ∑        sum that
       ⌡       that many times do
        k        remove the 1st character of the joined string
         m     mold to the length of the input
          č    chop into characters
           r∑  convert to numbers and sum

C ++, 180 byte

-17 byte grazie a Zacharý

L'indice inizia da 1

#include<string>
int s(int n){std::string t;int i=0,p=0;for(;i<=n;)p+=i++;for(i=0;t.size()<p;t+=std::to_string(++i));t=t.substr(0,p).substr(p-n);i=0;for(auto&a:t)i+=a-48;return i;}

Pyth ,  15 14  13 byte

s<>sMjkS^Q2sU

Provalo qui! oppure Dai un'occhiata alla suite di test.

13 byte di alternative:

ssM<>jkS^Q2sU
ssM<>jkS*QQsU
s<>sMjkS^Q2sU

Come?

s<>sMjkS^Q2sU    Full program. Q means input.

       S^Q2      The range [1, Q^2].
     jk          Join as a String.
   sM            Convert each character to integer.
  >              All the elements of the above, but the first Q*(Q-1)/2.
 <               All the element of the above but the last Q.
s                Sum.
                 Output implicitly.

> <>, 141 + 2 byte

::1+* 2,01\
@}})?/:0$\>$:@{{:
:%a:/?(1:< ,a-]{+1[4
  /~/     \+1~\
1:<]{+1[+4@:-1\?(
{1-}>{:}1(?\@1-@+
    \0}~{{\\n;
@:{{:<-1~$\!?)}}
     ~

1-indicizzato

+ 2b per -v flag

Tio.run non sembra davvero apprezzare i miei programmi <> di recente ... Tuttavia, può ancora essere verificato su https://fishlanguage.com . L'ingresso va nello "stack iniziale".

Modifica: A tio.run non piace perché gestisce '[' e ']' in modo diverso da fishlanguage.com. fishlanguage.com inverte lo stack durante la creazione o la rimozione di un nuovo stack, ma tio.run no.

Perl 5 , 62 + 1 (-p) = 63 byte

$_=eval(substr((join'',1..$_*$_),($_**2-$_)/2,$_)=~s/./+$&/gr)

Provalo online!

Il risultato è 1 indicizzato.

Come?

Concatena insieme più cifre sufficienti, quindi salta quelle irrilevanti all'inizio (la lunghezza del salto è la somma di numeri interi da 1 a n-1). Prendi le ncifre successive , posiziona una +davanti a ciascuna, quindi valuta quell'equazione.

JavaScript (ES6), 78 65 byte

f=
n=>eval([...(g=n=>n?g(n-1)+n:``)(n*n).substr(n*~-n/2,n)].join`+`)

<input type=number min=1 oninput=o.textContent=f(this.value)><pre id=o>

1-indicizzati. Modifica: salvato 13 byte grazie a @tsh.