La tâche

Étant donné un entier positif en entrée n(de 1 à la limite de votre langue, inclusivement), retournez ou sortez le nombre maximum d'entiers positifs distincts qui totalisent n.

Cas de test

Soit fdéfinir une fonction valide en fonction de la tâche:

La séquence pour f, à partir de 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, ...

En tant que cas de test plus grand:

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

Code de test

Pour tous les cas de test non explicitement fournis, la sortie de votre code doit correspondre au résultat de ce qui suit:

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

Essayez-le en ligne!

05AB1E , 4 octets

ÅTg<

Essayez-le en ligne!

Outil parfait pour le travail.

ÅTdonne la liste des Å ll T numéros riangular jusqu'au N (y compris , malheureusement , 0 aussi, sinon il serait 3 octets), g<obtient le len g e et décrémente.

Gelée , 6 5 octets

R+\»ċ

Essayez-le en ligne!

Assez efficace. Cette séquence s'incrémente aux nombres triangulaires, donc cela compte juste combien de nombres triangulaires sont plus petits que n .

Explication:

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

-2 octets grâce à H.PWiz.

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

Essayez-le en ligne!

Cela renvoie le nième élément des nombres entiers où chaque i est répliqué i + 1 fois.

Brain-Flak , 36 octets

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

Essayez-le en ligne!

Il utilise la même structure que l'algorithme de division standard, sauf que le "diviseur" est incrémenté à chaque lecture.

Pari / GP , 19 octets

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

Essayez-le en ligne!

Brain-Flak , 82 octets

Ajout d'un espace blanc pour la "lisibilité"

(())

{
    {}

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

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

}{}{}{}

([]<>)

Essayez-le en ligne!

Gelée , 7 octets

×8‘½’:2

Essayez-le en ligne!

Gelée , 9 octets

Ḥ+4ݤ½_.Ḟ

Essayez-le en ligne!

C'est plus long que Dennis et DJ, mais cette fois exprès . Très, très efficace .

R , 28 octets

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

Essayez-le en ligne!

Crée le vecteur des temps 1répétés 2, 2des 3temps répétés , ..., ndes n+1temps répétés et prend l' nthélément. Cela entraînera une erreur de mémoire soit parce qu'elle 1:nest trop grande, soit parce que la liste répétée avec des n*(n+1)/2 - 1éléments est trop grande.

R , 29 octets

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

Essayez-le en ligne!

Calcule la valeur directement, en utilisant la formule trouvée dans la réponse d'alephalpha . Cela devrait fonctionner sans problème, à part la précision numérique possible.

R , 30 octets

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

Essayez-le en ligne!

Compte les nombres triangulaires inférieurs ou égaux à n. Ce sera peut-être une erreur de mémoire si elle 1:nest suffisamment grande - par exemple, 1e9elle lance Error: cannot allocate vector of size 3.7 Gb.

APL (Dyalog) , 8 octets

+/+\∘⍳<⊢

Essayez-le en ligne!

TI-Basic, 12 octets

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

JavaScript (Node.js) , 18 octets

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

Essayez-le en ligne!

Japt , 8 octets

Solution de formule fermée.

*8Ä ¬É z

Essayez-le

Explication

Multipliez par 8, ajoutez 1 ( Ä), obtenez la racine carrée ( ¬), soustrayez 1 ( É) et plancher divisez le résultat par 2 ( z).

Alternative, 8 octets

Port de la solution Jelly de DJMcMayhem .

õ å+ è§U

Essayez-le

Générez un tableau d'entiers ( õ) de 1 à l'entrée, réduisez cumulativement ( å) par addition ( +) et comptez ( è) les éléments inférieurs ou égaux à ( §) l'entrée ( U).

Befunge, 32 20 octets

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

Essayez-le en ligne!

Brain-Flak , 70 56 48 octets

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

Essayez-le en ligne!

Explication

La partie principale de ceci est l'extrait suivant que j'ai écrit:

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

Cela ne fera rien si le TOS est positif et changera de pile dans le cas contraire. C'est super pile impur mais ça marche. Maintenant, la partie principale du programme soustrait des nombres de plus en plus importants de l'entrée jusqu'à ce que l'entrée soit non positive. Nous démarrons l'accumulateur à 1 à chaque fois en soustrayant 1 de plus que l'accumulateur de l'entrée.

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

Nous pouvons mettre cela à l'intérieur de l'extrait ci-dessus

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

Cela est mis en boucle pour qu'il s'exécute jusqu'à ce que nous changions de pile. Une fois la boucle terminée, nous récupérons l'accumulateur en changeant de pile et en supprimant les fichiers indésirables.

Pyth , 7 octets

