Tiré de: OEIS- A071816

Votre tâche, étant donné une limite supérieure de n, est de trouver le nombre de solutions qui satisfont l'équation:

a+b+c = x+y+z, where 0 <= a,b,c,x,y,z < n

La séquence commence comme décrit sur la page OEIS, et comme ci-dessous (indexé 1):

1, 20, 141, 580, 1751, 4332, 9331, 18152, 32661, 55252, 88913, 137292, 204763, 296492, 418503, 577744, 782153, 1040724, 1363573, 1762004, 2248575, 2837164, 3543035, 4382904, 5375005, 6539156, 7896825, 9471196, 11287235, 13371756

Car n = 1, il n'y a qu'une seule solution:(0,0,0,0,0,0)

Pour n = 2, il existe 20 solutions ordonnées (a,b,c,x,y,z)pour a+b+c = x+y+z:

(0,0,0,0,0,0), (0,0,1,0,0,1), (0,0,1,0,1,0), (0,0,1,1,0,0), (0,1,0,0,0,1), 
(0,1,0,0,1,0), (0,1,0,1,0,0), (0,1,1,0,1,1), (0,1,1,1,0,1), (0,1,1,1,1,0), 
(1,0,0,0,0,1), (1,0,0,0,1,0), (1,0,0,1,0,0), (1,0,1,0,1,1), (1,0,1,1,0,1), 
(1,0,1,1,1,0), (1,1,0,0,1,1), (1,1,0,1,0,1), (1,1,0,1,1,0), (1,1,1,1,1,1).

I & O

• L'entrée est un entier unique indiquant n.
• La sortie est un seul entier / chaîne indiquant f(n), où f(...)est la fonction ci-dessus.
• L'indexation est exactement comme décrit, aucune autre indexation n'est acceptable.

Il s'agit du code-golf , le plus petit nombre de victoires d'octets.

Gelée , 9 6 octets

ṗ6ḅ-ċ0

Solution O (n ⁶ ) .

Essayez-le en ligne!

Comment ça fonctionne

ṗ6ḅ-ċ0  Main link. Argument: n

ṗ6      Cartesian power 6; build all 6-tuples (a, x, b, y, c, z) of integers in
        [1, ..., n]. The challenge spec mentions [0, ..., n-1], but since there
        are three summands on each side, this doesn't matter.
  ḅ-    Unbase -1; convert each tuple from base -1 to integer, mapping (a, ..., z)
        to a(-1)**5 + x(-1)**4 + b(-1)**3 + y(-1)**2 + c(-1)**1 + z(-1)**0, i.e.,
        to -a + x - b + y - c + z = (x + y + z) - (a + b + c). This yields 0 if and
        only if the 6-tuple is a match.
    ċ0  Count the number of zeroes.

Mathematica 17 ou 76 octets

En utilisant la formule:

.55#^5+#^3/4+#/5&

(Enregistré 3 octets par @GregMartin et @ngenisis)

Plutôt que d'utiliser la formule, ici, je calcule littéralement toutes les solutions et les compte.

