L'obiettivo

Dato un intero positivo di input n(compreso tra 1 e il limite della tua lingua, inclusivamente), restituisce o genera il numero massimo di interi positivi distinti a cui si somma n.

Casi test

Lasciate fdefinire una funzione valida a seconda del compito:

La sequenza per f, a partire da 1:

1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, ...

Come caso di prova più grande:

>>> f(1000000000) // Might not be feasible with brute-forcers
44720

Codice test

Per tutti i casi di test non esplicitamente indicati, l'output del codice deve corrispondere al risultato di quanto segue:

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        System.out.println((int) Math.floor(Math.sqrt(2*x + 1./4) - 1./2));
    }
}

Provalo online!

05AB1E , 4 byte

ÅTg<

Provalo online!

Strumento perfetto per il lavoro.

ÅTI rendimenti l'elenco dei Å ll t numeri riangular fino al N (include purtroppo 0 troppo, altrimenti sarebbe 3 byte), g<ottiene il len g ° e decrementa.

Gelatina , 6 5 byte

R+\»ċ

Provalo online!

Abbastanza efficiente. Questa sequenza si incrementa ai numeri triangolari, quindi conta solo quanti numeri triangolari sono più piccoli di n .

Spiegazione:

        # Main link
R       # Range, generate [1..n]
 +\     # Cumulative sum (returns the first n triangular numbers)
   »    # For each element, return the maximum of that element and 'n'
    ċ   # How many elements are 'n'? (implicit right argument is n)

Haskell , 26 byte

-2 byte grazie a H.PWiz.

(!!)$do x<-[0..];x<$[0..x]

Provalo online!

Ciò restituisce l' ennesimo elemento dei numeri interi in cui ogni i viene replicato i + 1 volte.

Brain-Flak , 36 byte

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

Provalo online!

Questo utilizza la stessa struttura dell'algoritmo di divisione standard, tranne per il fatto che il "divisore" viene incrementato ogni volta che viene letto.

Pari / GP , 19 byte

n->((8*n+1)^.5-1)\2

Provalo online!

Brain-Flak , 82 byte

Spazio bianco aggiunto per "Leggibilità"

(())

{
    {}

    ((({})[[]]))

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

}{}{}{}

([]<>)

Provalo online!

Gelatina , 7 byte

×8‘½’:2

Provalo online!

Gelatina , 9 byte

Ḥ+4ݤ½_.Ḟ

Provalo online!

Questo è più lungo di quello di Dennis e DJ, ma questa volta apposta . Molto, molto efficiente .

R , 28 byte

function(n)rep(1:n,1:n+1)[n]

Provalo online!

Crea il vettore di tempi 1ripetuti 2, tempi 2ripetuti 3, ..., tempi nripetuti n+1e prende l' nthelemento. Questo errore di memoria o perché 1:nè troppo grande o perché l'elenco ripetuto con n*(n+1)/2 - 1elementi è troppo grande.

R , 29 byte

function(n)((8*n+1)^.5-1)%/%2

Provalo online!

Calcola direttamente il valore, usando la formula trovata nella risposta di alephalpha . Questo dovrebbe funzionare senza problemi, a parte forse la precisione numerica.

R , 30 byte

function(n)sum(cumsum(1:n)<=n)

Provalo online!

Conta i numeri triangolari minori o uguali a n. Questo probabilmente causerà un errore di memoria se 1:nè abbastanza grande - per esempio, al 1e9suo lancio Error: cannot allocate vector of size 3.7 Gb.

APL (Dyalog) , 8 byte

+/+\∘⍳<⊢

Provalo online!

TI-Basic, 12 byte

