Die Aufgabe

Wenn Sie eine positive Ganzzahl eingeben n(von 1 bis einschließlich zum Grenzwert Ihrer Sprache), geben Sie die maximale Anzahl eindeutiger positiver Ganzzahlen zurück oder geben Sie sie aus n.

Testfälle

Lassen Sie feine gültige Funktion definieren entsprechend der Aufgabe:

Die Reihenfolge für f, beginnend mit 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, ...

Als größerer Testfall:

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

Code testen

Für alle nicht explizit angegebenen Testfälle sollte die Ausgabe Ihres Codes mit den folgenden Ergebnissen übereinstimmen:

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));
    }
}

Probieren Sie es online!

05AB1E , 4 Bytes

ÅTg<

Probieren Sie es online!

Perfektes Werkzeug für den Job.

ÅTergibt die Liste der Å ll T riangular Zahlen bis zu und einschließlich N (schließt leider auch 0, sonst wäre es 3 Bytes), g<das Len bekommt g es th und dekrementiert.

Gelee , 6 5 Bytes

R+\»ċ

Probieren Sie es online!

Etwas effizient. Diese Sequenz wird bei Dreieckszahlen inkrementiert, sodass nur gezählt wird, wie viele Dreieckszahlen kleiner als n sind .

Erläuterung:

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

-2 Bytes dank H.PWiz.

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

Probieren Sie es online!

Dies gibt das n-te Element der ganzen Zahlen zurück, wobei jedes i i + 1- mal repliziert wird .

Brain-Flak , 36 Bytes

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

Probieren Sie es online!

Dies verwendet dieselbe Struktur wie der Standard-Divisionsalgorithmus, außer dass der "Divisor" jedes Mal inkrementiert wird, wenn er gelesen wird.

Pari / GP , 19 Bytes

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

Probieren Sie es online!

Brain-Flak , 82 Bytes

Leerzeichen für "Lesbarkeit" hinzugefügt

(())

{
    {}

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

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

}{}{}{}

([]<>)

Probieren Sie es online!

Gelee , 7 Bytes

×8‘½’:2

Probieren Sie es online!

Gelee , 9 Bytes

Ḥ+4ݤ½_.Ḟ

Probieren Sie es online!

Das ist länger als bei Dennis und DJs, aber diesmal mit Absicht . Sehr sehr effizient .

R , 28 Bytes

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

Probieren Sie es online!

Erzeugt den Vektor der 1wiederholten 2Male, 2wiederholten 3Male, ..., nwiederholten n+1Male und nimmt das nthElement. Dies führt zu einem Speicherfehler, entweder weil 1:ndie Liste zu groß ist oder weil die wiederholte Liste mit n*(n+1)/2 - 1Elementen zu groß ist.

R 29 Bytes

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

Probieren Sie es online!

Berechnet den Wert direkt unter Verwendung der in der Antwort von Alephalpha gefundenen Formel . Abgesehen von der möglichen numerischen Genauigkeit sollte dies ohne Probleme funktionieren.

R , 30 Bytes

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

Probieren Sie es online!

Zählt die Dreieckszahlen kleiner oder gleich n. Dies wird möglicherweise Speicherfehler, wenn 1:ngroß genug ist - zum Beispiel 1e9wirft es Error: cannot allocate vector of size 3.7 Gb.

APL (Dyalog) , 8 Bytes

+/+\∘⍳<⊢

Probieren Sie es online!

TI-Basic, 12 Bytes

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

JavaScript (Node.js) , 18 Byte

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

Probieren Sie es online!

Japt , 8 Bytes

Geschlossene Rezepturlösung.

*8Ä ¬É z

Versuch es

Erläuterung

Multiplizieren Sie mit 8, addieren Sie 1 ( Ä), erhalten Sie die Quadratwurzel ( ¬), subtrahieren Sie 1 ( É) und teilen Sie das Ergebnis durch 2 ( z).

Alternativ 8 Bytes

Port der Jelly-Lösung von DJMcMayhem .

õ å+ è§U

Versuch es

Generieren Sie ein Array von Ganzzahlen ( õ) von 1 bis zur Eingabe, reduzieren Sie ( å) kumulativ durch Addition ( +) und zählen Sie ( è) die Elemente, die kleiner oder gleich ( §) der Eingabe ( U) sind.

Befunge, 32 20 Bytes

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

Probieren Sie es online!

Brain-Flak , 70 56 48 Bytes

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

Probieren Sie es online!

Erläuterung

Der Hauptteil davon ist der folgende Ausschnitt, den ich geschrieben habe:

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

Dies wird nichts bewirken, wenn die TOS positiv ist, und wird ansonsten die Stapel wechseln. Es ist super Stapel unsauber, aber es funktioniert. Jetzt subtrahiert der Hauptteil des Programms immer größere Zahlen von der Eingabe, bis die Eingabe nicht mehr positiv ist. Wir starten den Akkumulator bei 1, indem wir jeweils 1 mehr als den Akkumulator von der Eingabe abziehen.

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

Wir können das oben in das Snippet einfügen

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

Das wird in einer Schleife ausgeführt, bis wir die Stapel wechseln. Sobald die Schleife beendet ist, holen wir den Akku, indem wir die Stapel tauschen und den Müll entfernen.

Pyth , 7 Bytes