lh{I#./

Essayez-le en ligne!

Filtrez-gardez les partitions entières qui sont Invariantes par rapport à la déduplication, saisissez l' head et obtenez sonl ength.

Preuve de validité

_{^{Pas très rigoureux ni bien formulé.}}

Soit A = a ₁ + a ₂ + ... + a _n et B = b ₁ + b ₂ + ... + b _m soit deux partitions distinctes d'un même nombre entier N . Nous supposerons que A est la partition unique la plus longue . Après nous dédupliquer B , qui est, remplacer plusieurs occurrences du même entier avec un seul d'entre eux, nous savons que la somme de B est inférieure à N . Mais nous savons également que le résultat de la fonction augmente (non strictement), nous pouvons donc déduire que la partition unique A la plus longue a toujours au moins la même quantité d'éléments que le nombre d'éléments uniques dans d'autres partitions.

Triangularité , 49 octets

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

Essayez-le en ligne!

Comment ça fonctionne

La triangularité nécessite que le code ait une distribution triangulaire des points. Autrement dit, la longueur de chaque ligne doit être égale au nombre de lignes multiplié par 2 et décrémenté, et chaque ligne doit avoir (de chaque côté) un nombre de points égal à sa position dans le programme (la ligne du bas est la ligne 0, celui au-dessus est la ligne 1 et ainsi de suite). Il n'y a que quelques commandes, et tout caractère autre que ceux répertoriés sur la page 'Wiki / Commandes' est traité comme un no-op (les points étrangers n'affectent en rien le programme, tant que la forme globale du programme reste rectangulaire).

Notez que pour les commandes à deux arguments, j'ai utilisé un et b tout au long de l'explication. Gardant cela à l'esprit, voyons ce que fait le programme réel, après avoir supprimé tous les caractères étrangers qui composent le remplissage:

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

Une solution alternative, et plus courte si le rembourrage n'est pas nécessaire:

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

Essayez-le en ligne!

PowerShell 3.0, 45 octets

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

L'appel mathématique fait mal et l'arrondi du banquier de PS est le diable réel (d'où la nécessité de regex pour tronquer pour enregistrer un octet), mais cela semble assez bien.

Java (JDK) , 28 octets

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

Essayez-le en ligne!

Parce que l'exemple n'était vraiment pas bien joué: p

Crédits

• -2 octets grâce à Kevin Cruijssen

Gelée , 7 octets

ŒPfŒṗṪL

Fonctionne approximativement en temps O (2 ⁿ ) .

Essayez-le en ligne!

Comment ça fonctionne

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

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

-3 octets grâce à ETHproductions.

Essayez-le

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>

Explication

Multipliez l'entrée par 8 et ajoutez 1, augmentez cela à la puissance de 0,5, en nous donnant la racine carrée, soustrayez 1 et décalez le résultat de 1 à droite.

Python 2/3, 32 octets

Implémentation Python de la formule sous forme fermée

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

La division entière est //2arrondie vers zéro, donc pas floor( )nécessaire

Haskell , 28 octets

Un peu ennuyeux, mais il est assez court que l 'autre solution Haskell et a une très belle expression sans point. Malheureusement, je ne pouvais pas le raccourcir sans que le système de type ne gêne:

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

Essayez-le en ligne!

Sans point, 33 octets

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

Alternativement, 33 octets

Même longueur que la version sans point, mais beaucoup plus intéressante.

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

Voie lactée , 12 octets

'8*1+g1-2/v!

Explication

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 octets

Đř△>Ʃ

Explication:

                      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)

Plus rapide, mais plus long

Pyt , 11 9 octets

Đ2*√⌈ř△>Ʃ

Explication:

Đ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

Voie alternative - port de la réponse Shaggy

Pyt , 8 7 octets

8*⁺√⁻2÷

J , 11 octets

2&!inv<.@-*

Essayez-le en ligne!

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

Espace blanc , 111 octets

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

Lettres S(espace), T(tabulation) etN (nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté à titre d'explication uniquement.

Essayez-le en ligne (avec des espaces bruts, des tabulations et des nouvelles lignes uniquement).

Explication en pseudo-code:

Utilise la formule:

REMARQUE: les espaces blancs n'ont pas de racine carrée intégrée, nous devons donc le faire manuellement.

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 octets

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

Essayez-le en ligne!

Autant ajouter ma propre contribution au mix. C'est plus court que la solution d'itérations de partition dans Vitsy.

Oasis , 14 octets

n8*1+1tm1%_b+0

Essayez-le en ligne!

Comment?

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

             0  f(0) is 0

Il s'agit d'une solution récursive qui incrémente le résultat lorsqu'il rencontre un index triangulaire, en commençant par 0 pour l'entrée 0.

Perl 5 -p , 19 (++) octets

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

Essayez-le en ligne!

Rubis , 27 octets

Trois pour le prix d'un. Je suis déçu de ne pas pouvoir aller plus court.

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

Essayez-le en ligne! (pour sélectionner la fonction, ajoutez f = devant)