Length@Solve[a+b+c==x+y+z&&And@@Table[(0<=i<#),{i,{a,b,c,x,y,z}}],Integers]&

Haskell , 48 octets

Je n'ai pas remarqué la formule avant d'écrire ceci, donc ce n'est certainement pas la méthode générale la plus courte (ou la plus rapide), mais je pensais que c'était joli.

f n=sum[1|0<-foldr1(-)<$>pure[1..n]`mapM`[1..6]]

Essayez-le en ligne!

f ngénère toutes les listes de 6 éléments à partir de [1..n], puis compte ceux dont la somme alternée est 0. Utilise le fait que a+b+c==d+e+fc'est la même chose a-(d-(b-(e-(c-f))))==0, et aussi que cela n'a pas d'importance si nous ajoutons un 1 à tous les nombres.

MATL , 12 octets

l6:"G:gY+]X>

Essayez-le en ligne!

Explication

Je ne pouvais pas manquer la chance d'utiliser à nouveau la convolution!

Cela utilise la caractérisation suivante d'OEIS:

a(n) = largest coefficient of (1+...+x^(n-1))^6

et bien sûr, la multiplication polynomiale est la convolution.

l        % Push 1
6:"      % Do the following 6 times
  G:g    %   Push a vector of n ones, where n is the input
  Y+     %   Convolution
]        % End
X>       % Maximum

Gelée , 9 octets

ṗ3S€ĠL€²S

Pas aussi court que @ Dennis, mais il se termine en moins de 20 secondes pour l'entrée 100.

Essayez-le en ligne!

Comment ça fonctionne

ṗ3S€ĠL€²S  Main link. Argument: n

ṗ3         Cartesian power; yield all subsets of [1, ..., n] of length 3.
  S€       Sum each. 
    Ġ      Group indices by their values; for each unique sum S, list all indices whose
           values are equal to S.
     L€    Length each; for each unique sum S, yield the number of items in the original
           array that sum to S.
       ²   Square each; for each unique sum S, yield the number of pairs that both sum to S.
        S  Sum; yield the total number of equal pairs.

Pyth, 13 12 octets

JsM^UQ3s/LJJ

Un octet enregistré grâce à Leaky Nun.

Explication

JsM^UQ3s/LJJ
   ^UQ3         Get all triples in the range.
JsM             Save the sums as J.
        /LJJ    Count occurrences of each element of J in J.
       s        Take the sum.

Python 3 , 28 octets

lambda n:.55*n**5+n**3/4+n/5

Essayez-le en ligne!

TI-BASIC, 19 octets

:Prompt X
:.05X(11X^4+5X²+4

Évalue la formule OEIS.

Oasis , 17 octets

5m11*n3m5*nz++20÷

5                   n 5             implicit n for illustration
 m                  n**5
  11                n**5 11
    *               11*n**5
     n              11*n**5 n
      3             11*n**5 n 3
       m            11*n**5 n**3
        5           11*n**5 n**3 5
         *          11*n**5 5*n**3
          n         11*n**5 5*n**3 n
           z        11*n**5 5*n**3 4*n
            +       11*n**5 5*n**3+4*n
             +      11*n**5+5*n**3+4*n
              20    11*n**5+5*n**3+4*n 20
                ÷  (11*n**5+5*n**3+4*n)÷20

Essayez-le en ligne!

Oasis est un langage basé sur la pile optimisé pour les séquences récurrentes. Cependant, la formule de récursivité serait trop longue pour ce cas.

Brachylog , 17 octets

{>ℕ|↰}ᶠ⁶ḍD+ᵐ=∧D≜ᶜ

Essayez-le en ligne!

Explication

{  |↰}ᶠ⁶           Generate a list of 6 variables [A,B,C,D,E,F]...
 >ℕ                  ...which are all in the interval [0, Input)
        ḍD         Dichotomize; D = [[A,B,C],[D,E,F]]
          +ᵐ=      A + B + C must be equal to D + E + F
             ∧
              D≜ᶜ  Count the number of possible ways you can label the elements of D while
                     satisfying the constraints they have

JavaScript, 24 octets

x=>11*x**5/20+x**3/4+x/5

Utilise la formule de la page OEIS.

Essayez-le en ligne!

Octave , 25 23 21 octets

@(n).55*n^5+n^3/4+n/5

Essayez-le en ligne!

Utilise la formule de l'entrée OEIS. Enregistré deux quatre octets en réorganisant la formule et en utilisant .55au lieu de 11/20, grâce à fəˈnɛtɪk.

Python 2,7, 109 105 99 96 octets

Merci à ETHproductions et Dennis d'avoir économisé quelques octets:

from itertools import*
lambda s:sum(sum(x[:3])==sum(x[3:])for x in product(range(s),repeat=6))

Mathematica, 52 octets

La mise en œuvre de la formule OEIS par Kelly Lowder est beaucoup plus courte, mais cela calcule les chiffres directement:

Count[Tr/@#~Partition~3&/@Range@#~Tuples~6,{n_,n_}]&

Eh bien, il compte en fait le nombre de solutions avec 1 <= a,b,c,x,y,z <= n. C'est le même nombre, car l'ajout de 1 à toutes les variables ne change pas l'égalité.

Explication: Range@#~Tuples~6crée toutes les listes de six entiers entre 1 et n, #~Partition~3&/@divise chaque liste en deux listes de longueur 3, Tr/@additionne ces sous-listes et Count[...,{n_,n_}]compte le nombre de paires ayant la même somme. J'ai eu beaucoup de chance avec l'ordre de priorité entre f @, f /@et ~f~!

Octave , 41 octets

@(n)round(max(ifft(fft(~~(1:n),n^2).^6)))

Essayez-le en ligne!

Similaire à ma réponse MATL , mais calcule la convolution via une transformée de Fourier discrète ( fft) avec un nombre suffisant de points ( n^2). ~~(1:n)est utilisé comme une version plus courte de ones(1,n). roundest nécessaire en raison d'erreurs en virgule flottante.

CJam , 17 octets

ri,6m*{3/::+:=},,

Saisie des 11temps morts sur TIO 12et plus de mémoire.

Essayez-le en ligne!

Explication

ri                e# Read an int from input.
  ,               e# Generate the range 0 ... input-1.
   6m*            e# Take the 6th Cartesian power of the range.
      {           e# Keep only the sets of 6 values where:
       3/         e#  The set split into (two) chunks of 3
         ::+:=    e#  Have the sums of both chunks equal.
              },  e# (end of filter)
                , e# Get the length of the resulting list.

Clojure, 79 octets

#(count(for[r[(range %)]a r b r c r x r y r z r :when(=(+ a b c)(+ x y z))]1))

Des tonnes de répétition dans le code, sur un plus grand nombre de variables, une macro peut être plus courte.