lh{I#./

Probieren Sie es online!

Halten Sie die ganzzahligen Partitionen, die Inicht über die Deduplizierung variieren, gefilterth Filter aufl Länge.

Gültigkeitsnachweis

_{^{Nicht sehr streng und nicht gut formuliert.}}

Let A = a ₁ + a ₂ + ... + a _n und B = b ₁ + b ₂ + ... + b _m sein , zwei verschiedene Partitionen derselben ganze Zahl N . Wir gehen davon aus, dass A die längste eindeutige Partition ist. Nachdem wir B dedupliziert haben , dh mehrere Vorkommen derselben Ganzzahl durch nur eines ersetzt haben, wissen wir, dass die Summe von B kleiner als N ist . Wir wissen aber auch, dass das Funktionsergebnis (nicht ausschließlich) zunimmt, sodass wir daraus die längste eindeutige Partition A ableiten können Enthält immer mindestens die gleiche Anzahl von Elementen wie die Anzahl der eindeutigen Elemente in anderen Partitionen.

Dreieckigkeit , 49 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Dreieckigkeit erfordert, dass der Code eine dreieckige Verteilung der Punkte aufweist. Das heißt, die Länge jeder Zeile muss gleich der Anzahl der mit 2 multiplizierten und dekrementierten Zeilen sein, und jede Zeile muss (auf jeder Seite) eine Anzahl von Punkten aufweisen, die ihrer Position im Programm entspricht (die unterste Zeile ist Zeile 0). die darüberliegende ist Zeile 1 und so weiter). Es gibt nur ein paar Befehle, und alle Zeichen, die nicht auf der Seite "Wiki / Befehle" aufgeführt sind, werden als "No-Op" behandelt (irrelevante Punkte wirken sich auf das Programm in keiner Weise aus, solange sich die Gesamtform ändert des Programms bleibt rechteckig).

Beachten Sie, dass ich bei Befehlen mit zwei Argumenten in der gesamten Erläuterung a und b verwendet habe . In diesem Sinne wollen wir uns ansehen, was das eigentliche Programm macht, nachdem wir alle überflüssigen Zeichen entfernt haben, die das Auffüllen ausmachen:

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

Eine alternative und kürzere Lösung, wenn keine Polsterung erforderlich wäre:

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

Probieren Sie es online!

PowerShell 3.0, 45 Byte

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

Der Mathematik-Aufruf tut weh und die Rundung von PSs Bank ist der eigentliche Teufel (daher muss Regex abgeschnitten werden, um ein Byte zu speichern), aber das scheint in Ordnung zu sein.

Java (JDK) , 28 Byte

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

Probieren Sie es online!

Weil das Beispiel wirklich nicht gut war: p

Credits

• -2 Bytes dank Kevin Cruijssen

Gelee , 7 Bytes

ŒPfŒṗṪL

Läuft ungefähr in O (2 ⁿ ) Zeit.

Probieren Sie es online!

Wie es funktioniert

Œ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 bis 19 Byte

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

-3 Bytes dank ETHproductions.

Versuch es

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>

Erläuterung

Multiplizieren Sie die Eingabe mit 8 und addieren Sie 1, erhöhen Sie diese auf die Potenz von 0,5, geben Sie uns die Quadratwurzel, subtrahieren Sie 1 und verschieben Sie das Ergebnis bitweise nach rechts um 1.

Python 2/3, 32 Bytes

Python-Implementierung der Formel für geschlossene Formulare

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

Die Ganzzahldivision //2rundet in Richtung Null, ist also nicht floor( )erforderlich

Haskell , 28 Bytes

Ein bisschen langweilig, aber es ist ziemlich kürzer als die andere Haskell-Lösung und hat einen wirklich schönen, pointfree Ausdruck. Leider könnte ich es nicht kürzer machen, ohne dass das Typensystem im Weg wäre:

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

Probieren Sie es online!

Punktfrei, 33 Bytes

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

Alternativ 33 Bytes

Gleiche Länge wie die Pointfree-Version, aber viel interessanter.

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

Milchstraße , 12 Bytes

'8*1+g1-2/v!

Erläuterung

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 Bytes

Đř△>Ʃ

Erläuterung:

                      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)

Schneller, aber längerer Weg

Pyt , 11 9 Bytes

Đ2*√⌈ř△>Ʃ

Erläuterung:

Đ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

Alternativer Weg - Hafen von Shaggys Antwort

Pyt , 8 7 Bytes

8*⁺√⁻2÷

J , 11 Bytes

2&!inv<.@-*

Probieren Sie es online!

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

Leerzeichen , 111 Bytes

[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]

Buchstaben S(Leerzeichen), T(Tabulator) und (Zeilenvorschub) werden Nnur als Hervorhebungen hinzugefügt.
[..._some_action]nur als Erklärung hinzugefügt.

Probieren Sie es online aus (nur mit Leerzeichen, Tabulatoren und Zeilenumbrüchen).

Erklärung im Pseudocode:

Verwendet die Formel:

HINWEIS: In Whitespace ist keine Quadratwurzel integriert, daher müssen wir dies manuell tun.

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 Bytes

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

Probieren Sie es online!

Könnte auch meinen eigenen Beitrag zur Mischung hinzufügen. Dies ist kürzer als die Partitionsiterationslösung in Vitsy.

Oase , 14 Bytes

n8*1+1tm1%_b+0

Probieren Sie es online!

Wie?

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

             0  f(0) is 0

Dies ist eine rekursive Lösung, die das Ergebnis erhöht, wenn sie auf einen Dreieckindex stößt, der mit 0 für die Eingabe 0 beginnt.

Perl 5 -p , 19 (++) Bytes

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

Probieren Sie es online!

Ruby , 27 Bytes

Drei zum Preis von einem. Ich bin enttäuscht, dass ich nicht kürzer werden kann.

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

Probieren Sie es online! (Um die Funktion auszuwählen, fügen Sie f = davor hinzu.)