int(√(2Ans+1/4)-.5

JavaScript (Node.js) , 18 byte

x=>(x-~x)**.5-.5|0

Provalo online!

Japt , 8 byte

Soluzione a formula chiusa.

*8Ä ¬É z

Provalo

Spiegazione

Moltiplicare per 8, aggiungere 1 ( Ä), ottenere la radice quadrata ( ¬), sottrarre 1 ( É) e dividere il risultato per 2 (z ).

Alternativa, 8 byte

Porta della soluzione Jelly di DJMcMayhem .

õ å+ è§U

Provalo

Generare una matrice di numeri interi ( õ) da 1 a input, ridurre cumulativamente ( å) per addizione ( +) e contare ( è) gli elementi che sono inferiori o uguali a ( §) l'input ( U).

Befunge, 32 20 byte

1+::1+*2/&#@0#.-`#1_

Provalo online!

Brain-Flak , 70 56 48 byte

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

Provalo online!

Spiegazione

La parte principale di questo è il seguente frammento che ho scritto:

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

Questo non farà nulla se il TOS è positivo e cambierà le pile in caso contrario. È super impuro ma sporco. Ora la parte principale del programma sottrae numeri sempre più grandi dall'input fino a quando l'input non è positivo. Iniziamo l'accumulatore a 1 ogni volta sottraendo 1 in più rispetto all'accumulatore dall'ingresso.

({}[({}())()])

Possiamo inserirlo all'interno del frammento sopra

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

Questo viene messo in un ciclo in modo che venga eseguito fino a quando non cambiamo stack. Una volta terminato il ciclo, recuperiamo l'accumulatore cambiando pile e rimuovendo la spazzatura.

Pyth , 7 byte

lh{I#./

Provalo online!

Filtra-mantieni le partizioni intere che sono Invarianti rispetto alla deduplicazione, prendi ilh ead e ottieni il suo linghilterra.

Prova di validità

_{^{Non molto rigoroso né ben formulato.}}

Lasciare A = a ₁ + a ₂ + ... + a _n e B = b ₁ + b ₂ + ... + b _m essere due partizioni distinte dello stesso numero intero N . Supponiamo che A sia la partizione unica più lunga . Dopo che deduplicazione B , cioè, sostituire le molteplici occorrenze dello stesso intero con uno solo di essi, sappiamo che la somma di B è inferiore a N . Ma sappiamo anche che il risultato della funzione è in aumento (non rigorosamente), quindi possiamo dedurre che la partizione unica A più lunga ha sempre almeno la stessa quantità di elementi del conteggio di elementi unici in altre partizioni.

Triangolarità , 49 byte

....)....
...2)2...
..)1/)8..
.)1/)IE/.
@^)1_+/i.

Provalo online!

Come funziona

La triangolarità richiede che il codice abbia una distribuzione triangolare dei punti. Cioè, la lunghezza di ogni riga deve essere uguale al numero di righe moltiplicato per 2 e decrementato e ogni riga deve avere (su ciascun lato) un numero di punti uguale alla sua posizione nel programma (la riga inferiore è la riga 0, quello sopra è la riga 1 e così via). Esistono solo un paio di comandi e qualsiasi carattere diverso da quelli elencati nella pagina "Wiki / Comandi" viene trattato come no-op (i punti estranei non influiscono in alcun modo sul programma, purché la forma complessiva del programma rimane rettangolare).

Si noti che per i comandi a due argomenti, ho usato un e b durante la spiegazione. Tenendo presente questo, vediamo cosa fa il programma vero e proprio, dopo aver rimosso tutti i caratteri estranei che compensano il riempimento:

)2)2)1/)8)1/)IE/@^)1_+/i | Input from STDIN and output to STDOUT.

)                        | Push a 0 onto the stack. Must precede integer literals.
 2                       | Push ToS * 10 + 2 (the literal 2, basically).
  )2                     | Again, push a 2 onto the stack. This can be replaced by D
                         | (duplicate), but then the padding would discard the saving.
    )1                   | Literal 1.
      /                  | Division. Push b / a (1 / 2).
       )8)1              | The literal 8 and the literal 1 (lots of these!).
           /             | Division. Push b / a (1 / 8).
            )IE          | Get the 0th input from STDIN and evaluate it.
               /         | Divide it by 1 / 8 (multiply by 8, but there isn't any
                         | operand for multiplication, and I'm not willing to add one).
                @        | Add 1 to the result.
                 ^       | Exponentiation. Here, it serves as a square too.
                  )1_+   | Decrement (add literal -1).
                      /  | Divide (by 2).
                       i | Cast to an integer.

Una soluzione alternativa e più breve se l'imbottitura non sarebbe necessaria:

....)....
...2)1...
../DD)I..
.E/)4)1/.
+^s_+i...

Provalo online!

PowerShell 3.0, 45 byte

[math]::Sqrt(2*$args[0]+.25)-.5-replace'\..*'

La chiamata matematica fa male e l'arrotondamento del banco di PS è il vero diavolo (quindi ha bisogno di regex per troncare per salvare un byte) ma questo sembra abbastanza bene.

Java (JDK) , 28 byte

n->~-(int)Math.sqrt(8*n+1)/2

Provalo online!

Perché l'esempio non è stato davvero ben giocato: p

Titoli di coda

• -2 byte grazie a Kevin Cruijssen

Gelatina , 7 byte

ŒPfŒṗṪL

Funziona all'incirca in O (2 ⁿ ) tempo.

Provalo online!

Come funziona

ŒPfŒṗṪL  Main link. Argument: n

ŒP       Powerset; yield all subarrays of [1, ..., n], sorted by length.
   Œṗ    Yield all integer partitions of n.
  f      Filter; keep subarrays that are partitions.
     Ṫ   Tail; extract the last result.
      L  Compute its length.

JavaScript (ES7), 22 19 byte

n=>(8*n+1)**.5-1>>1

-3 byte grazie a ETHproductions.

Provalo

o.innerText=(f=
n=>(8*n+1)**.5-1>>1
)(i.value=1000000000);oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>

Spiegazione

Moltiplica l'input per 8 e aggiungi 1, aumenta quello alla potenza di 0,5, dandoci la radice quadrata, sottrai 1 e sposta il risultato a bit per 1.

Python 2/3, 32 byte

Implementazione Python della formula in forma chiusa

lambda n:int((sqrt(1+8*n)-1)//2)

La divisione intera viene //2arrotondata verso zero, quindi non è floor( )necessaria

Haskell , 28 byte

Un po 'noioso, ma è piuttosto più corto dell'altra soluzione Haskell e ha un'espressione davvero priva di significato. Sfortunatamente non potrei accorciarlo senza che il sistema di tipi si frapponga:

g x=floor$sqrt(2*x+0.25)-0.5

Provalo online!

Pointfree, 33 byte

ceiling.(-0.5+).sqrt.(0.25+).(2*)

In alternativa, 33 byte

Stessa lunghezza della versione senza punti, ma molto più interessante.

g n=sum[1|x<-scanl1(+)[1..n],n>x]

Via Lattea , 12 byte

'8*1+g1-2/v!

Spiegazione

code         explanation       value

'            push input        n          
 8*          push 8, multiply  8n
   1+        add 1             8n+1
     g       square root       sqrt(8n+1)
      1-     subtract 1        sqrt(8n+1)-1
        2/   divide by 2       (sqrt(8n+1)-1)/2
          v  floor             floor((sqrt(8n+1)-1)/2)
           ! output

Pyt , 7 5 byte

Đř△>Ʃ

Spiegazione:

                      Implicit input
Đř△                   Gets a list of the first N triangle numbers
   >                  Is N greater than each element in the list? (returns an array of True/False)
    Ʃ                 Sums the list (autoconverts booleans to ints)

Più veloce, ma più lungo

Pyt , 11 9 byte

Đ2*√⌈ř△>Ʃ

Spiegazione:

Đ2*√⌈ř△           Gets a list of triangle numbers up to the ceiling(sqrt(2*N))-th
       >          Is N greater than each element of the list? (returns an array of True/False)
        Ʃ         Sums the array

Modo alternativo: porto della risposta di Shaggy

Pyt , 8 7 byte

8*⁺√⁻2÷

J , 11 byte

2&!inv<.@-*

Provalo online!

2&!inv       solve [x choose 2 = input]
         -*  minus 1
      <.     and floor

Spazio bianco , 111 byte

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_integer_from_STDIN][T T   T   _Retrieve_input][S S S T    S S S N
_Push_8][T  S S N
_Multiply][S S S T  N
_Push_1][T  S S S _Add][S S T   T   N
_Push_n=-1][N
S S N
_Create_Label_SQRT_LOOP][S S S T    N
_Push_1][T  S S S _Add][S N
S _Duplicate_n][S N
S _Duplicate_n][T   S S N
Multiply][S T   S S T   S N
_Copy_0-based_2nd_(the_input)][S S S T  N
_Push_1][T  S S S _Add][T   S S T   _Subtract][N
T   T   N
_If_negative_jump_to_Label_SQRT_LOOP][S S S T   S N
_Push_2][T  S S T   _Subtract][S S S T  S N
_Push_2][T  S T S _Integer_divide][T    N
S T _Print_integer]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Spiegazione in pseudo-codice:

Usa la formula:

NOTA: Whitespace non ha un built-in radice quadrata, quindi dobbiamo farlo manualmente.

Integer i = read STDIN as integer
i = i * 8 + 1
Integer n = -1
Start SQRT_LOOP:
  n = n + 1
  If(n*n < i+1):
    Go to next iteration of SQRT_LOOP
n = (n - 2) integer-divided by 2
Print n as integer to STDOUT

Vitsy , 16 byte

2*14/+12/^12/-_N

Provalo online!

Potrebbe anche aggiungere il mio contributo al mix. Questo è più breve della soluzione di iterazioni delle partizioni in Vitsy.

Oasi , 14 byte

n8*1+1tm1%_b+0

Provalo online!

Come?

n8*1+           8n + 1
     1tm        sqrt
        1%_     integer?
           b+   add f(n-1)

             0  f(0) is 0

Questa è una soluzione ricorsiva che incrementa il risultato quando incontra un indice triangolare, iniziando con 0 per l'ingresso 0.

Perl 5 -p , 19 (++) byte

$_=0|-.5+sqrt$_*2+1

Provalo online!

Rubino , 27 byte

Tre al prezzo di uno. Sono deluso dal fatto che non posso andare più corto.

->n{a=0;n-=a+=1while n>a;a}

->n{((8*n+1)**0.5-1).div 2}

->n{((n-~n)**0.5-0.5).to_i}

Provalo online! (per selezionare la funzione, aggiungi f = davanti ad essa)